def transferTCoords(): input = paf.GetInputDataObject(0,0) refin = paf.GetInputList().GetItem(0) output = paf.GetPolyDataOutput() # output.CopyStructure(input) # output.CopyAttributes(input) TCorig = refin.GetPointData().GetTCoords() Norig = refin.GetPointData().GetNormals() TC = vtk.vtkFloatArray() TC.SetNumberOfComponents(TCorig.GetNumberOfComponents()) TC.SetNumberOfTuples(TCorig.GetNumberOfTuples()) TC.SetName('Texture Coordinates') for ii in range(TCorig.GetNumberOfTuples()): ff = TCorig.GetTuple2(ii) TC.SetTuple2(ii,ff[0],ff[1]) NN = vtk.vtkFloatArray() NN.SetNumberOfComponents(Norig.GetNumberOfComponents()) NN.SetNumberOfTuples(Norig.GetNumberOfTuples()) NN.SetName('normals') for ii in range(Norig.GetNumberOfTuples()): ff = Norig.GetTuple3(ii) NN.SetTuple3(ii,ff[0],ff[1],ff[2]) output.GetPointData().AddArray(TC) output.GetPointData().SetActiveTCoords('Texture Coordinates') output.GetPointData().AddArray(NN) output.GetPointData().SetActiveNormals('normals')
def get_vtk_data(self,geo): """Returns dictionary of VTK data arrays from rock types. The geometry object geo must be passed in.""" from vtk import vtkIntArray,vtkFloatArray,vtkCharArray arrays={'Block':{'Rock type index':vtkIntArray(),'Porosity':vtkFloatArray(), 'Permeability':vtkFloatArray(),'Name':vtkCharArray()},'Node':{}} vector_properties=['Permeability'] string_properties=['Name'] string_length=5 nele=geo.num_underground_blocks array_length={'Block':nele,'Node':0} for array_type,array_dict in arrays.items(): for name,array in array_dict.items(): array.SetName(name) if name in vector_properties: array.SetNumberOfComponents(3) array.SetNumberOfTuples(array_length[array_type]) elif name in string_properties: array.SetNumberOfComponents(string_length) array.SetNumberOfTuples(array_length[array_type]) else: array.SetNumberOfComponents(1) array.SetNumberOfValues(array_length[array_type]) natm=geo.num_atmosphere_blocks rindex=self.rocktype_indices[natm:] for i,ri in enumerate(rindex): arrays['Block']['Rock type index'].SetValue(i,ri) rt=self.rocktypelist[ri] arrays['Block']['Porosity'].SetValue(i,rt.porosity) k=rt.permeability arrays['Block']['Permeability'].SetTuple3(i,k[0],k[1],k[2]) for i,blk in enumerate(self.blocklist[natm:]): arrays['Block']['Name'].SetTupleValue(i,blk.name) return arrays
def findLocalCsys(self, filename): poly = vtk.vtkGeometryFilter() poly.SetInputData(self.vtkMeshes[filename]) poly.Update() distanceFilter = vtk.vtkImplicitPolyDataDistance() distanceFilter.SetInput(poly.GetOutput()) gradients = vtk.vtkFloatArray() gradients.SetNumberOfComponents(3) gradients.SetName("LevelSet Normals") distances = vtk.vtkFloatArray() distances.SetNumberOfComponents(1) distances.SetName("Signed Distances") N = self.vtkMeshes[filename].GetCellData().GetArray( "Centroids").GetNumberOfTuples() for i in range(N): g = np.zeros(3, np.float32) p = self.vtkMeshes[filename].GetCellData().GetArray( "Centroids").GetTuple3(i) d = distanceFilter.EvaluateFunction(p) distanceFilter.EvaluateGradient(p, g) g = old_div(np.array(g), np.linalg.norm(np.array(g))) gradients.InsertNextTuple(g) distances.InsertNextValue(d) self.vtkMeshes[filename].GetCellData().AddArray(gradients) self.vtkMeshes[filename].GetCellData().AddArray(distances)
def addPlot(self,_plotName,_style="Lines"): # called directly from Steppable; add a (possibly more than one) plot to a plot window self.plotWindowInterfaceMutex.lock() # self.plotWindowMutex.lock() # return # print MODULENAME,' addPlot(): _plotName= ',_plotName # import pdb; pdb.set_trace() # self.plotData[_plotName] = [array([],dtype=double),array([],dtype=double),False] # 'array': from PyQt4.Qwt5.anynumpy import * self.chart = vtk.vtkChartXY() # self.chart.GetAxis(vtk.vtkAxis.LEFT).SetLogScale(True) # self.chart.GetAxis(vtk.vtkAxis.BOTTOM).SetLogScale(True) # self.numCharts += 1 self.plotData[_plotName] = [self.chart] self.view = vtk.vtkContextView() self.ren = self.view.GetRenderer() # self.renWin = self.qvtkWidget.GetRenderWindow() self.renWin = self.pW.GetRenderWindow() self.renWin.AddRenderer(self.ren) # Create a table with some points in it self.table = vtk.vtkTable() self.arrX = vtk.vtkFloatArray() self.arrX.SetName("xarray") self.arrC = vtk.vtkFloatArray() self.arrC.SetName("yarray") numPoints = 5 numPoints = 15 inc = 7.5 / (numPoints - 1) # for i in range(0,numPoints): # self.arrX.InsertNextValue(i*inc) # self.arrC.InsertNextValue(math.cos(i * inc) + 0.0) # self.arrX.InsertNextValue(0.0) # self.arrC.InsertNextValue(0.0) # self.arrX.InsertNextValue(0.1) # self.arrC.InsertNextValue(0.1) self.table.AddColumn(self.arrX) self.table.AddColumn(self.arrC) # Now add the line plots with appropriate colors self.line = self.chart.AddPlot(0) self.line.SetInput(self.table,0,1) self.line.SetColor(0,0,255,255) self.line.SetWidth(1.0) self.view.GetRenderer().SetBackground([0.6,0.6,0.1]) self.view.GetRenderer().SetBackground([1.0,1.0,1.0]) self.view.GetScene().AddItem(self.chart) self.plotWindowInterfaceMutex.unlock()
def testLinePlot(self): "Test if line plots can be built with python" # Set up a 2D scene, add an XY chart to it view = vtk.vtkContextView() view.GetRenderer().SetBackground(1.0,1.0,1.0) view.GetRenderWindow().SetSize(400,300) chart = vtk.vtkChartXY() view.GetScene().AddItem(chart) # Create a table with some points in it table = vtk.vtkTable() arrX = vtk.vtkFloatArray() arrX.SetName("X Axis") arrC = vtk.vtkFloatArray() arrC.SetName("Cosine") arrS = vtk.vtkFloatArray() arrS.SetName("Sine") arrS2 = vtk.vtkFloatArray() arrS2.SetName("Sine2") numPoints = 69 inc = 7.5 / (numPoints - 1) for i in range(0,numPoints): arrX.InsertNextValue(i*inc) arrC.InsertNextValue(math.cos(i * inc) + 0.0) arrS.InsertNextValue(math.sin(i * inc) + 0.0) arrS2.InsertNextValue(math.sin(i * inc) + 0.5) table.AddColumn(arrX) table.AddColumn(arrC) table.AddColumn(arrS) table.AddColumn(arrS2) # Now add the line plots with appropriate colors line = chart.AddPlot(0) line.SetInput(table,0,1) line.SetColor(0,255,0,255) line.SetWidth(1.0) line = chart.AddPlot(0) line.SetInput(table,0,2) line.SetColor(255,0,0,255); line.SetWidth(5.0) line = chart.AddPlot(0) line.SetInput(table,0,3) line.SetColor(0,0,255,255); line.SetWidth(4.0) view.GetRenderWindow().SetMultiSamples(0) img_file = "TestLinePlot.png" vtk.test.Testing.compareImage(view.GetRenderWindow(),vtk.test.Testing.getAbsImagePath(img_file),threshold=25) vtk.test.Testing.interact()
def ndarray_to_vtkarray(colors, radius, nbat): # define the colors color_scalars = vtk.vtkFloatArray() for c in colors: color_scalars.InsertNextValue(c) color_scalars.SetName("colors") # some radii radius_scalars = vtk.vtkFloatArray() for r in radius: radius_scalars.InsertNextValue(r) radius_scalars.SetName("radius") # the original index index_scalars = vtk.vtkIntArray() for i in range(nbat): index_scalars.InsertNextValue(i) radius_scalars.SetName("index") scalars = vtk.vtkFloatArray() scalars.SetNumberOfComponents(3) scalars.SetNumberOfTuples(radius_scalars.GetNumberOfTuples()) scalars.CopyComponent(0, radius_scalars ,0 ) scalars.CopyComponent(1, color_scalars ,0 ) scalars.CopyComponent(2, index_scalars ,0 ) scalars.SetName("scalars") return scalars
def testBufferShared(self): """Test the special buffer_shared() check that VTK provides.""" a = bytearray(b'hello') self.assertEqual(vtk.buffer_shared(a, a), True) b = bytearray(b'hello') self.assertEqual(vtk.buffer_shared(a, b), False) a = vtk.vtkFloatArray() a.SetNumberOfComponents(3) a.InsertNextTuple((10, 7, 4)) a.InsertNextTuple((85, 8, 2)) b = vtk.vtkFloatArray() b.SetVoidArray(a, 6, True) self.assertEqual(vtk.buffer_shared(a, b), True) c = vtk.vtkFloatArray() c.DeepCopy(a) self.assertEqual(vtk.buffer_shared(a, c), False) if sys.hexversion >= 0x02070000: m = memoryview(a) self.assertEqual(vtk.buffer_shared(a, m), True) if sys.hexversion < 0x03000000: m = buffer(a) self.assertEqual(vtk.buffer_shared(a, m), True)
def BlenderToPolyData(me, uvlayer=None): pcoords = vtk.vtkFloatArray() pcoords.SetNumberOfComponents(3) pcoords.SetNumberOfTuples(len(me.verts)) for i in range(len(me.verts)): p0 = me.verts[i].co[0] p1 = me.verts[i].co[1] p2 = me.verts[i].co[2] pcoords.SetTuple3(i, p0, p1, p2) points = vtk.vtkPoints() points.SetData(pcoords) polys = vtk.vtkCellArray() lines = vtk.vtkCellArray() for face in me.faces: if len(face.v) == 4: polys.InsertNextCell(4) polys.InsertCellPoint(face.v[0].index) polys.InsertCellPoint(face.v[1].index) polys.InsertCellPoint(face.v[2].index) polys.InsertCellPoint(face.v[3].index) elif len(face.v) == 3: polys.InsertNextCell(3) polys.InsertCellPoint(face.v[0].index) polys.InsertCellPoint(face.v[1].index) polys.InsertCellPoint(face.v[2].index) elif len(face.v) == 2: lines.InsertNextCell(2) lines.InsertCellPoint(face.v[0].index) lines.InsertCellPoint(face.v[1].index) for edge in me.edges: lines.InsertNextCell(2) lines.InsertCellPoint(edge.v1.index) lines.InsertCellPoint(edge.v2.index) pdata =vtk.vtkPolyData() pdata.SetPoints(points) pdata.SetPolys(polys) pdata.SetLines(lines) if me.faceUV: if uvlayer: uvnames = me.getUVLayerNames() if uvlayer in uvnames: me.activeUVLayer = uvlayer tcoords = vtk.vtkFloatArray() tcoords.SetNumberOfComponents(2) tcoords.SetNumberOfTuples(len(me.verts)) for face in me.faces: for i in range(len(face.verts)): uv = face.uv[i] tcoords.SetTuple2(face.v[i].index, uv[0], uv[1]) pdata.GetPointData().SetTCoords(tcoords); pdata.Update() return pdata
def ndarray_to_vtkarray(colors, radius, nbat): # define the colours color_scalars = vtk.vtkFloatArray() color_scalars.SetNumberOfValues(colors.shape[0]) for i,c in enumerate(colors): color_scalars.SetValue(i,c) color_scalars.SetName("colors") # some radii radius_scalars = vtk.vtkFloatArray() radius_scalars.SetNumberOfValues(radius.shape[0]) for i,r in enumerate(radius): radius_scalars.SetValue(i,r) radius_scalars.SetName("radius") # the original index index_scalars = vtk.vtkIntArray() index_scalars.SetNumberOfValues(nbat) for i in range(nbat): index_scalars.SetValue(i,i) index_scalars.SetName("index") scalars = vtk.vtkFloatArray() scalars.SetNumberOfComponents(3) scalars.SetNumberOfTuples(radius_scalars.GetNumberOfTuples()) scalars.CopyComponent(0, radius_scalars ,0 ) scalars.CopyComponent(1, color_scalars ,0 ) scalars.CopyComponent(2, index_scalars ,0 ) scalars.SetName("scalars") return scalars
def section_CreateTable(self): self.delayDisplay("Create table",self.delayMs) tableNode = slicer.mrmlScene.AddNewNodeByClass("vtkMRMLTableNode", self.tableName) self.assertIsNotNone(tableNode) table = tableNode.GetTable() self.assertIsNotNone(table) # Create X, Y1, and Y2 series arrX = vtk.vtkFloatArray() arrX.SetName(self.xColumnName) table.AddColumn(arrX) arrY1 = vtk.vtkFloatArray() arrY1.SetName(self.y1ColumnName) table.AddColumn(arrY1) arrY2 = vtk.vtkFloatArray() arrY2.SetName(self.y2ColumnName) table.AddColumn(arrY2) # Fill in the table with some example values import math numPoints = 69 inc = 7.5 / (numPoints - 1) table.SetNumberOfRows(numPoints) for i in range(numPoints): table.SetValue(i, 0, i * inc ) table.SetValue(i, 1, math.cos(i * inc)) table.SetValue(i, 2, math.sin(i * inc))
def generateMesh(self, x, y, z, in_x, in_y, in_z): x_coord = vtk.vtkFloatArray() x_coord.InsertNextValue(x) y_coord = vtk.vtkFloatArray() y_coord.InsertNextValue(y) z_coord = vtk.vtkFloatArray() z_coord.InsertNextValue(z) grid = vtk.vtkRectilinearGrid() grid.SetDimensions(self.nx if in_x else 1, self.ny if in_y else 1, self.nz if in_z else 1) grid.SetXCoordinates(self.x_coords if in_x else x_coord); grid.SetYCoordinates(self.y_coords if in_y else y_coord); grid.SetZCoordinates(self.z_coords if in_z else z_coord); # We're going to generate all of the IDs of the cells in that rectilinear grid so we can extract them as an UnstructuredGrid # Why would we do such a thing? Because there is some bug associated with RecitilinearGrids and clipping / rendering # So, instead I'm going to use RectilinearGrid for generating the cells and then "copy" it to an UnstructuredGrid using ExtractCells num_cells = grid.GetNumberOfCells() id_list = vtk.vtkIdList() for i in xrange(num_cells): id_list.InsertNextId(i) extract = vtk.vtkExtractCells() if vtk.VTK_MAJOR_VERSION <= 5: extract.SetInput(grid) else: extract.SetInputData(grid) extract.SetCellList(id_list) return extract.GetOutput()
def removeOldGeometry(self, fileName): if fileName is None: self.grid = vtk.vtkUnstructuredGrid() self.gridResult = vtk.vtkFloatArray() #self.emptyResult = vtk.vtkFloatArray() #self.vectorResult = vtk.vtkFloatArray() self.grid2 = vtk.vtkUnstructuredGrid() self.scalarBar.VisibilityOff() skipReading = True else: self.TurnTextOff() self.grid.Reset() self.grid2.Reset() self.gridResult = vtk.vtkFloatArray() self.gridResult.Reset() self.gridResult.Modified() self.eidMap = {} self.nidMap = {} self.resultCases = {} self.nCases = 0 try: del self.caseKeys del self.iCase del self.iSubcaseNameMap except: print "cant delete geo" pass ### #print dir(self) skipReading = False self.scalarBar.VisibilityOff() self.scalarBar.Modified() return skipReading
def compute_scalar_measures(pd): tensors = pd.GetPointData().GetTensors() lines = pd.GetLines() fa = vtk.vtkFloatArray() lambda_parallel = vtk.vtkFloatArray() lambda_perp = vtk.vtkFloatArray() #fa_array = list() for tidx in range(tensors.GetNumberOfTuples()): if (tidx % 5000) == 0: print tidx, '/', tensors.GetNumberOfTuples() D = tensors.GetTuple9(tidx) D = numpy.array(D).reshape(3,3) w, v = numpy.linalg.eig(D) fa_tidx = fractional_anisotropy(w) lambda_parallel_tidx = w[2] lambda_perp_tidx = (w[0] + w[1])/2.0 fa.InsertNextTuple1(fa_tidx) lambda_parallel.InsertNextTuple1(lambda_parallel_tidx) lambda_perp.InsertNextTuple1(lambda_perp_tidx) fa_avg = vtk.vtkFloatArray() fa_lines_list = list() fa_avg_list = list() lines.InitTraversal() for lidx in range(0, pd.GetNumberOfLines()): if (lidx % 100) == 0: print lidx, '/', pd.GetNumberOfLines() pts = vtk.vtkIdList() #lines.GetCell(lidx, pts) lines.GetNextCell(pts) # compute average FA for this line if pts.GetNumberOfIds(): fa_list = list() for pidx in range(0, pts.GetNumberOfIds()): fa_list.append(fa.GetTuple1(pts.GetId(pidx))) #fa_avg.InsertNextTuple1(numpy.mean(numpy.array(fa_list))) fa_avg.InsertNextTuple1(numpy.median(numpy.array(fa_list))) fa_lines_list.append(fa_list) fa_avg_list.append(numpy.median(numpy.array(fa_list))) else: fa_avg.InsertNextTuple1(0.0) fa_lines_list.append([0.0]) fa_avg.SetName('mean_FA') fa.SetName('FA') lambda_parallel.SetName('parallel_diffusivity') lambda_perp.SetName('perpendicular_diffusivity') outpd = pd outpd.GetCellData().AddArray(fa_avg) outpd.GetCellData().SetActiveScalars('mean_FA') outpd.GetPointData().AddArray(fa) outpd.GetPointData().AddArray(lambda_parallel) outpd.GetPointData().AddArray(lambda_perp) outpd.GetPointData().SetActiveScalars('FA') return outpd, fa_lines_list, fa_avg_list
def writeVTR(vtr_name, scalar_fields, vector_fields, vtkX, vtkY, vtkZ, localZrange): """Writes a single VTR file per Python processor/variable Parameters: vtr_name - name of the VTR file scalar_fields - dictionary with scalar field arrays ordered [x, y, z], e.g. {'p': array[nx,ny,nz], 'rho0': array[nx,ny,nz]} vector_fields - dictionary with vector fields ordered [3, x, y, z], e.g. {'J': array[3,nx,ny,nz], 'B': array[3,nx,ny,nz]} vtkX, vtkY, vtkZ - VTR coordinates, see createVtrCoordinates() localZrange - local range for Z indices """ Nx = vtkX.GetNumberOfTuples() - 1 Ny = vtkY.GetNumberOfTuples() - 1 Nz=0 #2D numpoints = (Nx+1)*(Ny+1)*(Nz+1) rtg = vtk.vtkRectilinearGrid() rtg.SetExtent(0, Nx, 0, Ny, localZrange[0], localZrange[1]) rtg.SetXCoordinates(vtkX) rtg.SetYCoordinates(vtkY) vtk_data = [] array_list = [] for f in scalar_fields: vtk_data.append(vtk.vtkFloatArray()) vtk_data[-1].SetNumberOfTuples(numpoints) vtk_data[-1].SetNumberOfComponents(1) array_list.append(scalar_fields[f].swapaxes(0,2).flatten().astype("float32")) vtk_data[-1].SetVoidArray(array_list[-1], numpoints, 1) vtk_data[-1].SetName(f) if f == scalar_fields.keys()[0]: rtg.GetPointData().SetScalars(vtk_data[-1]) else: rtg.GetPointData().AddArray(vtk_data[-1]) #end for for f in vector_fields: vtk_data.append(vtk.vtkFloatArray()) vtk_data[-1].SetNumberOfTuples(numpoints*3) vtk_data[-1].SetNumberOfComponents(3) array_list.append(vector_fields[f].swapaxes(0,3).swapaxes(1,2).flatten().astype("float32")) vtk_data[-1].SetVoidArray(array_list[-1], numpoints*3, 1) vtk_data[-1].SetName(f) if f == vector_fields.keys()[0]: rtg.GetPointData().SetVectors(vtk_data[-1]) else: rtg.GetPointData().AddArray(vtk_data[-1]) #end for try: writer = vtk.vtkXMLRectilinearGridWriter() writer.SetFileName(vtr_name) writer.SetInput(rtg) writer.Write() except: print 'Error writing VTR file: ', vtr_name
def array_to_vtk(array_in, dtype=None): """Get vtkFloatArray/vtkDoubleArray from the input numpy array.""" if dtype == None: dtype = _numpy.dtype(array_in.dtype) else: dtype = _numpy.dtype(dtype) if dtype == _numpy.float32: float_array = _vtk.vtkFloatArray() elif dtype == _numpy.float64: float_array = _vtk.vtkDoubleArray() elif dtype == _numpy.uint8: float_array = _vtk.vtkUnsignedCharArray() elif dtype == _numpy.int8: float_array = _vtk.vtkCharArray() else: raise ValueError("Wrong format of input array, must be float32 or float64") if len(array_in.shape) != 1 and len(array_in.shape) != 2: raise ValueError("Wrong shape: array must be 1D or 2D.") #float_array.SetNumberOfComponents(_numpy.product(array_in.shape)) # if len(array_in.shape) == 2: # float_array.SetNumberOfComponents(array_in.shape[1]) # elif len(array_in.shape) == 1: # float_array.SetNumberOfComponents(1) float_array.SetNumberOfComponents(1) array_contiguous = _numpy.ascontiguousarray(array_in, dtype) float_array.SetVoidArray(array_contiguous, _numpy.product(array_in.shape), 1) float_array._contiguous_array = array_contiguous # Hack to keep the array of being garbage collected # if len(array_in.shape) == 2: # print "set tuple to {0}".format(array_in.shape[1]) # #float_array.SetNumberOfTuples(array_in.shape[1]) # float_array.Resize(array_in.shape[1]) # float_array.Squeeze() return float_array
def _format_output_polydata(output_polydata, cluster_idx, color, embed): """ Output polydata with embedding colors, cluster numbers, and embedding coordinates. Cell data array names are: EmbeddingColor ClusterNumber EmbeddingCoordinate """ embed_colors = vtk.vtkUnsignedCharArray() embed_colors.SetNumberOfComponents(3) embed_colors.SetName('EmbeddingColor') cluster_colors = vtk.vtkIntArray() cluster_colors.SetName('ClusterNumber') embed_data = vtk.vtkFloatArray() embed_data.SetNumberOfComponents(embed.shape[1]) embed_data.SetName('EmbeddingCoordinate') for lidx in range(0, output_polydata.GetNumberOfLines()): embed_colors.InsertNextTuple3( color[lidx, 0], color[lidx, 1], color[lidx, 2]) cluster_colors.InsertNextTuple1(int(cluster_idx[lidx])) embed_data.InsertNextTupleValue(embed[lidx, :]) output_polydata.GetCellData().AddArray(embed_data) output_polydata.GetCellData().AddArray(cluster_colors) output_polydata.GetCellData().AddArray(embed_colors) output_polydata.GetCellData().SetActiveScalars('EmbeddingColor') return output_polydata
def draw(self, renderer): ### FIXME this should be made faster (C++ Module? How to deal with C++ linkage problems?) ### Sticking the vtkPoints objects in a cache would help somewhat but not on the first view. ### - Jack if not self.drawn: vtk_points = vtkPoints() points = self.visualiser.getQuantityPoints(self.quantityName, dynamic=self.dynamic) nPoints = len(points) vtk_points.SetNumberOfPoints(nPoints) setPoint = vtkPoints.SetPoint for i in xrange(nPoints): z = points[i] * self.zScale + self.offset setPoint(vtk_points, i, self.visualiser.xPoints[i], self.visualiser.yPoints[i], z) polyData = vtkPolyData() polyData.SetPoints(vtk_points) polyData.SetPolys(self.visualiser.vtk_cells) mapper = vtkPolyDataMapper() mapper.SetInput(polyData) setValue = vtkFloatArray.SetValue if hasattr(self.colour[0], '__call__'): scalars = self.colour[0](self.visualiser.getQuantityDict()) nScalars = len(scalars) vtk_scalars = vtkFloatArray() vtk_scalars.SetNumberOfValues(nScalars) for i in xrange(nScalars): setValue(vtk_scalars, i, scalars[i]) polyData.GetPointData().SetScalars(vtk_scalars) mapper.SetScalarRange(self.colour[1:3]) mapper.Update() self.actor.SetMapper(mapper) Feature.draw(self, renderer)
def _update_vtk_objects(self): """When n is changed the thus the number of coordinates this function is needed to update the vtk objects with the new number of points.""" # self._vtk_points.SetNumberOfPoints(len(self._points)) # for i, c in enumerate(self._points): # self._vtk_points.InsertPoint(i, c[0], c[1], c[2]) self._vtk_points = _vtk.vtkPoints() for coordinates in self._points: self._vtk_points.InsertNextPoint(coordinates[0], coordinates[1], coordinates[2]) self._vtk_polygons = _vtk.vtkCellArray() for polygon in self._polygons: vtk_polygon = _vtk.vtkPolygon() vtk_polygon.GetPointIds().SetNumberOfIds(3) for local_index, global_index in enumerate(polygon): vtk_polygon.GetPointIds().SetId(local_index, global_index) self._vtk_polygons.InsertNextCell(vtk_polygon) self._vtk_poly_data.SetPoints(self._vtk_points) self._vtk_poly_data.SetPolys(self._vtk_polygons) self._vtk_scalars = _vtk.vtkFloatArray() self._vtk_scalars.SetNumberOfValues(self._vtk_poly_data.GetPoints().GetNumberOfPoints()) for i in range(self._vtk_scalars.GetNumberOfTuples()): self._vtk_scalars.SetValue(i, 0.) self._vtk_poly_data.GetPointData().SetScalars(self._vtk_scalars) self._vtk_poly_data.Modified()
def compute_max_array_along_lines(pd, array_name, output_array_name): lines = pd.GetLines() point_array = pd.GetPointData().GetArray(array_name) point_array_max = vtk.vtkFloatArray() point_array_lines_list = list() point_array_max_list = list() lines.InitTraversal() for lidx in range(0, pd.GetNumberOfLines()): if (lidx % 100) == 0: print lidx, '/', pd.GetNumberOfLines() pts = vtk.vtkIdList() lines.GetNextCell(pts) # compute mean POINT_ARRAY for this line if pts.GetNumberOfIds(): point_array_list = list() for pidx in range(0, pts.GetNumberOfIds()): point_array_list.append(point_array.GetTuple1(pts.GetId(pidx))) point_array_max.InsertNextTuple1(numpy.max(numpy.array(point_array_list))) #fa_max.InsertNextTuple1(numpy.median(numpy.array(fa_list))) else: point_array_max.InsertNextTuple1(0.0) point_array_max.SetName(output_array_name) outpd = pd outpd.GetCellData().AddArray(point_array_max) outpd.GetCellData().SetActiveScalars(output_array_name) return outpd
def array2vtk(z): """Converts a numpy Array to a VTK array object directly. The resulting array copies the data in the passed array. The array can therefore be deleted safely. This works for real arrays. """ arr_vtk = {'c':vtkConstants.VTK_UNSIGNED_CHAR, 'b':vtkConstants.VTK_UNSIGNED_CHAR, '1':vtkConstants.VTK_CHAR, 's':vtkConstants.VTK_SHORT, 'i':vtkConstants.VTK_INT, 'l':vtkConstants.VTK_LONG, 'f':vtkConstants.VTK_FLOAT, 'd':vtkConstants.VTK_DOUBLE, 'F':vtkConstants.VTK_FLOAT, 'D':vtkConstants.VTK_DOUBLE } # A dummy array used to create others. f = vtk.vtkFloatArray() # First create an array of the right type by using the typecode. tmp = f.CreateDataArray(arr_vtk[z.dtype.char]) tmp.SetReferenceCount(2) # Prevents memory leak. zf = N.ravel(z) tmp.SetNumberOfTuples(len(zf)) tmp.SetNumberOfComponents(1) tmp.SetVoidArray(zf, len(zf), 1) # Now create a new array that is a DeepCopy of tmp. This is # required because tmp does not copy the data from the NumPy array # and will point to garbage if the NumPy array is deleted. arr = f.CreateDataArray(arr_vtk[z.dtype.char]) arr.SetReferenceCount(2) # Prevents memory leak. arr.DeepCopy(tmp) return arr
def make_spreadsheet(column_names, table): # column_names is a list of strings # table is a 2D numpy.ndarray # returns a vtkTable object that stores the table content # Create a vtkTable to store the output. rows = table.shape[0] if (table.shape[1] != len(column_names)): print('Warning: table number of columns differs from number of ' 'column names') return from vtk import vtkTable, vtkFloatArray vtk_table = vtkTable() for (column, name) in enumerate(column_names): array = vtkFloatArray() array.SetName(name) array.SetNumberOfComponents(1) array.SetNumberOfTuples(rows) vtk_table.AddColumn(array) for row in range(0, rows): array.InsertValue(row, table[row, column]) return vtk_table
def add_runs(self, eclipse, search_terms): """Uses self.prt to search PRT file using list of search terms then creates vtkFloatArrays for the scalar values""" self.prt.set_dims(eclipse.dims()) # actual PRT file parsing self.prt.add_runs(search_terms) x_dim, y_dim, z_dim = eclipse.dims() # self.prt.runs is dictionary referencing lists of PRTEntry objects for term, runs in self.prt.runs.iteritems(): # run is PRTEntry object for run in tqdm(runs, "creating "+term+"'s vtk arrays"): # writing individual time steps requires seperate VTK grids tmp = vtkImageData() self._set_grid_spec(tmp, eclipse) array = vtkFloatArray() array.SetName(run.name) array.SetNumberOfComponents(1) # starts at bottom and moves down x rows, building up for z in range(z_dim - 1, -1, -1): for y in range(0, y_dim): for x in range(0, x_dim): scalar = run.cells[z][y][x] array.InsertNextTuple1(scalar) tmp.GetCellData().AddArray(array) self.grid[term] += [tmp]
def generateSpline(markers): aSplineX = vtk.vtkCardinalSpline() aSplineY = vtk.vtkCardinalSpline() aSplineZ = vtk.vtkCardinalSpline() for i, marker in enumerate(markers): center = Vec3f(marker.GetCenter()) if not isinstance(marker, Vec3f) else marker aSplineX.AddPoint(i, center.x) aSplineY.AddPoint(i, center.y) aSplineZ.AddPoint(i, center.z) # Generate the polyline for the spline. points = vtk.vtkPoints() scalars = vtk.vtkFloatArray() # Number of points on the spline splineRes = len(markers)*1 # Interpolate x, y and z by using the three spline filters and # create new points splineList = [] for i in range(splineRes): t = (len(markers)-1.0)/(splineRes-1.0)*i splineList.append((aSplineX.Evaluate(t), aSplineY.Evaluate(t), aSplineZ.Evaluate(t))) points.InsertPoint(i, splineList[-1][0], splineList[-1][1], splineList[-1][2]) scalars.InsertTuple1(i,t) return points, scalars, t, splineList
def pca(self): """Performs Principle Component Analysis on the alignedGrids. Also calculates the mean shape. """ logging.info("running pca") size = len(self.alignedGrids) self.filterPCA.SetNumberOfInputs(size) for id, grid in enumerate(self.alignedGrids): self.filterPCA.SetInput(id, grid) self.filterPCA.Update() #Get the eigenvalues evals = self.filterPCA.GetEvals() #Now let's get mean ^^ b = vtk.vtkFloatArray() b.SetNumberOfComponents(0) b.SetNumberOfTuples(0) mean = vtk.vtkUnstructuredGrid() mean.DeepCopy(self.alignedGrids[0]) #Get the mean shape: self.filterPCA.GetParameterisedShape(b, mean) self.meanShape.append(mean) #get the meanpositions for pos in range(self.meanShape[0].GetNumberOfCells()): bounds = self.meanShape[0].GetCell(pos).GetBounds() self.meanPositions.append((bounds[0],bounds[2])) logging.info("done")
def __init__(self, filename, max_num_of_vertices=-1, edge_color_filename=None): super(VTKVisualizer, self).__init__() self.vertex_id_idx_map = {} self.next_vertex_id = 0 self.edge_counter = 0 self.lookup_table = vtk.vtkLookupTable() self.lookup_table.SetNumberOfColors(int(1e8)) self.edge_color_tuples = {} self.edge_color_filename = edge_color_filename self.label_vertex_id_map = {} self.starting_vertex = None self.starting_vertex_index = -1 self.filename = filename self.max_num_of_vertices = max_num_of_vertices self.g = vtk.vtkMutableDirectedGraph() self.vertex_ids = vtk.vtkIntArray() self.vertex_ids.SetNumberOfComponents(1) self.vertex_ids.SetName(VERTEX_ID) self.labels = vtk.vtkStringArray() self.labels.SetNumberOfComponents(1) self.labels.SetName(LABELS) self.glyph_scales = vtk.vtkFloatArray() self.glyph_scales.SetNumberOfComponents(1) self.glyph_scales.SetName(SCALES) self.edge_weights = vtk.vtkDoubleArray() self.edge_weights.SetNumberOfComponents(1) self.edge_weights.SetName(WEIGHTS) self.edge_colors = vtk.vtkIntArray() self.edge_colors.SetNumberOfComponents(1) self.edge_colors.SetName(EDGE_COLORS)
def damage(): input = test.GetPolyDataInput() numPts = input.GetNumberOfPoints() newPts = vtk.vtkPoints() isolines = vtk.vtkFloatArray() for i in range(0, numPts): x = input.GetPoint(i) x0, x1 = x[:2] r = sqrt(x0**2+x1**2) if r < 1: x2 = 1 else: x2 = (1/sqrt(r))*(abs(cos(x1/r)))**2 + (1/r**3)*abs((sin(x1/r)))**2 if r < 1: isoline = 1 else: isoline = (1/sqrt(r))*(abs(cos(x1/r)))**2 + (1/r**2)*abs((sin(x1/r)))**2 newPts.InsertPoint(i, x0, x1, x2) isolines.InsertValue(i, isoline) test.GetPolyDataOutput().CopyStructure(input) test.GetPolyDataOutput().SetPoints(newPts) test.GetPolyDataOutput().GetPointData().SetScalars(isolines)
def __init__(self, side, curvature): self._side = side self._curvature = curvature x_array_single = _numpy.arange(self._side) - self._side/2. + 0.5 y_array_single = _numpy.arange(self._side) - self._side/2. + 0.5 y_array, x_array = _numpy.meshgrid(y_array_single, x_array_single) z_array = (self._curvature - _numpy.sqrt(self._curvature**2 - x_array**2 - y_array**2)) self._image_values = _vtk.vtkFloatArray() self._image_values.SetNumberOfComponents(1) self._image_values.SetName("Intensity") self._points = _vtk.vtkPoints() for i in range(self._side): for j in range(self._side): self._points.InsertNextPoint(x_array[i, j], y_array[i, j], z_array[i, j]) self._image_values.InsertNextTuple1(0.) self._polygons = _vtk.vtkCellArray() self._square_slice() self._template_poly_data = _vtk.vtkPolyData() self._template_poly_data.SetPoints(self._points) self._template_poly_data.GetPointData().SetScalars(self._image_values) self._template_poly_data.SetPolys(self._polygons)
def addPlot(chart, reader, name): data1 = reader.GetOutput() coords = vtk.vtkFloatArray() coords.SetName("Coords") for i in range(data1.GetNumberOfPoints()): x,y,z = data1.GetPoint(i) coords.InsertNextValue(y) table = vtk.vtkTable() table.AddColumn(coords) table.AddColumn(data1.GetPointData().GetArray("S_g")) table.AddColumn(data1.GetPointData().GetArray("S_n")) table.AddColumn(data1.GetPointData().GetArray("S_w")) line1 = chart.AddPlot(vtk.vtkChart.LINE) line1.SetInput(table, 0, 1) line1.SetMarkerStyle(vtk.vtkPlotPoints.CROSS) line2 = chart.AddPlot(vtk.vtkChart.LINE) line2.SetInput(table, 0, 2) line2.SetMarkerStyle(vtk.vtkPlotPoints.PLUS) line3 = chart.AddPlot(vtk.vtkChart.LINE) line3.SetInput(table, 0, 3) line3.SetMarkerStyle(vtk.vtkPlotPoints.CIRCLE)
def Execute(self, *args): polydata = self.GetPolyDataInput() nTris = polydata.GetNumberOfCells() totalPerim = 0. for i in xrange(nTris): tri = polydata.GetCell(i) perim = 0. for j in range(3): perim += sqrt(tri.GetEdge(j).GetLength2()) continue totalPerim += perim continue aveSide = totalPerim / (3*nTris) p = vtkPoints() p.InsertPoint(0, 0.,0.,0.) val = vtkFloatArray() val.InsertValue(0, aveSide) out = vtkPolyData() out.SetPoints(p) out.GetPointData().SetScalars(val) self.GetPolyDataOutput().ShallowCopy(out) return
def main(): colors = vtk.vtkNamedColors() g = vtk.vtkMutableUndirectedGraph() v1 = g.AddVertex() v2 = g.AddVertex() g.AddEdge(v1, v2) g.AddEdge(v1, v2) scales = vtk.vtkFloatArray() scales.SetNumberOfComponents(1) scales.SetName('Scales') scales.InsertNextValue(2.0) scales.InsertNextValue(5.0) # Add the scale array to the graph g.GetVertexData().AddArray(scales) # Create the color array vertexColors = vtk.vtkIntArray() vertexColors.SetNumberOfComponents(1) vertexColors.SetName('Color') lookupTable = vtk.vtkLookupTable() lookupTable.SetNumberOfTableValues(2) lookupTable.SetTableValue(0, colors.GetColor4d('Yellow')) lookupTable.SetTableValue(1, colors.GetColor4d('Lime')) lookupTable.Build() vertexColors.InsertNextValue(0) vertexColors.InsertNextValue(1) # Add the color array to the graph g.GetVertexData().AddArray(vertexColors) theme = vtk.vtkViewTheme() theme.SetPointLookupTable(lookupTable) force_directed = vtk.vtkForceDirectedLayoutStrategy() layout_view = vtk.vtkGraphLayoutView() # If we create a layout object directly, just set the pointer through this method. # graph_layout_view.SetLayoutStrategy(force_directed) layout_view.SetLayoutStrategyToForceDirected() layout_view.AddRepresentationFromInput(g) layout_view.ApplyViewTheme(theme) layout_view.ScaledGlyphsOn() layout_view.SetScalingArrayName('Scales') layout_view.SetVertexColorArrayName('Color') layout_view.ColorVerticesOn() rGraph = vtk.vtkRenderedGraphRepresentation() gGlyph = vtk.vtkGraphToGlyphs() rGraph.SafeDownCast(layout_view.GetRepresentation()).SetGlyphType( gGlyph.CIRCLE) layout_view.GetRenderer().SetBackground(colors.GetColor3d('Navy')) layout_view.GetRenderer().SetBackground2(colors.GetColor3d('MidnightBlue')) layout_view.GetRenderWindow().SetWindowName('ScaleVertices') layout_view.Render() layout_view.ResetCamera() layout_view.GetInteractor().Start()
def testGlyphs(self): """Test if texturing of the glyphs works correctly.""" # The Glyph cs = vtk.vtkCubeSource() cs.SetXLength(2.0) cs.SetYLength(1.0) cs.SetZLength(0.5) # Create input point data. pts = vtk.vtkPoints() pts.InsertPoint(0, (1, 1, 1)) pts.InsertPoint(1, (0, 0, 0)) pts.InsertPoint(2, (-1, -1, -1)) polys = vtk.vtkCellArray() polys.InsertNextCell(1) polys.InsertCellPoint(0) polys.InsertNextCell(1) polys.InsertCellPoint(1) polys.InsertNextCell(1) polys.InsertCellPoint(2) pd = vtk.vtkPolyData() pd.SetPoints(pts) pd.SetPolys(polys) # Orient the glyphs as per vectors. vec = vtk.vtkFloatArray() vec.SetNumberOfComponents(3) vec.InsertTuple3(0, 1, 0, 0) vec.InsertTuple3(1, 0, 1, 0) vec.InsertTuple3(2, 0, 0, 1) pd.GetPointData().SetVectors(vec) # The glyph filter. g = vtk.vtkGlyph3D() g.SetScaleModeToDataScalingOff() g.SetVectorModeToUseVector() g.SetInputData(pd) g.SetSourceConnection(cs.GetOutputPort()) m = vtk.vtkPolyDataMapper() m.SetInputConnection(g.GetOutputPort()) a = vtk.vtkActor() a.SetMapper(m) # The texture. img_file = os.path.join(Testing.VTK_DATA_ROOT, "Data", "masonry.bmp") img_r = vtk.vtkBMPReader() img_r.SetFileName(img_file) t = vtk.vtkTexture() t.SetInputConnection(img_r.GetOutputPort()) t.InterpolateOn() a.SetTexture(t) # Renderer, RenderWindow etc. ren = vtk.vtkRenderer() ren.SetBackground(0.5, 0.5, 0.5) ren.AddActor(a) ren.ResetCamera() cam = ren.GetActiveCamera() cam.Azimuth(-90) cam.Zoom(1.4) renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) rwi = vtk.vtkRenderWindowInteractor() rwi.SetRenderWindow(renWin) rwi.Initialize() rwi.Render()
def laplacian_of_gaussian(inpd, fiber_distance_sigma=25, points_per_fiber=30, n_jobs=2, upper_thresh=30): """ Filter nearby fibers, using LoG weights. The pairwise fiber distance matrix is computed, then fibers are averaged with their neighbors using LoG weighting. This is essentially a fiber subtraction operation, giving vectors pointing from the center fiber under the kernel, to all nearby fibers. Thus the output of this operation is not a fiber, but we compute properties of the output that might be interesting and related to fibers. We summarize the result using the average vector at each fiber point (output is its magnitude, similar to edge strength). The covariance of the vectors is also investigated. This matrix would be spherical in an isotropic region such as a tract center (tube/line detector), or planar in a sheetlike tract (sheet detector). The equation is: (1-d^2/sigma^2) exp(-d^2/(2*sigma^2)), and weights are normalized in the neighborhood (weighted averaging). """ sigmasq = fiber_distance_sigma * fiber_distance_sigma # polydata to array conversion, fixed-length fiber representation fiber_array = fibers.FiberArray() fiber_array.points_per_fiber = points_per_fiber fiber_array.convert_from_polydata(inpd) fiber_indices = list(range(0, fiber_array.number_of_fibers)) # pairwise distance matrix if USE_PARALLEL: distances = Parallel(n_jobs=n_jobs, verbose=1)( delayed(similarity.fiber_distance)(fiber_array.get_fiber( lidx), fiber_array, 0, 'Hausdorff') for lidx in fiber_indices) distances = numpy.array(distances) else: distances = \ numpy.zeros( (fiber_array.number_of_fibers, fiber_array.number_of_fibers)) for lidx in fiber_indices: distances[lidx, :] = \ similarity.fiber_distance( fiber_array.get_fiber(lidx), fiber_array, 0) # fiber list data structure initialization for easy fiber averaging fiber_list = list() for lidx in range(0, fiber_array.number_of_fibers): fiber_list.append(fiber_array.get_fiber(lidx)) filter_vectors = list() filter_vector_magnitudes = list() filter_confidences = list() # gaussian smooth all fibers using local neighborhood for fidx in fiber_indices: if (fidx % 100) == 0: print(fidx, '/', fiber_array.number_of_fibers) current_fiber = fiber_list[fidx] # find indices of all nearby fibers # this includes the center fiber under the kernel indices = numpy.nonzero(distances[fidx] < upper_thresh)[0] local_fibers = list() local_weights = list() for idx in indices: dist = distances[fidx][idx] # compute filter kernel weights weight = numpy.exp(-(dist * dist) / sigmasq) #weight = (1 - (dist*dist)/sigmasq) * numpy.exp(-(dist*dist)/(2*sigmasq)) local_fibers.append(fiber_list[idx]) local_weights.append(weight) # actually perform the weighted average #mean_weight = numpy.mean(numpy.array(local_weights)) #out_weights = local_weights[0] #for weight in local_weights[1:]: # out_weights += weight # the weights must sum to 0 for LoG # (response in constant region is 0) #mean_weight = out_weights / len(local_weights) #local_normed_weights = list() #for weight in local_weights: # local_normed_weights.append(weight - mean_weight) #match_fiber = local_fibers[0] #out_vector = local_fibers[0] * local_normed_weights[0] idx = 0 for fiber in local_fibers: #out_vector += fiber # ensure fiber ordering by matching to current fiber only # otherwise the order is undefined after fiber subtraction matched_fiber = current_fiber.match_order(fiber) #filtered_fiber = matched_version * local_normed_weights[idx] #filtered_fiber = matched_version * local_weights[idx] if idx == 0: out_vector = fibers.Fiber() out_vector.points_per_fiber = points_per_fiber out_vector.r = numpy.zeros(points_per_fiber) out_vector.a = numpy.zeros(points_per_fiber) out_vector.s = numpy.zeros(points_per_fiber) #filtered_fiber = match_fiber.match_order(fiber) #out_vector.r = (out_vector.r + matched_fiber.r) * local_weights[idx] #out_vector.a = (out_vector.a + matched_fiber.a) * local_weights[idx] #out_vector.s = (out_vector.s + matched_fiber.s) * local_weights[idx] out_vector.r += (current_fiber.r - matched_fiber.r) * local_weights[idx] out_vector.a += (current_fiber.a - matched_fiber.a) * local_weights[idx] out_vector.s += (current_fiber.s - matched_fiber.s) * local_weights[idx] idx += 1 total_weights = numpy.sum(numpy.array(local_weights)) out_vector = out_vector / total_weights filter_vectors.append(out_vector) filter_confidences.append(total_weights) filter_vector_magnitudes.append(numpy.sqrt(\ numpy.multiply(out_vector.r, out_vector.r) + \ numpy.multiply(out_vector.a, out_vector.a) + \ numpy.multiply(out_vector.s, out_vector.s))) #filter_vector_magnitudes.append(numpy.sum(out_vector.r)) # output a new pd!!!! # with fixed length fibers. and the new vector field. # output the vectors from the filtering outpd = fiber_array.convert_to_polydata() vectors = vtk.vtkFloatArray() vectors.SetName('FiberDifferenceVectors') vectors.SetNumberOfComponents(3) for vec in filter_vectors: for idx in range(points_per_fiber): vectors.InsertNextTuple3(vec.r[idx], vec.a[idx], vec.s[idx]) magnitudes = vtk.vtkFloatArray() magnitudes.SetName('FiberDifferenceMagnitudes') magnitudes.SetNumberOfComponents(1) for mag in filter_vector_magnitudes: for idx in range(points_per_fiber): magnitudes.InsertNextTuple1(mag[idx]) confidences = vtk.vtkFloatArray() confidences.SetName('FiberDifferenceConfidences') confidences.SetNumberOfComponents(1) for mag in filter_confidences: for idx in range(points_per_fiber): confidences.InsertNextTuple1(mag) outpd.GetPointData().AddArray(vectors) outpd.GetPointData().SetActiveVectors('FiberDifferenceVectors') outpd.GetPointData().AddArray(confidences) outpd.GetPointData().SetActiveScalars('FiberDifferenceConfidences') outpd.GetPointData().AddArray(magnitudes) outpd.GetPointData().SetActiveScalars('FiberDifferenceMagnitudes') # color by the weights or "local density" # color output by the number of fibers that each output fiber corresponds to #outcolors = vtk.vtkFloatArray() #outcolors.SetName('KernelDensity') #for weight in next_weights: # outcolors.InsertNextTuple1(weight) #inpd.GetCellData().AddArray(outcolors) #inpd.GetCellData().SetActiveScalars('KernelDensity') #outcolors = vtk.vtkFloatArray() #outcolors.SetName('EdgeMagnitude') #for magnitude in filter_vector_magnitudes: # outcolors.InsertNextTuple1(magnitude) #inpd.GetCellData().AddArray(outcolors) #inpd.GetCellData().SetActiveScalars('EdgeMagnitude') return outpd, numpy.array(filter_vector_magnitudes)
def parseFile(): global VTK_DATA_ROOT, dos # Use Python to read an ASCII file file = open(os.path.join(VTK_DATA_ROOT, "Data/financial.txt"), "r") line = file.readline() numPts = int(getNumberFromLine(line)[0]) numLines = (numPts - 1) // 8 # Get the data object's field data and allocate # room for 4, fields fieldData = dos.GetOutput().GetFieldData() fieldData.AllocateArrays(4) # read TIME_LATE - dependent variable # search the file until an array called TIME_LATE is found while file.readline()[:9] != "TIME_LATE": pass # Create the corresponding float array timeLate = vtk.vtkFloatArray() timeLate.SetName("TIME_LATE") # Read the values for i in range(0, numLines): val = getNumberFromLine(file.readline()) for j in range(0, 8): timeLate.InsertNextValue(val[j]) # Add the array fieldData.AddArray(timeLate) # MONTHLY_PAYMENT - independent variable while file.readline()[:15] != "MONTHLY_PAYMENT": pass monthlyPayment = vtk.vtkFloatArray() monthlyPayment.SetName("MONTHLY_PAYMENT") for i in range(0, numLines): val = getNumberFromLine(file.readline()) for j in range(0, 8): monthlyPayment.InsertNextValue(val[j]) fieldData.AddArray(monthlyPayment) # UNPAID_PRINCIPLE - skip while file.readline()[:16] != "UNPAID_PRINCIPLE": pass for i in range(0, numLines): file.readline() # LOAN_AMOUNT - skip while file.readline()[:11] != "LOAN_AMOUNT": pass for i in range(0, numLines): file.readline() # INTEREST_RATE - independent variable while file.readline()[:13] != "INTEREST_RATE": pass interestRate = vtk.vtkFloatArray() interestRate.SetName("INTEREST_RATE") for i in range(0, numLines): val = getNumberFromLine(file.readline()) for j in range(0, 8): interestRate.InsertNextValue(val[j]) fieldData.AddArray(interestRate) # MONTHLY_INCOME - independent variable while file.readline()[:14] != "MONTHLY_INCOME": pass monthlyIncome = vtk.vtkFloatArray() monthlyIncome.SetName("MONTHLY_INCOME") for i in range(0, numLines): val = getNumberFromLine(file.readline()) for j in range(0, 8): monthlyIncome.InsertNextValue(val[j]) fieldData.AddArray(monthlyIncome)
#!/bin/python import vtk import math view = vtk.vtkContextView() view.GetRenderer().SetBackground(1.0, 1.0, 1.0) view.GetRenderWindow().SetSize(400, 300) chart = vtk.vtkChartXY() view.GetScene().AddItem(chart) chart.SetShowLegend(True) arrX = vtk.vtkFloatArray() arrX.SetName("X Axis") arrC = vtk.vtkFloatArray() arrC.SetName("Cosine") arrS = vtk.vtkFloatArray() arrS.SetName("Sine") arrT = vtk.vtkFloatArray() arrT.SetName("Sine - Cosine") numPoints = 40 inc = 7.5 / (numPoints - 1) #table.SetNumberOfRows(numPoints) for i in range(numPoints): #table.SetValue(i, 0, i * inc) #table.SetValue(i, 1, math.cos(i * inc) + 0.0)
def _plotInternal(self): """Overrides baseclass implementation.""" # Preserve time and z axis for plotting these inof in rendertemplate projection = vcs.elements["projection"][self._gm.projection] zaxis, taxis = self.getZandT() scale = 1.0 if self._vtkGeoTransform is not None: lat = None lon = None latAccessor = self._data1.getLatitude() lonAccessor = self._data1.getLongitude() if latAccessor: lat = latAccessor[:] if lonAccessor: lon = lonAccessor[:] newv = vtk.vtkDoubleArray() newv.SetNumberOfComponents(3) newv.InsertTypedTuple(0, [lon.min(), lat.min(), 0]) newv.InsertTypedTuple(1, [lon.max(), lat.max(), 0]) vcs2vtk.projectArray(newv, projection, self._vtkDataSetBounds) dimMin = [0, 0, 0] dimMax = [0, 0, 0] newv.GetTypedTuple(0, dimMin) newv.GetTypedTuple(1, dimMax) maxDimX = max(dimMin[0], dimMax[0]) maxDimY = max(dimMin[1], dimMax[1]) if lat.max() != 0.0: scale = abs((maxDimY / lat.max())) if lon.max() != 0.0: temp = abs((maxDimX / lon.max())) if scale < temp: scale = temp else: scale = 1.0 # Vector attempt ltp_tmp = self._gm.linetype if ltp_tmp is None: ltp_tmp = "default" try: ltp_tmp = vcs.getline(ltp_tmp) lwidth = ltp_tmp.width[0] # noqa lcolor = ltp_tmp.color[0] lstyle = ltp_tmp.type[0] # noqa except Exception: lstyle = "solid" # noqa lwidth = 1. # noqa lcolor = [0., 0., 0., 100.] if self._gm.linewidth is not None: lwidth = self._gm.linewidth # noqa if self._gm.linecolor is not None: lcolor = self._gm.linecolor arrow = vtk.vtkGlyphSource2D() arrow.SetGlyphTypeToArrow() arrow.SetOutputPointsPrecision(vtk.vtkAlgorithm.DOUBLE_PRECISION) arrow.FilledOff() plotting_dataset_bounds = self.getPlottingBounds() x1, x2, y1, y2 = plotting_dataset_bounds vp = self._resultDict.get('ratio_autot_viewport', [ self._template.data.x1, self._template.data.x2, self._template.data.y1, self._template.data.y2 ]) # The unscaled continent bounds were fine in the presence of axis # conversion, so save them here adjusted_plotting_bounds = vcs2vtk.getProjectedBoundsForWorldCoords( plotting_dataset_bounds, self._gm.projection) continentBounds = vcs2vtk.computeDrawAreaBounds( adjusted_plotting_bounds) # Transform the input data T = vtk.vtkTransform() T.Scale(self._context_xScale, self._context_yScale, 1.) self._vtkDataSetFittedToViewport = vcs2vtk.applyTransformationToDataset( T, self._vtkDataSetFittedToViewport) self._vtkDataSetBoundsNoMask = self._vtkDataSetFittedToViewport.GetBounds( ) polydata = self._vtkDataSetFittedToViewport # view and interactive area view = self._context().contextView area = vtk.vtkInteractiveArea() view.GetScene().AddItem(area) drawAreaBounds = vcs2vtk.computeDrawAreaBounds( self._vtkDataSetBoundsNoMask, self._context_flipX, self._context_flipY) [renWinWidth, renWinHeight] = self._context().renWin.GetSize() geom = vtk.vtkRecti(int(round(vp[0] * renWinWidth)), int(round(vp[2] * renWinHeight)), int(round((vp[1] - vp[0]) * renWinWidth)), int(round((vp[3] - vp[2]) * renWinHeight))) vcs2vtk.configureContextArea(area, drawAreaBounds, geom) # polydata = tmpMapper.GetInput() plotting_dataset_bounds = self.getPlottingBounds() vectors = polydata.GetPointData().GetVectors() if self._gm.scaletype == 'constant' or\ self._gm.scaletype == 'constantNNormalize' or\ self._gm.scaletype == 'constantNLinear': scaleFactor = scale * self._gm.scale else: scaleFactor = 1.0 glyphFilter = vtk.vtkGlyph2D() glyphFilter.SetInputArrayToProcess(1, 0, 0, 0, "vector") glyphFilter.SetSourceConnection(arrow.GetOutputPort()) glyphFilter.SetVectorModeToUseVector() # Rotate arrows to match vector data: glyphFilter.OrientOn() glyphFilter.ScalingOn() glyphFilter.SetScaleModeToScaleByVector() maxNormInVp = None minNormInVp = None # Find the min and max vector magnitudes (minNorm, maxNorm) = vectors.GetRange(-1) if maxNorm == 0: maxNorm = 1.0 if self._gm.scaletype == 'normalize' or self._gm.scaletype == 'linear' or\ self._gm.scaletype == 'constantNNormalize' or self._gm.scaletype == 'constantNLinear': if self._gm.scaletype == 'normalize' or self._gm.scaletype == 'constantNNormalize': scaleFactor /= maxNorm if self._gm.scaletype == 'linear' or self._gm.scaletype == 'constantNLinear': noOfComponents = vectors.GetNumberOfComponents() scalarArray = vtk.vtkDoubleArray() scalarArray.SetNumberOfComponents(1) scalarArray.SetNumberOfValues(vectors.GetNumberOfTuples()) oldRange = maxNorm - minNorm oldRange = 1.0 if oldRange == 0.0 else oldRange # New range min, max. newRangeValues = self._gm.scalerange newRange = newRangeValues[1] - newRangeValues[0] for i in range(0, vectors.GetNumberOfTuples()): norm = vtk.vtkMath.Norm(vectors.GetTuple(i), noOfComponents) newValue = (((norm - minNorm) * newRange) / oldRange) + newRangeValues[0] scalarArray.SetValue(i, newValue) polydata.GetPointData().SetScalars(scalarArray) maxNormInVp = newRangeValues[1] * scaleFactor minNormInVp = newRangeValues[0] * scaleFactor # Scale to vector magnitude: # NOTE: Currently we compute our own scaling factor since VTK does # it by clamping the values > max to max and values < min to min # and not remap the range. glyphFilter.SetScaleModeToScaleByScalar() if (maxNormInVp is None): maxNormInVp = maxNorm * scaleFactor # minNormInVp is left None, as it is displayed only for linear scaling. cmap = self.getColorMap() if isinstance(lcolor, (list, tuple)): r, g, b, a = lcolor else: r, g, b, a = cmap.index[lcolor] # act.GetProperty().SetColor(r / 100., g / 100., b / 100.) vtk_color = [int((c / 100.) * 255) for c in [r, g, b, a]] # Using the scaled data, set the glyph filter input glyphFilter.SetScaleFactor(scaleFactor) glyphFilter.SetInputData(polydata) glyphFilter.Update() # and set the arrows to be rendered. data = glyphFilter.GetOutput() floatValue = vtk.vtkFloatArray() floatValue.SetNumberOfComponents(1) floatValue.SetName("LineWidth") floatValue.InsertNextValue(lwidth) data.GetFieldData().AddArray(floatValue) item = vtk.vtkPolyDataItem() item.SetPolyData(data) item.SetScalarMode(vtk.VTK_SCALAR_MODE_USE_CELL_DATA) colorArray = vtk.vtkUnsignedCharArray() colorArray.SetNumberOfComponents(4) for i in range(data.GetNumberOfCells()): colorArray.InsertNextTypedTuple(vtk_color) item.SetMappedColors(colorArray) area.GetDrawAreaItem().AddItem(item) kwargs = { 'vtk_backend_grid': self._vtkDataSet, 'dataset_bounds': self._vtkDataSetBounds, 'plotting_dataset_bounds': plotting_dataset_bounds, "vtk_dataset_bounds_no_mask": self._vtkDataSetBoundsNoMask, 'vtk_backend_geo': self._vtkGeoTransform, "vtk_backend_draw_area_bounds": continentBounds, "vtk_backend_viewport_scale": [self._context_xScale, self._context_yScale] } if ('ratio_autot_viewport' in self._resultDict): kwargs["ratio_autot_viewport"] = vp self._resultDict.update(self._context().renderTemplate( self._template, self._data1, self._gm, taxis, zaxis, **kwargs)) # assume that self._data1.units has the proper vector units unitString = None if (hasattr(self._data1, 'units')): unitString = self._data1.units if self._vtkGeoTransform: worldWidth = self._vtkDataSetBoundsNoMask[ 1] - self._vtkDataSetBoundsNoMask[0] else: worldWidth = self._vtkDataSetBounds[1] - self._vtkDataSetBounds[0] worldToViewportXScale = (vp[1] - vp[0]) / worldWidth maxNormInVp *= worldToViewportXScale if (minNormInVp): minNormInVp *= worldToViewportXScale vcs.utils.drawVectorLegend(self._context().canvas, self._template.legend, lcolor, lstyle, lwidth, unitString, maxNormInVp, maxNorm, minNormInVp, minNorm, reference=self._gm.reference) kwargs['xaxisconvert'] = self._gm.xaxisconvert kwargs['yaxisconvert'] = self._gm.yaxisconvert if self._data1.getAxis(-1).isLongitude() and self._data1.getAxis( -2).isLatitude(): self._context().plotContinents( self._plot_kargs.get("continents", self._useContinents), plotting_dataset_bounds, projection, self._dataWrapModulo, vp, self._template.data.priority, **kwargs) self._resultDict["vtk_backend_actors"] = [[ item, plotting_dataset_bounds ]] self._resultDict["vtk_backend_glyphfilters"] = [glyphFilter] self._resultDict["vtk_backend_luts"] = [[None, None]]
def bbox2vtk(data, attributes, vtk_file): points_data = vtk.vtkPoints() cells = vtk.vtkCellArray() num_cells = data.shape[0] for i in range(num_cells): pos = data[i, 0:3] print('pos:', pos) x = 0.5 * data[i, 3] # len, x h = data[i, 4] # height, z y = 0.5 * data[i, 5] # width, y yaw = 0.5 * math.pi - data[i, 6] q = Quaternion(axis=[0, 0, 1], angle=yaw) tmp_pos0 = q.rotate([-x, -y, pos[2]]) tmp_pos1 = q.rotate([-x, +y, pos[2]]) tmp_pos2 = q.rotate([+x, +y, pos[2]]) tmp_pos3 = q.rotate([+x, -y, pos[2]]) points_data.InsertNextPoint(pos[0] + tmp_pos0[0], pos[1] + tmp_pos0[1], tmp_pos0[2]) points_data.InsertNextPoint(pos[0] + tmp_pos1[0], pos[1] + tmp_pos1[1], tmp_pos1[2]) points_data.InsertNextPoint(pos[0] + tmp_pos2[0], pos[1] + tmp_pos2[1], tmp_pos2[2]) points_data.InsertNextPoint(pos[0] + tmp_pos3[0], pos[1] + tmp_pos3[1], tmp_pos3[2]) points_data.InsertNextPoint(pos[0] + tmp_pos0[0], pos[1] + tmp_pos0[1], tmp_pos0[2] + h) points_data.InsertNextPoint(pos[0] + tmp_pos1[0], pos[1] + tmp_pos1[1], tmp_pos1[2] + h) points_data.InsertNextPoint(pos[0] + tmp_pos2[0], pos[1] + tmp_pos2[1], tmp_pos2[2] + h) points_data.InsertNextPoint(pos[0] + tmp_pos3[0], pos[1] + tmp_pos3[1], tmp_pos3[2] + h) off = i * 8 cells.InsertNextCell(5, [off + 0, off + 1, off + 2, off + 3, off + 0]) cells.InsertNextCell(5, [off + 4, off + 5, off + 6, off + 7, off + 4]) cells.InsertNextCell(2, [off + 0, off + 4]) cells.InsertNextCell(2, [off + 1, off + 5]) cells.InsertNextCell(2, [off + 2, off + 6]) cells.InsertNextCell(2, [off + 3, off + 7]) bx_attrs = [] for attr in attributes: if attr[1] == 'int1': tmp_attr = vtk.vtkIntArray() tmp_attr.SetName(attr[0]) tmp_attr.SetNumberOfComponents(1) tmp_attr.SetNumberOfTuples(num_cells * 6) for i in range(0, num_cells): tmp_attr.SetTuple1(i * 6, attr[2][i]) tmp_attr.SetTuple1(i * 6 + 1, attr[2][i]) tmp_attr.SetTuple1(i * 6 + 2, attr[2][i]) tmp_attr.SetTuple1(i * 6 + 3, attr[2][i]) tmp_attr.SetTuple1(i * 6 + 4, attr[2][i]) tmp_attr.SetTuple1(i * 6 + 5, attr[2][i]) bx_attrs.append(tmp_attr) elif attr[1] == 'float1': tmp_attr = vtk.vtkFloatArray() tmp_attr.SetName(attr[0]) tmp_attr.SetNumberOfComponents(1) tmp_attr.SetNumberOfTuples(num_cells * 6) for i in range(0, num_cells): tmp_attr.SetTuple1(i * 6, attr[2][i]) tmp_attr.SetTuple1(i * 6 + 1, attr[2][i]) tmp_attr.SetTuple1(i * 6 + 2, attr[2][i]) tmp_attr.SetTuple1(i * 6 + 3, attr[2][i]) tmp_attr.SetTuple1(i * 6 + 4, attr[2][i]) tmp_attr.SetTuple1(i * 6 + 5, attr[2][i]) bx_attrs.append(tmp_attr) bboxes = vtk.vtkPolyData() bboxes.SetPoints(points_data) bboxes.SetLines(cells) for bx_at in bx_attrs: bboxes.GetCellData().AddArray(bx_at) poly_data_writer = vtk.vtkPolyDataWriter() poly_data_writer.SetInputData(bboxes) poly_data_writer.SetFileName(vtk_file) poly_data_writer.SetFileTypeToBinary() poly_data_writer.Write()
] points.InsertNextPoint(numPointData[:]) # Separar las conexiones entre puntos y guardarlas en una estructura lines = vtk.vtkCellArray() for line in atomsConnectionsDataset: stringList = line.split(' ') position = int(stringList[0]) value = int(stringList[1]) lines.InsertNextCell(2) lines.InsertCellPoint(position) lines.InsertCellPoint(value) # Guardar los radios en una estructura scalars = vtk.vtkFloatArray() for valueStr in radiusDataset: value = float(valueStr) scalars.InsertNextValue(value) # Crear el renderer renderer = vtk.vtkRenderer() # Crear la estructura para pintar los datos glyph = vtk.vtkGlyph3D() glyph.SetScaleFactor(0.1) # Crear LUT para colorear las esferas lut = vtkColorTransferFunction() lut.SetColorSpaceToRGB() lut.AddRGBPoint(0.3, 1, 1, 1)
def main(): # x = array of 8 3-tuples of float representing the vertices of a cube: x = [(0.0, 0.0, 0.0), (1.0, 0.0, 0.0), (1.0, 1.0, 0.0), (0.0, 1.0, 0.0), (0.0, 0.0, 1.0), (1.0, 0.0, 1.0), (1.0, 1.0, 1.0), (0.0, 1.0, 1.0)] # pts = array of 6 4-tuples of vtkIdType (int) representing the faces # of the cube in terms of the above vertices pts = [(0, 1, 2, 3), (4, 5, 6, 7), (0, 1, 5, 4), (1, 2, 6, 5), (2, 3, 7, 6), (3, 0, 4, 7)] # We'll create the building blocks of polydata including data attributes. cube = vtk.vtkPolyData() points = vtk.vtkPoints() polys = vtk.vtkCellArray() scalars = vtk.vtkFloatArray() # Load the point, cell, and data attributes. for i in range(8): points.InsertPoint(i, x[i]) for i in range(6): polys.InsertNextCell(mkVtkIdList(pts[i])) for i in range(8): scalars.InsertTuple1(i, i) # We now assign the pieces to the vtkPolyData. cube.SetPoints(points) del points cube.SetPolys(polys) del polys cube.GetPointData().SetScalars(scalars) del scalars # Now we'll look at it. cubeMapper = vtk.vtkPolyDataMapper() if vtk.VTK_MAJOR_VERSION <= 5: cubeMapper.SetInput(cube) else: cubeMapper.SetInputData(cube) cubeMapper.SetScalarRange(0, 7) cubeActor = vtk.vtkActor() cubeActor.SetMapper(cubeMapper) # The usual rendering stuff. camera = vtk.vtkCamera() camera.SetPosition(1, 1, 1) camera.SetFocalPoint(0, 0, 0) renderer = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(renderer) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) renderer.AddActor(cubeActor) renderer.SetActiveCamera(camera) renderer.ResetCamera() renderer.SetBackground(1, 1, 1) renWin.SetSize(300, 300) # interact with data renWin.Render() iren.Start() # Clean up del cube del cubeMapper del cubeActor del camera del renderer del renWin del iren
sphereActor.GetProperty().SetOpacity(.3) sphereActor.GetProperty().SetColor(1, 0, 0) implicitPolyDataDistance = vtk.vtkImplicitPolyDataDistance() implicitPolyDataDistance.SetInput(sphereSource.GetOutput()) # Setup a grid points = vtk.vtkPoints() step = 0.1 for x in np.arange(-2, 2, step): for y in np.arange(-2, 2, step): for z in np.arange(-2, 2, step): points.InsertNextPoint(x, y, z) # Add distances to each point signedDistances = vtk.vtkFloatArray() signedDistances.SetNumberOfComponents(1) signedDistances.SetName("SignedDistances") # Evaluate the signed distance function at all of the grid points for pointId in range(points.GetNumberOfPoints()): p = points.GetPoint(pointId) signedDistance = implicitPolyDataDistance.EvaluateFunction(p) signedDistances.InsertNextValue(signedDistance) polyData = vtk.vtkPolyData() polyData.SetPoints(points) polyData.GetPointData().SetScalars(signedDistances) vertexGlyphFilter = vtk.vtkVertexGlyphFilter() vertexGlyphFilter.SetInputData(polyData)
import vtk from math import sqrt plane = vtk.vtkPlane() plane.SetOrigin(5, 5, 9.8) plane.SetNormal(0, 0, 1) coords = [(0, 0, 0), (10, 0, 0), (10, 10, 0), (0, 10, 0), (0, 0, 10), (10, 0, 10), (10, 10, 10), (0, 10, 10), (5, 0, 0), (10, 5, 0), (5, 10, 0), (0, 5, 0), (5, 0, 9.5), (10, 5, 9.3), (5, 10, 9.5), (0, 5, 9.3), (0, 0, 5), (10, 0, 5), (10, 10, 5), (0, 10, 5)] data = vtk.vtkFloatArray() points = vtk.vtkPoints() ptIds = vtk.vtkIdList() mesh = vtk.vtkUnstructuredGrid() mesh.SetPoints(points) mesh.GetPointData().SetScalars(data) for id in range(0, 20): x = coords[id][0] y = coords[id][1] z = coords[id][2] ptIds.InsertNextId(id) points.InsertNextPoint(x, y, z) data.InsertNextValue(sqrt(x * x + y * y + z * z)) mesh.InsertNextCell(vtk.VTK_QUADRATIC_HEXAHEDRON, ptIds) ptIds.Reset() for id in range(0, 8): x = coords[id][0] + 20 y = coords[id][1] + 20
def readPoints(file, depth_scaling=0.01): # Create an array of Points points = vtk.vtkPoints() # Create arrays of Scalars scalars = vtk.vtkFloatArray() tid = vtk.vtkFloatArray() depth = vtk.vtkFloatArray() # Initialize LatMax=0 LatMin=360 LonMax=0 LonMin=360 tMin=99999999999999 # Open the file file = open(file) # Read one line line = file.readline() # Loop through lines tMin = 1.0e15 while line: # Split the line into data data = line.split('|') # Skip the commented lines if data and data[0][0] != '#': # Convert data into float print(data[0], data[1], data[2], data[3], data[4].split('--')[0], data[10]) date, x, y, z, r = data[1], float(data[2]), float(data[3]), float(data[4]), float(data[10]) z_scaled = z * depth_scaling row=date.split('T') adate=row[0].split('-') atime=row[1].split(':') temp=atime[2].split('.') atime[2]=temp[0] if atime[2]=='': atime[2]='00' t= time.mktime((int(adate[0]),int(adate[1]),int(adate[2]),int(atime[0]),int(atime[1]),int(atime[2]),0,0,0)) if x > LatMax: LatMax=x if x< LatMin: LatMin=x if y > LonMax: LonMax=y if y< LonMin: LonMin=y if t< tMin: tMin=t # Insert floats into the point array points.InsertNextPoint(x, y, z_scaled) scalars.InsertNextValue(r) t -= 1467247524.0 #FIXME tid.InsertNextValue(t) depth.InsertNextValue(z_scaled) # read next line line = file.readline() print(LatMin, LatMax, LonMin, LonMax) return points, scalars, tid, depth
def smooth(inpd, fiber_distance_sigma=25, points_per_fiber=30, n_jobs=2, upper_thresh=30): """ Average nearby fibers. The pairwise fiber distance matrix is computed, then fibers are averaged with their neighbors using Gaussian weighting. The "local density" or soft neighbor count is also output. """ sigmasq = fiber_distance_sigma * fiber_distance_sigma # polydata to array conversion, fixed-length fiber representation current_fiber_array = fibers.FiberArray() current_fiber_array.points_per_fiber = points_per_fiber current_fiber_array.convert_from_polydata(inpd) # fiber list data structure initialization for easy fiber averaging curr_count = list() curr_fibers = list() next_fibers = list() next_weights = list() for lidx in range(0, current_fiber_array.number_of_fibers): curr_fibers.append(current_fiber_array.get_fiber(lidx)) curr_count.append(1) fiber_indices = list(range(0, current_fiber_array.number_of_fibers)) # compare squared distances to squared distance threshold upper_thresh = upper_thresh * upper_thresh print("<filter.py> Computing pairwise distances...") # pairwise distance matrix if USE_PARALLEL: distances = Parallel(n_jobs=n_jobs, verbose=1)( delayed(similarity.fiber_distance)(current_fiber_array.get_fiber( lidx), current_fiber_array, 0, 'Hausdorff') for lidx in fiber_indices) distances = numpy.array(distances) else: distances = \ numpy.zeros( (current_fiber_array.number_of_fibers, current_fiber_array.number_of_fibers)) for lidx in fiber_indices: distances[lidx, :] = \ similarity.fiber_distance( current_fiber_array.get_fiber(lidx), current_fiber_array, 0) # gaussian smooth all fibers using local neighborhood for fidx in fiber_indices: if (fidx % 100) == 0: print(fidx, '/', current_fiber_array.number_of_fibers) # find indices of all nearby fibers indices = numpy.nonzero(distances[fidx] < upper_thresh)[0] local_fibers = list() local_weights = list() for idx in indices: dist = distances[fidx][idx] # these are now squared distances weight = numpy.exp(-dist / sigmasq) #weight = numpy.exp(-(dist*dist)/sigmasq) local_fibers.append(curr_fibers[idx] * weight) local_weights.append(weight) # actually perform the weighted average # start with the one under the center of the kernel #out_fiber = curr_fibers[fidx] #out_weights = 1.0 out_fiber = local_fibers[0] out_weights = local_weights[0] for fiber in local_fibers[1:]: out_fiber += fiber for weight in local_weights[1:]: out_weights += weight out_fiber = out_fiber / out_weights next_fibers.append(out_fiber) next_weights.append(out_weights) # set up array for output output_fiber_array = fibers.FiberArray() output_fiber_array.number_of_fibers = len(curr_fibers) output_fiber_array.points_per_fiber = points_per_fiber dims = [ output_fiber_array.number_of_fibers, output_fiber_array.points_per_fiber ] # fiber data output_fiber_array.fiber_array_r = numpy.zeros(dims) output_fiber_array.fiber_array_a = numpy.zeros(dims) output_fiber_array.fiber_array_s = numpy.zeros(dims) next_fidx = 0 for next_fib in next_fibers: output_fiber_array.fiber_array_r[next_fidx] = next_fib.r output_fiber_array.fiber_array_a[next_fidx] = next_fib.a output_fiber_array.fiber_array_s[next_fidx] = next_fib.s next_fidx += 1 # convert output to polydata outpd = output_fiber_array.convert_to_polydata() # color by the weights or "local density" # color output by the number of fibers that each output fiber corresponds to outcolors = vtk.vtkFloatArray() outcolors.SetName('KernelDensity') for weight in next_weights: outcolors.InsertNextTuple1(weight) #outpd.GetCellData().SetScalars(outcolors) outpd.GetCellData().AddArray(outcolors) outpd.GetCellData().SetActiveScalars('KernelDensity') return outpd, numpy.array(next_weights)
def isoFile(filename): lines=0 geomfile=open(filename,"rb") m=1 spherepoints= vtk.vtkPoints() radii=vtk.vtkFloatArray() cubepoints=vtk.vtkPoints() while geomfile: line = geomfile.readline() if line == "": break line = str.rstrip(line) cols =line.split(' ') x=cols[0] y=cols[1] z=cols[2] r=cols[3] if m==1: sr=r spherepoints.InsertNextPoint(float(x),float(y), float(z)) radii.InsertNextValue(float(r)) if m>1: cubepoints.InsertNextPoint(float(x),float(y),float(z)) m+=1 # Putting the data into cellarray cubecell=vtk.vtkCellArray() cubecell.InsertNextCell(m-1) for j in range(0,m-1): cubecell.InsertCellPoint(j) # Getting Points for spherevisualization spheredata=vtk.vtkPolyData() spheredata.SetPoints(spherepoints) vector=vtk.vtkFloatArray() vector.SetNumberOfComponents(3) vector.SetNumberOfTuples(m) pline=vtk.vtkCellArray() pline.InsertNextCell(1) for i in range(0,1): pline.InsertCellPoint(i) spheredata.SetPolys(pline) spheredata.GetPointData().SetVectors(vector) # Cube Rendering from Geometry file CubeData = vtk.vtkPolyData() CubeData.SetPoints(cubepoints) CubeData.GetPointData().SetVectors(vector) # CubeSource is using as a source of vtkGlyph3D to visualize cube Cube=vtk.vtkCubeSource() Cubesurface=vtk.vtkGlyph3D() Cubesurface.SetSource(Cube.GetOutput()) Cubesurface.SetInput(CubeData) # Data mapping for cube visualization CubeMapper = vtk.vtkPolyDataMapper() CubeMapper.SetInput(Cubesurface.GetOutput()) CubeMapper.GlobalImmediateModeRenderingOn() CubeActor = vtk.vtkLODActor() CubeActor.SetMapper(CubeMapper) #CubeActor.GetProperty().SetColor(1, 0, 0) CubeActor.GetProperty().SetDiffuseColor(1, 0, 0); #CubeActor.GetProperty().SetSpecular(.3); #CubeActor.GetProperty().SetSpecularPower(20); #CubeActor.GetProperty().SetOpacity(0.5) #Sphere Rendering # Sphere visualization. If you to want chage the radius, resolution, please do changes in the numeric parameter only. spheres=vtk.vtkSphereSource() spheres.SetRadius(16.0) spheres.SetThetaResolution(32) spheres.SetPhiResolution(32) Glyph=vtk.vtkGlyph3D() Glyph.SetSource(spheres.GetOutput()) Glyph.SetInput(spheredata) # Mapping of sphere data and also adding actors for rendering the spheres.Here you can also chnage the color of shere changing the parameters into SetColor. You can put any values and observe changes but (0,0,0) is used for black and (1,1,1) is for white. sphereMapper = vtk.vtkPolyDataMapper() sphereMapper.SetInput(Glyph.GetOutput()) sphereMapper.GlobalImmediateModeRenderingOn() sphereActor = vtk.vtkLODActor() sphereActor.SetMapper(sphereMapper) sphereActor.GetProperty().SetColor(1, 0, 1) ren.AddActor(CubeActor) ren.AddActor(sphereActor)
def symmetrize(inpd): """Generate symmetric polydata by reflecting. Output polydata has twice as many lines as input. """ # output and temporary objects ptids = vtk.vtkIdList() points = inpd.GetPoints() outpd = vtk.vtkPolyData() outlines = vtk.vtkCellArray() outpoints = vtk.vtkPoints() outpoints.DeepCopy(points) # loop over lines inpd.GetLines().InitTraversal() outlines.InitTraversal() # set scalar cell data to 1 for orig, -1 for reflect, for vis outcolors = vtk.vtkFloatArray() # index into end of point array lastidx = outpoints.GetNumberOfPoints() print("<filter.py> Input number of points: ", lastidx) # loop over all lines, insert line and reflected copy into output pd for lidx in range(0, inpd.GetNumberOfLines()): # progress if verbose: if lidx % 100 == 0: print("<filter.py> Line:", lidx, "/", inpd.GetNumberOfLines()) inpd.GetLines().GetNextCell(ptids) num_points = ptids.GetNumberOfIds() # insert fiber (ptids are same since new points go at the end) outlines.InsertNextCell(ptids) outcolors.InsertNextTuple1(1) # insert reflection into END of point array and into line array refptids = vtk.vtkIdList() for pidx in range(0, num_points): point = points.GetPoint(ptids.GetId(pidx)) # reflect (RAS -> reflect first value) refpoint = (-point[0], point[1], point[2]) idx = outpoints.InsertNextPoint(refpoint) refptids.InsertNextId(idx) outlines.InsertNextCell(refptids) outcolors.InsertNextTuple1(-1) # put data into output polydata outpd.SetLines(outlines) outpd.SetPoints(outpoints) outpd.GetCellData().SetScalars(outcolors) return outpd
array1.SetNumberOfTuples(10) for idArray in range(0,10): array1.SetTuple3(idArray, idArray+1, idArray+2, idArray+3) modifiedTable.GetFieldData().AddArray(array1) array2 = vtk.vtkDoubleArray() array2.SetName("Array 2") array2.SetNumberOfComponents(1) array2.SetNumberOfTuples(10) for idArray in range(0,10): array2.SetTuple1(idArray, idArray+1.5) modifiedTable.GetFieldData().AddArray(array2) array3 = vtk.vtkFloatArray() array3.SetName("Array 3") array3.SetNumberOfComponents(3) array3.SetNumberOfTuples(10) for idArray in range(0,10): array3.SetTuple3(idArray, idArray+1.5, idArray+2.5, idArray+3.5) modifiedTable.GetFieldData().AddArray(array3) xmlTableWriter = vtk.vtkXMLTableWriter() xmlTableWriter.SetFileName(file2) xmlTableWriter.SetDataModeToAppended() xmlTableWriter.SetInputData(modifiedTable) xmlTableWriter.Write() # read the ASCII version
def mask(inpd, fiber_mask, color=None, preserve_point_data=False, preserve_cell_data=True, verbose=True): """ Keep lines and their points where fiber_mask == 1. Unlike vtkMaskPolyData that samples every nth cell, this function uses an actual mask, and also gets rid of points that are not used by any cell, reducing the size of the polydata file. This code also sets scalar cell data to input color data. This input data is expected to be 1 or 3 components. If there is no input cell scalar color data, existing cell scalars that we have created (EmbeddingColor, ClusterNumber, EmbeddingCoordinate) are looked for and masked as well. """ inpoints = inpd.GetPoints() inpointdata = inpd.GetPointData() incelldata = inpd.GetCellData() # output and temporary objects ptids = vtk.vtkIdList() outpd = vtk.vtkPolyData() outlines = vtk.vtkCellArray() outpoints = vtk.vtkPoints() outcolors = None outpointdata = outpd.GetPointData() outcelldata = outpd.GetCellData() tensor_names = [] if color is not None: # if input is RGB if len(color.shape) == 2: if color.shape[1] == 3: outcolors = vtk.vtkUnsignedCharArray() outcolors.SetNumberOfComponents(3) # otherwise output floats as colors if outcolors == None: outcolors = vtk.vtkFloatArray() # check for cell data arrays to keep if preserve_cell_data: if incelldata.GetNumberOfArrays() > 0: cell_data_array_indices = list( range(incelldata.GetNumberOfArrays())) for idx in cell_data_array_indices: array = incelldata.GetArray(idx) dtype = array.GetDataType() if dtype == 10: out_array = vtk.vtkFloatArray() elif dtype == 6: out_array = vtk.vtkIntArray() elif dtype == 3: out_array = vtk.vtkUnsignedCharArray() else: out_array = vtk.vtkFloatArray() out_array.SetNumberOfComponents(array.GetNumberOfComponents()) out_array.SetName(array.GetName()) if verbose: print("Cell data array found:", array.GetName(), array.GetNumberOfComponents()) outcelldata.AddArray(out_array) # make sure some scalars are active so rendering works #outpd.GetCellData().SetActiveScalars(array.GetName()) #if inpd.GetCellData().GetArray('ClusterNumber'): # # this will be active unless we have embedding colors # outpd.GetCellData().SetActiveScalars('ClusterNumber') #if inpd.GetCellData().GetArray('EmbeddingColor'): # # Note Slicer can't display these cell scalars (all is red) # outpd.GetCellData().SetActiveScalars('EmbeddingColor') else: preserve_cell_data = False # check for point data arrays to keep if preserve_point_data: if inpointdata.GetNumberOfArrays() > 0: point_data_array_indices = list( range(inpointdata.GetNumberOfArrays())) for idx in point_data_array_indices: array = inpointdata.GetArray(idx) out_array = vtk.vtkFloatArray() out_array.SetNumberOfComponents(array.GetNumberOfComponents()) out_array.SetName(array.GetName()) if verbose: print("Point data array found:", array.GetName(), array.GetNumberOfComponents()) outpointdata.AddArray(out_array) # make sure some scalars are active so rendering works #outpd.GetPointData().SetActiveScalars(array.GetName()) # keep track of tensors to choose which is active if array.GetNumberOfComponents() == 9: tensor_names.append(array.GetName()) else: preserve_point_data = False # Set up scalars and tensors attributes for correct visualization in Slicer. # Slicer works with point data and does not handle cell data well. # This set of changes breaks old internal wma default visualization of cell scalars. # Changes must be propagated through wma so that render is called with the name of the field to visualize. # the new way in wma is like this line, below. #ren = wma.render.render(output_polydata_s, 1000, data_mode="Cell", data_name='EmbeddingColor') # For Slicer: First set one of the expected tensor arrays as default for vis tensors_labeled = False for name in tensor_names: if name == "tensors": outpd.GetPointData().SetTensors( outpd.GetPointData().GetArray("tensors")) tensors_labeled = True if name == "Tensors": outpd.GetPointData().SetTensors( outpd.GetPointData().GetArray("Tensors")) tensors_labeled = True if name == "tensor1": outpd.GetPointData().SetTensors( outpd.GetPointData().GetArray("tensor1")) tensors_labeled = True if name == "Tensor1": outpd.GetPointData().SetTensors( outpd.GetPointData().GetArray("Tensor1")) tensors_labeled = True if not tensors_labeled: if len(tensor_names) > 0: print( "Data has unexpected tensor name(s). Unable to set active for visualization:", tensor_names) # now set cell data visualization inactive. outpd.GetCellData().SetActiveScalars(None) # loop over lines inpd.GetLines().InitTraversal() outlines.InitTraversal() for lidx in range(0, inpd.GetNumberOfLines()): inpd.GetLines().GetNextCell(ptids) if fiber_mask[lidx]: if verbose: if lidx % 100 == 0: print("<filter.py> Line:", lidx, "/", inpd.GetNumberOfLines()) # get points for each ptid and add to output polydata cellptids = vtk.vtkIdList() for pidx in range(0, ptids.GetNumberOfIds()): point = inpoints.GetPoint(ptids.GetId(pidx)) idx = outpoints.InsertNextPoint(point) cellptids.InsertNextId(idx) if preserve_point_data: for idx in point_data_array_indices: array = inpointdata.GetArray(idx) out_array = outpointdata.GetArray(idx) out_array.InsertNextTuple( array.GetTuple(ptids.GetId(pidx))) outlines.InsertNextCell(cellptids) if color is not None: # this code works with either 3 or 1 component only if outcolors.GetNumberOfComponents() == 3: outcolors.InsertNextTuple3(color[lidx, 0], color[lidx, 1], color[lidx, 2]) else: outcolors.InsertNextTuple1(color[lidx]) if preserve_cell_data: for idx in cell_data_array_indices: array = incelldata.GetArray(idx) out_array = outcelldata.GetArray(idx) out_array.InsertNextTuple(array.GetTuple(lidx)) # put data into output polydata outpd.SetLines(outlines) outpd.SetPoints(outpoints) # if we had an input color requested during masking, set that to be the default scalar for vis if color is not None: outpd.GetCellData().SetScalars(outcolors) if verbose: print("<filter.py> Fibers sampled:", outpd.GetNumberOfLines(), "/", inpd.GetNumberOfLines()) return outpd
det_corners.InsertNextPoint(det_r0cN[0], det_r0cN[1], det_r0cN[2]) det_quad = vtkQuad() det_quad.GetPointIds().SetId(0, 0) det_quad.GetPointIds().SetId(1, 1) det_quad.GetPointIds().SetId(2, 2) det_quad.GetPointIds().SetId(3, 3) quads = vtkCellArray() quads.InsertNextCell(det_quad) det_poly_data = vtkPolyData() det_poly_data.SetPoints(det_corners) det_poly_data.SetPolys(quads) tex_coords = vtkFloatArray() tex_coords.SetNumberOfComponents(2) tex_coords.SetName('TextureCoordinates') tex_coords.InsertNextTuple([0, 0]) tex_coords.InsertNextTuple([0, 1]) tex_coords.InsertNextTuple([1, 1]) tex_coords.InsertNextTuple([1, 0]) det_poly_data.GetPointData().SetTCoords(tex_coords) tex = vtkTexture() tex.SetInputData(proj_vtk_img) plane_mapper = vtkPolyDataMapper() plane_mapper.SetInputData(det_poly_data) plane_mapper.Update()
#http://www.vtk.org/pipermail/vtkusers/2013-February/078465.html import vtk from pyNastran.bdf.bdf import (BDF, CQUAD4, CQUAD8, CQUADR, CSHEAR, CTRIA3, CTRIA6, CTRIAR, CTRIAX6, CTETRA4, CTETRA10, CPENTA6, CPENTA15, CHEXA8, CHEXA20, CBUSH, CBEAM, CONM2) model = BDF() bdf_file = r'C:\Users\Michael\PycharmProjects\FEMAnalysisTool\fem_post\data\rotor.bdf' vtk_file = r'C:\Users\Michael\PycharmProjects\FEMAnalysisTool\fem_post\data\rotor.vtk_widget' model.readBDF(bdf_file, includeDir=None, xref=False) points = vtk.vtkPoints() grid = vtk.vtkUnstructuredGrid() Color = vtk.vtkFloatArray() CntCONM2 = 0 for (eid, element) in model.elements.iteritems(): CntCONM2 = CntCONM2 + 1 Scale = vtk.vtkFloatArray() nidMap = {} EidMap = {} i = 0 for (nid, node) in model.nodes.iteritems(): #node = model.Node(1) cp = node.Cp() coord = model.Coord(cp) pos = coord.transformToGlobal(node.xyz) Coord = []
def make_patterned_polydata(inputContours, fillareastyle=None, fillareaindex=None, fillareacolors=None, fillareaopacity=None, fillareapixelspacing=None, fillareapixelscale=None, size=None, renderer=None): if inputContours is None or fillareastyle == 'solid': return None if inputContours.GetNumberOfCells() == 0: return None if fillareaindex is None: fillareaindex = 1 if fillareaopacity is None: fillareaopacity = 100 if fillareapixelspacing is None: if size is not None: sp = int(0.015 * min(size[0], size[1])) fillareapixelspacing = 2 * [sp if sp > 1 else 1] else: fillareapixelspacing = [15, 15] if fillareapixelscale is None: fillareapixelscale = 1.0 * min(fillareapixelspacing[0], fillareapixelspacing[1]) # Create a point set laid out on a plane that will be glyphed with the # pattern / hatch # The bounds of the plane match the bounds of the input polydata bounds = inputContours.GetBounds() patternPolyData = vtk.vtkPolyData() patternPts = vtk.vtkPoints() patternPolyData.SetPoints(patternPts) xBounds = bounds[1] - bounds[0] yBounds = bounds[3] - bounds[2] xres = yres = 1 scale = [1.0, 1.0] if renderer is not None: # Be smart about calculating the resolution by taking the screen pixel # size into account # First, convert a distance of one unit screen distance to data # coordinates point1 = [1.0, 1.0, 0.0] point2 = [0.0, 0.0, 0.0] renderer.SetDisplayPoint(point1) renderer.DisplayToWorld() wpoint1 = renderer.GetWorldPoint() renderer.SetDisplayPoint(point2) renderer.DisplayToWorld() wpoint2 = renderer.GetWorldPoint() diffwpoints = [ abs(wpoint1[0] - wpoint2[0]), abs(wpoint1[1] - wpoint2[1]) ] diffwpoints = [1.0 if i < 1e-6 else i for i in diffwpoints] # Choosing an arbitary factor to scale the number of points. A spacing # of 10 pixels and a scale of 7.5 pixels was chosen based on visual # inspection of result. Essentially, it means each glyph is 10 pixels # away from its neighbors and 7.5 pixels high and wide. xres = int(xBounds / (fillareapixelspacing[0] * diffwpoints[0])) + 1 yres = int(yBounds / (fillareapixelspacing[1] * diffwpoints[1])) + 1 scale = [fillareapixelscale * x for x in diffwpoints[:2]] else: if xBounds <= 1 and yBounds <= 1 and size is not None: xBounds *= size[0] / 3 yBounds *= size[1] / 3 xres = int(xBounds / 3) yres = int(yBounds / 3) numPts = (xres + 1) * (yres + 1) patternPts.Allocate(numPts) normals = vtk.vtkFloatArray() normals.SetName("Normals") normals.SetNumberOfComponents(3) normals.Allocate(3 * numPts) tcoords = vtk.vtkFloatArray() tcoords.SetName("TextureCoordinates") tcoords.SetNumberOfComponents(2) tcoords.Allocate(2 * numPts) x = [0.0, 0.0, 0.0] tc = [0.0, 0.0] v1 = [0.0, bounds[3] - bounds[2]] v2 = [bounds[1] - bounds[0], 0.0] normal = [0.0, 0.0, 1.0] numPt = 0 for i in range(yres + 1): tc[0] = i * 1.0 / yres for j in range(xres + 1): tc[1] = j * 1.0 / xres for ii in range(2): x[ii] = bounds[2 * ii] + tc[0] * v1[ii] + tc[1] * v2[ii] patternPts.InsertPoint(numPt, x) tcoords.InsertTuple(numPt, tc) normals.InsertTuple(numPt, normal) numPt += 1 patternPolyData.GetPointData().SetNormals(normals) patternPolyData.GetPointData().SetTCoords(tcoords) # Create the pattern create_pattern(patternPolyData, scale, fillareastyle, fillareaindex) # Create pipeline to create a clipped polydata from the pattern plane. cutter = vtk.vtkCookieCutter() cutter.SetInputData(patternPolyData) cutter.SetLoopsData(inputContours) cutter.Update() # Now map the colors as cell scalars. # We are doing this here because the vtkCookieCutter does not preserve # cell scalars map_colors(cutter.GetOutput(), fillareastyle, fillareacolors, fillareaopacity) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(cutter.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) return actor
# coordinates x = linspace(-lx / 2, lx / 2, Nx + 1) y = linspace(-ly / 2, ly / 2, Ny + 1) z = linspace(-lz / 2, lz / 2, Nz + 1) # cell centers xmid = 0.5 * (x[1:] + x[:-1]) ymid = 0.5 * (y[1:] + y[:-1]) zmid = 0.5 * (z[1:] + z[:-1]) ### VTK STUFF ### import vtk xpoints = vtk.vtkFloatArray() ypoints = vtk.vtkFloatArray() zpoints = vtk.vtkFloatArray() xpoints.SetNumberOfComponents(1) ypoints.SetNumberOfComponents(1) zpoints.SetNumberOfComponents(1) grid = vtk.vtkRectilinearGrid() if centered == 'point': xpoints.SetNumberOfTuples(Nx) for i in xrange(Nx): xpoints.SetTuple1(i, xmid[i]) ypoints.SetNumberOfTuples(Ny)
def testLinePlot(self): "Test if colored scatter plots can be built with python" # Set up a 2D scene, add an XY chart to it view = vtk.vtkContextView() view.GetRenderer().SetBackground(1.0, 1.0, 1.0) view.GetRenderWindow().SetSize(400, 300) chart = vtk.vtkChartXY() chart.SetShowLegend(True) view.GetScene().AddItem(chart) # Create a table with some points in it arrX = vtk.vtkFloatArray() arrX.SetName("XAxis") arrC = vtk.vtkFloatArray() arrC.SetName("Cosine") arrS = vtk.vtkFloatArray() arrS.SetName("Sine") arrS2 = vtk.vtkFloatArray() arrS2.SetName("Tan") numPoints = 40 inc = 7.5 / (numPoints - 1) for i in range(numPoints): arrX.InsertNextValue(i * inc) arrC.InsertNextValue(math.cos(i * inc) + 0.0) arrS.InsertNextValue(math.sin(i * inc) + 0.0) arrS2.InsertNextValue(math.tan(i * inc) + 0.5) table = vtk.vtkTable() table.AddColumn(arrX) table.AddColumn(arrC) table.AddColumn(arrS) table.AddColumn(arrS2) # Generate a black-to-red lookup table with fixed alpha lut = vtk.vtkLookupTable() lut.SetValueRange(0.2, 1.0) lut.SetSaturationRange(1, 1) lut.SetHueRange(0, 0) lut.SetRampToLinear() lut.SetRange(-1, 1) lut.SetAlpha(0.75) lut.Build() # Generate a black-to-blue lookup table with alpha range lut2 = vtk.vtkLookupTable() lut2.SetValueRange(0.2, 1.0) lut2.SetSaturationRange(1, 1) lut2.SetHueRange(0.6667, 0.6667) lut2.SetAlphaRange(0.4, 0.8) lut2.SetRampToLinear() lut2.SetRange(-1, 1) lut2.Build() # Add multiple line plots, setting the colors etc points0 = chart.AddPlot(vtk.vtkChart.POINTS) points0.SetInput(table, 0, 1) points0.SetColor(0, 0, 0, 255) points0.SetWidth(1.0) points0.SetMarkerStyle(vtk.vtkPlotPoints.CROSS) points1 = chart.AddPlot(vtk.vtkChart.POINTS) points1.SetInput(table, 0, 2) points1.SetColor(0, 0, 0, 255) points1.SetMarkerStyle(vtk.vtkPlotPoints.DIAMOND) points1.SetScalarVisibility(1) points1.SetLookupTable(lut) points1.SelectColorArray(1) points2 = chart.AddPlot(vtk.vtkChart.POINTS) points2.SetInput(table, 0, 3) points2.SetColor(0, 0, 0, 255) points2.ScalarVisibilityOn() points2.SetLookupTable(lut2) points2.SelectColorArray("Cosine") points2.SetWidth(4.0) view.GetRenderWindow().SetMultiSamples(0) view.GetRenderWindow().Render() img_file = "TestScatterPlotColors.png" vtk.test.Testing.compareImage( view.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25) vtk.test.Testing.interact()
def main(): colors = vtk.vtkNamedColors() numTuples = 12 bitter = vtk.vtkFloatArray() bitter.SetNumberOfTuples(numTuples) crispy = vtk.vtkFloatArray() crispy.SetNumberOfTuples(numTuples) crunchy = vtk.vtkFloatArray() crunchy.SetNumberOfTuples(numTuples) salty = vtk.vtkFloatArray() salty.SetNumberOfTuples(numTuples) oily = vtk.vtkFloatArray() oily.SetNumberOfTuples(numTuples) rand_seq = vtk.vtkMinimalStandardRandomSequence() rand_seq.SetSeed(1) for i in range(numTuples): bitter.SetTuple1(i, rand_seq.GetRangeValue(1, 10)) rand_seq.Next() crispy.SetTuple1(i, rand_seq.GetRangeValue(-1, 1)) rand_seq.Next() crunchy.SetTuple1(i, rand_seq.GetRangeValue(1, 100)) rand_seq.Next() salty.SetTuple1(i, rand_seq.GetRangeValue(0, 10)) rand_seq.Next() oily.SetTuple1(i, rand_seq.GetRangeValue(5, 25)) rand_seq.Next() dobj = vtk.vtkDataObject() dobj.GetFieldData().AddArray(bitter) dobj.GetFieldData().AddArray(crispy) dobj.GetFieldData().AddArray(crunchy) dobj.GetFieldData().AddArray(salty) dobj.GetFieldData().AddArray(oily) actor = vtk.vtkSpiderPlotActor() actor.SetInputData(dobj) actor.SetTitle("Spider Plot") actor.SetIndependentVariablesToColumns() actor.GetPositionCoordinate().SetValue(0.05, 0.1, 0.0) actor.GetPosition2Coordinate().SetValue(0.95, 0.85, 0.0) actor.GetProperty().SetColor(colors.GetColor3d('Bisque')) actor.SetAxisLabel(0, "Bitter") actor.SetAxisRange(0, 1, 10) actor.SetAxisLabel(1, "Crispy") actor.SetAxisRange(1, -1, 1) actor.SetAxisLabel(2, "Crunchy") actor.SetAxisRange(2, 1, 100) actor.SetAxisLabel(3, "Salty") actor.SetAxisRange(3, 0, 10) actor.SetAxisLabel(4, "Oily") actor.SetAxisRange(4, 5, 25) actor.GetLegendActor().SetNumberOfEntries(numTuples) for i in range(numTuples): r = rand_seq.GetValue() rand_seq.Next() g = rand_seq.GetValue() rand_seq.Next() b = rand_seq.GetValue() rand_seq.Next() actor.SetPlotColor(i, r, g, b) actor.LegendVisibilityOn() actor.GetTitleTextProperty().SetColor(colors.GetColor3d('Yellow')) actor.GetLabelTextProperty().SetColor(colors.GetColor3d('OrangeRed')) ren1 = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) ren1.AddActor(actor) ren1.SetBackground(colors.GetColor3d('Black')) renWin.SetSize(800, 800) iren.Initialize() renWin.Render() iren.Start()
list_read_proc.extend(range(Z,Nprocs,ZLEN)) list_read_proc=scipy.array(list_read_proc) zread_proc=len(list_read_proc)/(YLEN*XLEN) #Number of proc file you want to read in the z direction Nzlocal=zread_proc*(shape[2]-1)+1 Fields_local = scipy.zeros((6,Nxc+1,Nyc+1,Nzlocal),dtype="float32") # 6 for 6 components of the field numproc=min(numproc,ZLEN) # To account for specific case where more processors are used here than in the Z direction of the simulation if len(list_read_proc) > 0: numpoints = (Nxc+1)*(Nyc+1)*Nzlocal Xcoordinates = scipy.arange(Nxc+1).flatten().astype('float32')*dx Ycoordinates = scipy.arange(Nyc+1).flatten().astype('float32')*dy Zcoordinates = (scipy.arange(Nzlocal).flatten().astype('float32')+list_read_proc[0]*(shape[2]-1))*dz vtkXcoordinates = vtk.vtkFloatArray() vtkXcoordinates.SetNumberOfComponents(1) vtkXcoordinates.SetNumberOfTuples(Nxc+1) vtkXcoordinates.SetVoidArray(Xcoordinates,Nxc+1,1) vtkYcoordinates = vtk.vtkFloatArray() vtkYcoordinates.SetNumberOfComponents(1) vtkYcoordinates.SetNumberOfTuples(Nyc+1) vtkYcoordinates.SetVoidArray(Ycoordinates,Nyc+1,1) vtkZcoordinates = vtk.vtkFloatArray() vtkZcoordinates.SetNumberOfComponents(1) vtkZcoordinates.SetNumberOfTuples(Nzlocal) vtkZcoordinates.SetVoidArray(Zcoordinates,Nzlocal,1) ########################################################################################### ## FIELDS ## ###########################################################################################
""" vtk_cell_array = vtk.vtkCellArray() vtk_cell_array.InsertNextCell(npts) for i in range(npts): vtk_cell_array.InsertCellPoint(i) """ vtk.vtkFLoatArray(): A set of values associated with the initial points, be it force magnitudes at the point or bending moments, can be captured as a scalar array of floating point values with the vtkFloatArray object. this is done by first declaring the number of scalars with the vtk_float_array.SetNumberOfValues(npts) method and then enumerating through the points and using the vtk_float_array.SetValue(i, value) method. """ value = lambda i: math.fabs(math.sin(math.pi * i / 30.)) vtk_float_array = vtk.vtkFloatArray() vtk_float_array.SetNumberOfValues(npts) for i in range(npts): vtk_float_array.SetValue(i, value(i)) """ vtk.vtkPolyData(): The point connectivity and scalar values can be encapsulated in the vtkPolyData object this is done by using the, vtk_poly_data.SetPoints(vtk_points), vtk_poly_data.SetLines(vtk_cell_array) and vtk_poly_data.GetPointData().SetScalars(vtkFLoatArray) methods """ vtk_poly_data = vtk.vtkPolyData() vtk_poly_data.SetPoints(vtk_points) vtk_poly_data.SetLines(vtk_cell_array) vtk_poly_data.GetPointData().SetScalars(vtk_float_array) """ vtk.vtkSplineFilter(): The data can be smoothly interpolated across a
def extract_slice_thickness_LVonly(nsubdivision, domain, verbose=True): refinedmesh = vtk.vtkLoopSubdivisionFilter() refinedmesh.SetNumberOfSubdivisions(nsubdivision) refinedmesh.SetInput(domain) refinedmesh.Update() bds = domain.GetBounds() ctr = [0, 0, 0] ctr[0] = 0.5 * (bds[0] + bds[1]) ctr[1] = 0.5 * (bds[2] + bds[3]) ctr[2] = 0.5 * (bds[4] + bds[5]) featureEdges = vtk.vtkFeatureEdges() featureEdges.SetInput(refinedmesh.GetOutput()) featureEdges.BoundaryEdgesOn() featureEdges.FeatureEdgesOff() featureEdges.ManifoldEdgesOff() featureEdges.NonManifoldEdgesOff() featureEdges.Update() connectfilter = vtk.vtkPolyDataConnectivityFilter() connectfilter.SetInput(featureEdges.GetOutput()) connectfilter.SetExtractionModeToSpecifiedRegions() connectfilter.Update() epi = vtk.vtkPolyData() LVendo = vtk.vtkPolyData() connectfilter.SetExtractionModeToClosestPointRegion() connectfilter.SetClosestPoint(ctr[0], ctr[1] + 1000, ctr[2] + 1000) connectfilter.Update() epi.DeepCopy(connectfilter.GetOutput()) epi = clean_pdata(epi) connectfilter.SetClosestPoint(ctr[0], ctr[1], ctr[2]) connectfilter.Update() LVendo.DeepCopy(connectfilter.GetOutput()) LVendo = clean_pdata(LVendo) epipointlocator = vtk.vtkPointLocator() epipointlocator.SetDataSet(epi) epipointlocator.BuildLocator() LVendopointlocator = vtk.vtkPointLocator() LVendopointlocator.SetDataSet(LVendo) LVendopointlocator.BuildLocator() epidistance = vtk.vtkFloatArray() epidistance.SetName("Thickness") for p in range(0, epi.GetNumberOfPoints()): pt = epi.GetPoints().GetPoint(p) LVendoid = LVendopointlocator.FindClosestPoint(pt) LVendopt = LVendo.GetPoints().GetPoint(LVendoid) disttoLVendo = math.sqrt( vtk.vtkMath.Distance2BetweenPoints(pt, LVendopt)) epidistance.InsertNextValue(disttoLVendo) epi.GetPointData().SetActiveScalars("Thickness") epi.GetPointData().SetScalars(epidistance) return epi
def anisotropic_smooth(inpd, fiber_distance_threshold, points_per_fiber=30, n_jobs=2, cluster_max=10): """ Average nearby fibers. The pairwise fiber distance matrix is computed, then fibers are averaged with their neighbors until an edge (>max_fiber_distance) is encountered. """ # polydata to array conversion, fixed-length fiber representation current_fiber_array = fibers.FiberArray() current_fiber_array.points_per_fiber = points_per_fiber current_fiber_array.convert_from_polydata(inpd) original_number_of_fibers = current_fiber_array.number_of_fibers # fiber list data structure initialization for easy fiber averaging curr_count = list() curr_fibers = list() curr_indices = list() for lidx in range(0, current_fiber_array.number_of_fibers): curr_fibers.append(current_fiber_array.get_fiber(lidx)) curr_count.append(1) curr_indices.append(list([lidx])) converged = False iteration_count = 0 while not converged: print("<filter.py> ITERATION:", iteration_count, "SUM FIBER COUNTS:", numpy.sum(numpy.array(curr_count))) print("<filter.py> number indices", len(curr_indices)) # fiber data structures for output of this iteration next_fibers = list() next_count = list() next_indices = list() # information for this iteration done = numpy.zeros(current_fiber_array.number_of_fibers) fiber_indices = list(range(0, current_fiber_array.number_of_fibers)) # if the maximum number of fibers have been combined, stop averaging this fiber done[numpy.nonzero(numpy.array(curr_count) >= cluster_max)] = 1 # pairwise distance matrix if USE_PARALLEL: distances = Parallel(n_jobs=n_jobs, verbose=1)(delayed(similarity.fiber_distance)( current_fiber_array.get_fiber(lidx), current_fiber_array, 0, 'Hausdorff') for lidx in fiber_indices) distances = numpy.array(distances) else: distances = \ numpy.zeros( (current_fiber_array.number_of_fibers, current_fiber_array.number_of_fibers)) for lidx in fiber_indices: distances[lidx, :] = \ similarity.fiber_distance( current_fiber_array.get_fiber(lidx), current_fiber_array, 0, 'Hausdorff') # distances to self are not of interest for lidx in fiber_indices: distances[lidx, lidx] = numpy.inf # sort the pairwise distances. distances_flat = distances.flatten() pair_order = numpy.argsort(distances_flat) print("<filter.py> DISTANCE MIN:", distances_flat[pair_order[0]], \ "DISTANCE COUNT:", distances.shape) # if the smallest distance is greater or equal to the # threshold, we have converged if distances_flat[pair_order[0]] >= fiber_distance_threshold: converged = True print("<filter.py> CONVERGED") break else: print("<filter.py> NOT CONVERGED") # loop variables idx = 0 pair_idx = pair_order[idx] number_of_fibers = distances.shape[0] number_averages = 0 # combine nearest neighbors unless done, until hit threshold while distances_flat[pair_idx] < fiber_distance_threshold: # find the fiber indices corresponding to this pairwise distance # use div and mod f_row = pair_idx / number_of_fibers f_col = pair_idx % number_of_fibers # check if this neighbor pair can be combined combine = (not done[f_row]) and (not done[f_col]) if combine: done[f_row] += 1 done[f_col] += 1 # weighted average of the fibers (depending on how many each one represents) next_fibers.append( (curr_fibers[f_row] * curr_count[f_row] + \ curr_fibers[f_col] *curr_count[f_col]) / \ (curr_count[f_row] + curr_count[f_col])) # this was the regular average #next_fibers.append((curr_fibers[f_row] + curr_fibers[f_col])/2) next_count.append(curr_count[f_row] + curr_count[f_col]) number_averages += 1 #next_indices.append(list([curr_indices[f_row], curr_indices[f_col]])) next_indices.append( list(curr_indices[f_row] + curr_indices[f_col])) # increment for the loop idx += 1 pair_idx = pair_order[idx] # copy through any unvisited (already converged) fibers unvisited = numpy.nonzero(done == 0)[0] for fidx in unvisited: next_fibers.append(curr_fibers[fidx]) next_count.append(curr_count[fidx]) next_indices.append(curr_indices[fidx]) # set up for next iteration curr_fibers = next_fibers curr_count = next_count curr_indices = next_indices iteration_count += 1 # set up array for next iteration distance computation current_fiber_array = fibers.FiberArray() current_fiber_array.number_of_fibers = len(curr_fibers) current_fiber_array.points_per_fiber = points_per_fiber dims = [ current_fiber_array.number_of_fibers, current_fiber_array.points_per_fiber ] # fiber data current_fiber_array.fiber_array_r = numpy.zeros(dims) current_fiber_array.fiber_array_a = numpy.zeros(dims) current_fiber_array.fiber_array_s = numpy.zeros(dims) curr_fidx = 0 for curr_fib in curr_fibers: current_fiber_array.fiber_array_r[curr_fidx] = curr_fib.r current_fiber_array.fiber_array_a[curr_fidx] = curr_fib.a current_fiber_array.fiber_array_s[curr_fidx] = curr_fib.s curr_fidx += 1 print("<filter.py> SUM FIBER COUNTS:", numpy.sum(numpy.array(curr_count)), "SUM DONE FIBERS:", numpy.sum(done)) print("<filter.py> MAX COUNT:", numpy.max(numpy.array(curr_count)), "AVGS THIS ITER:", number_averages) # when converged, convert output to polydata outpd = current_fiber_array.convert_to_polydata() # color output by the number of fibers that each output fiber corresponds to outcolors = vtk.vtkFloatArray() outcolors.SetName('FiberTotal') for count in curr_count: outcolors.InsertNextTuple1(count) outpd.GetCellData().SetScalars(outcolors) # also color the input pd by output cluster number cluster_numbers = numpy.zeros(original_number_of_fibers) cluster_count = numpy.zeros(original_number_of_fibers) cluster_idx = 0 for index_list in curr_indices: indices = numpy.array(index_list).astype(int) cluster_numbers[indices] = cluster_idx cluster_count[indices] = curr_count[cluster_idx] cluster_idx += 1 outclusters = vtk.vtkFloatArray() outclusters.SetName('ClusterNumber') for cluster in cluster_numbers: outclusters.InsertNextTuple1(cluster) inpd.GetCellData().AddArray(outclusters) inpd.GetCellData().SetActiveScalars('ClusterNumber') return outpd, numpy.array(curr_count), inpd, cluster_numbers, cluster_count
def spheres(centers, r=1, c='r', alpha=1, wire=False, legend=None, texture=None, res=8): ''' Build a (possibly large) set of spheres at `centers` of radius `r`. Either `c` or `r` can be a list of RGB colors or radii. .. hint:: Example: `manyspheres.py <https://github.com/marcomusy/vtkplotter/blob/master/examples/basic/manyspheres.py>`_ .. image:: https://user-images.githubusercontent.com/32848391/46818673-1f566b80-cd82-11e8-9a61-be6a56160f1c.png ''' cisseq = False if utils.isSequence(c): cisseq = True if cisseq: if len(centers) > len(c): colors.printc("Mismatch in spheres() colors", len(centers), len(c), c=1) exit() if len(centers) != len(c): colors.printc("Warning: mismatch in spheres() colors", len(centers), len(c)) risseq = False if utils.isSequence(r): risseq = True if risseq: if len(centers) > len(r): colors.printc("Mismatch in spheres() radius", len(centers), len(r), c=1) exit() if len(centers) != len(r): colors.printc("Warning: mismatch in spheres() radius", len(centers), len(r)) if cisseq and risseq: colors.printc("Limitation: c and r cannot be both sequences.", c=1) exit() src = vtk.vtkSphereSource() if not risseq: src.SetRadius(r) src.SetPhiResolution(res) src.SetThetaResolution(2 * res) src.Update() glyph = vtk.vtkGlyph3D() glyph.SetSourceConnection(src.GetOutputPort()) psrc = vtk.vtkPointSource() psrc.SetNumberOfPoints(len(centers)) psrc.Update() pd = psrc.GetOutput() vpts = pd.GetPoints() if cisseq: glyph.SetColorModeToColorByScalar() ucols = vtk.vtkUnsignedCharArray() ucols.SetNumberOfComponents(3) ucols.SetName("colors") for i, p in enumerate(centers): vpts.SetPoint(i, p) cc = np.array(colors.getColor(c[i])) * 255 ucols.InsertNextTuple3(cc[0], cc[1], cc[2]) pd.GetPointData().SetScalars(ucols) glyph.ScalingOff() elif risseq: glyph.SetScaleModeToScaleByScalar() urads = vtk.vtkFloatArray() urads.SetName("scales") for i, p in enumerate(centers): vpts.SetPoint(i, p) urads.InsertNextValue(r[i]) pd.GetPointData().SetScalars(urads) else: for i, p in enumerate(centers): vpts.SetPoint(i, p) glyph.SetInputData(pd) glyph.Update() mapper = vtk.vtkPolyDataMapper() mapper.SetInputData(glyph.GetOutput()) if cisseq: mapper.ScalarVisibilityOn() else: mapper.ScalarVisibilityOff() actor = Actor() #vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetInterpolationToPhong() # check if color string contains a float, in this case ignore alpha al = colors._getAlpha(c) if al: alpha = al actor.GetProperty().SetOpacity(alpha) if not cisseq: if texture is not None: actor.texture(texture) mapper.ScalarVisibilityOff() else: actor.GetProperty().SetColor(colors.getColor(c)) return actor
def testImagePlaneWidget(self): "A more rigorous test using the image plane widget." # This test is largely copied from # Widgets/Python/TestImagePlaneWidget.py # Load some data. v16 = vtk.vtkVolume16Reader() v16.SetDataDimensions(64, 64) v16.SetDataByteOrderToLittleEndian() v16.SetFilePrefix(os.path.join(VTK_DATA_ROOT, "Data", "headsq", "quarter")) v16.SetImageRange(1, 93) v16.SetDataSpacing(3.2, 3.2, 1.5) v16.Update() xMin, xMax, yMin, yMax, zMin, zMax = v16.GetExecutive().GetWholeExtent(v16.GetOutputInformation(0)) img_data = v16.GetOutput() spacing = img_data.GetSpacing() sx, sy, sz = spacing origin = img_data.GetOrigin() ox, oy, oz = origin # An outline is shown for context. outline = vtk.vtkOutlineFilter() outline.SetInputData(img_data) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInputConnection(outline.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(outlineMapper) # The shared picker enables us to use 3 planes at one time # and gets the picking order right picker = vtk.vtkCellPicker() picker.SetTolerance(0.005) # The 3 image plane widgets are used to probe the dataset. planeWidgetX = vtk.vtkImagePlaneWidget() planeWidgetX.DisplayTextOn() planeWidgetX.SetInputData(img_data) planeWidgetX.SetPlaneOrientationToXAxes() planeWidgetX.SetSliceIndex(32) planeWidgetX.SetPicker(picker) planeWidgetX.SetKeyPressActivationValue("x") prop1 = planeWidgetX.GetPlaneProperty() prop1.SetColor(1, 0, 0) planeWidgetY = vtk.vtkImagePlaneWidget() planeWidgetY.DisplayTextOn() planeWidgetY.SetInputData(img_data) planeWidgetY.SetPlaneOrientationToYAxes() planeWidgetY.SetSliceIndex(32) planeWidgetY.SetPicker(picker) planeWidgetY.SetKeyPressActivationValue("y") prop2 = planeWidgetY.GetPlaneProperty() prop2.SetColor(1, 1, 0) planeWidgetY.SetLookupTable(planeWidgetX.GetLookupTable()) # for the z-slice, turn off texture interpolation: # interpolation is now nearest neighbour, to demonstrate # cross-hair cursor snapping to pixel centers planeWidgetZ = vtk.vtkImagePlaneWidget() planeWidgetZ.DisplayTextOn() planeWidgetZ.SetInputData(img_data) planeWidgetZ.SetPlaneOrientationToZAxes() planeWidgetZ.SetSliceIndex(46) planeWidgetZ.SetPicker(picker) planeWidgetZ.SetKeyPressActivationValue("z") prop3 = planeWidgetZ.GetPlaneProperty() prop3.SetColor(0, 0, 1) planeWidgetZ.SetLookupTable(planeWidgetX.GetLookupTable()) # Now create another actor with an opacity < 1 and with some # scalars. p = vtk.vtkPolyData() pts = vtk.vtkPoints() pts.InsertNextPoint((0,0,0)) sc = vtk.vtkFloatArray() sc.InsertNextValue(1.0) p.SetPoints(pts) p.GetPointData().SetScalars(sc) m = vtk.vtkPolyDataMapper() m.SetInputData(p) # Share the lookup table of the widgets. m.SetLookupTable(planeWidgetX.GetLookupTable()) m.UseLookupTableScalarRangeOn() dummyActor = vtk.vtkActor() dummyActor.SetMapper(m) dummyActor.GetProperty().SetOpacity(0.0) # Create the RenderWindow and Renderer ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.SetMultiSamples(0) renWin.AddRenderer(ren) # Add the dummy actor. ren.AddActor(dummyActor) # Add the outline actor to the renderer, set the background # color and size ren.AddActor(outlineActor) renWin.SetSize(600, 600) ren.SetBackground(0.1, 0.1, 0.2) current_widget = planeWidgetZ mode_widget = planeWidgetZ # Set the interactor for the widgets iact = vtk.vtkRenderWindowInteractor() iact.SetRenderWindow(renWin) planeWidgetX.SetInteractor(iact) planeWidgetX.On() planeWidgetY.SetInteractor(iact) planeWidgetY.On() planeWidgetZ.SetInteractor(iact) planeWidgetZ.On() # Create an initial interesting view ren.ResetCamera(); cam1 = ren.GetActiveCamera() cam1.Elevation(110) cam1.SetViewUp(0, 0, -1) cam1.Azimuth(45) ren.ResetCameraClippingRange() iact.Initialize() renWin.Render()
est_time_list_i = [] est_rad_pt_list_i = [] regression_output_folder_path = '/media/shong/IntHard1/4DAnalysis/IPMI2019/GeodesicRegressionResults/CMRep_Abstract_CTRL_Group_LC_NewCode_Linearized/' for n in range(nTimePt): outFileName = 'CMRep_Abstract_Regression_CTRL_LC_' + str(n) + '.vtk' output_path = regression_output_folder_path + outFileName time_pt = (tN - t0) * n / (nTimePt - 1) + t0 polyData_t = vtk.vtkPolyData() polyData_t.DeepCopy(meanPolyData) radiusArr_t_vtk = vtk.vtkFloatArray() radiusArr_t_vtk.SetNumberOfValues(polyData_t.GetNumberOfPoints()) radiusArr_t_vtk.SetName('Radius') R2_posArr_t_vtk = vtk.vtkFloatArray() R2_posArr_t_vtk.SetNumberOfValues(polyData_t.GetNumberOfPoints()) R2_posArr_t_vtk.SetName('R2_pos') R2_radArr_t_vtk = vtk.vtkFloatArray() R2_radArr_t_vtk.SetNumberOfValues(polyData_t.GetNumberOfPoints()) R2_radArr_t_vtk.SetName('R2_rad') RMSE_posArr_t_vtk = vtk.vtkFloatArray() RMSE_posArr_t_vtk.SetNumberOfValues(polyData_t.GetNumberOfPoints()) RMSE_posArr_t_vtk.SetName('RMSE_pos')
def __init__(self, volume, level=None): self._surface_algorithm = None self._renderer = None self._actor = None self._mapper = None self._volume_array = None self._float_array = _vtk.vtkFloatArray() self._image_data = _vtk.vtkImageData() self._image_data.GetPointData().SetScalars(self._float_array) self._setup_data(_numpy.float32(volume)) self._surface_algorithm = _vtk.vtkMarchingCubes() self._surface_algorithm.SetInputData(self._image_data) self._surface_algorithm.ComputeNormalsOn() if level is not None: try: self.set_multiple_levels(iter(level)) except TypeError: self.set_level(0, level) self._mapper = _vtk.vtkPolyDataMapper() self._mapper.SetInputConnection(self._surface_algorithm.GetOutputPort()) self._mapper.ScalarVisibilityOn() # new self._actor = _vtk.vtkActor() self._actor.SetMapper(self._mapper)