def StructuredPointProbe(self, nx, ny, nz, bounding_box=None): """ Probe the unstructured grid dataset using a structured points dataset. """ probe = vtk.vtkProbeFilter() if vtk.vtkVersion.GetVTKMajorVersion() <= 5: probe.SetSource(self.ugrid) else: probe.SetSourceData(self.ugrid) sgrid = vtk.vtkStructuredPoints() bbox = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0] if bounding_box == None: bbox = self.ugrid.GetBounds() else: bbox = bounding_box sgrid.SetOrigin([bbox[0], bbox[2], bbox[4]]) sgrid.SetDimensions(nx, ny, nz) spacing = [0.0, 0.0, 0.0] if nx > 1: spacing[0] = (bbox[1] - bbox[0]) / (nx - 1.0) if ny > 1: spacing[1] = (bbox[3] - bbox[2]) / (ny - 1.0) if nz > 1: spacing[2] = (bbox[5] - bbox[4]) / (nz - 1.0) sgrid.SetSpacing(spacing) if vtk.vtkVersion.GetVTKMajorVersion() <= 5: probe.SetInput(sgrid) else: probe.SetInputData(sgrid) probe.Update() return probe.GetOutput()
def create_structured_points3D(x, y, z, s): """Creates a vtkStructuredPoints object given input data in the form of numpy arrays. Input Arguments: x -- Array of x-coordinates. These should be regularly spaced. y -- Array of y-coordinates. These should be regularly spaced. z -- Array of y-coordinates. These should be regularly spaced. s -- Array of scalar values for the x, y, z values given. """ nx = len(x) ny = len(y) nz = len(z) ns = N.size(s) assert nx*ny*nz == ns, "len(x)*len(y)*len(z) != len(s)"\ "You passed nx=%d, ny=%d, nz=%d, ns=%d"%(nx, ny, nz, ns) xmin, ymin, zmin = x[0], y[0], z[0] dx, dy, dz= (x[1] - x[0]), (y[1] - y[0]), (z[1] - z[0]) sp = vtk.vtkStructuredPoints() sp.SetDimensions(nx, ny, nz) sp.SetOrigin(xmin, ymin, zmin) sp.SetSpacing(dx, dy, dz) sc = array2vtk(s) sp.GetPointData().SetScalars(sc) return sp
def create_probe(filename): if(verbose): print "Creating probe from ", filename pd = vtk.vtkStructuredPoints() reader = vtk.vtkXMLUnstructuredGridReader() reader.SetFileName(filename) ugrid = reader.GetOutput() ugrid.Update() b = ugrid.GetBounds() pd.SetOrigin(b[0], b[2], b[4]) l = [b[1] - b[0], b[3] - b[2], b[5] - b[4]] tot_len = float(l[0] + l[1] + l[2]) dims = intervals pd.SetExtent(0, dims[0]-1, 0, dims[1] -1, 0, dims[2] -1) pd.SetUpdateExtent(0, dims[0]-1, 0, dims[1] -1, 0, dims[2] -1) pd.SetWholeExtent(0, dims[0]-1, 0, dims[1] -1, 0, dims[2] -1) pd.SetDimensions(dims) dims = [max(1, x-1) for x in dims] l = [max(1e-3, x) for x in l] sp = [l[0]/dims[0], l[1]/dims[1], l[2]/dims[2]] pd.SetSpacing(sp) return pd
def probe_grid(data, resolution=(250, 250, 250)): x0, x1, y0, y1, z0, z1 = data.GetBounds() if hasattr(data, "GetDimensions"): nx, ny, nz = data.GetDimensions() log.warning( "The data has specific dimensions ({}, {}, {}): ignoring the provided resolution." .format(nx, ny, nz)) else: nx, ny, nz = resolution struct_p = vtk.vtkStructuredPoints() struct_p.SetOrigin(x0, y0, z0) struct_p.SetDimensions(nx, ny, nz) struct_p.SetSpacing((x1 - x0) / nx, (y1 - y0) / ny, (z1 - z0) / nz) probe = vtk.vtkProbeFilter() probe.SetInputData(struct_p) probe.SetSourceData(data) log.warning("Starting probe. The process may take a long time.", draw_win=False) probe.Update() log.warning("Probe complete.", draw_win=False) probe_out = probe.GetOutput() return probe_out
def create_probe(filename): if (verbose): print "Creating probe from ", filename pd = vtk.vtkStructuredPoints() reader = vtk.vtkXMLUnstructuredGridReader() reader.SetFileName(filename) ugrid = reader.GetOutput() ugrid.Update() b = ugrid.GetBounds() pd.SetOrigin(b[0], b[2], b[4]) l = [b[1] - b[0], b[3] - b[2], b[5] - b[4]] tot_len = float(l[0] + l[1] + l[2]) dims = intervals pd.SetExtent(0, dims[0] - 1, 0, dims[1] - 1, 0, dims[2] - 1) pd.SetUpdateExtent(0, dims[0] - 1, 0, dims[1] - 1, 0, dims[2] - 1) pd.SetWholeExtent(0, dims[0] - 1, 0, dims[1] - 1, 0, dims[2] - 1) pd.SetDimensions(dims) dims = [max(1, x - 1) for x in dims] l = [max(1e-3, x) for x in l] sp = [l[0] / dims[0], l[1] / dims[1], l[2] / dims[2]] pd.SetSpacing(sp) return pd
def writePicture(filename,image): #image reshape imageLength=image.shape[0] imageWidth=image.shape[1] image=image.reshape(imageLength*imageWidth,1) #create a data array to stock these values data_array=vtk.vtkFloatArray() data_array.SetNumberOfValues(len(image)) for i in range(0,len(image)): data_array.SetValue(i,image[i][0]) #create an ImageData called vtkStructuredPoints which stocks the pixel/voxel value of the image strPts=vtk.vtkStructuredPoints() strPts.SetDimensions(imageWidth,imageLength,1) strPts.SetOrigin(0.,0.,0.) strPts.SetExtent(0,imageWidth-1,0,imageLength-1,0,0) strPts.SetNumberOfScalarComponents(1) strPts.SetScalarTypeToFloat() strPts.AllocateScalars() strPts.GetPointData().SetScalars(data_array) strPts.Update() #print the image to an output file writer=vtk.vtkStructuredPointsWriter() writer.SetFileName(filename) writer.SetInput(strPts) writer.Update() writer.Write()
def _create_structured_points_direct(x, y, z=None): """Creates a vtkStructuredPoints object given input data in the form of Numeric arrays. Input Arguments: x -- Array of x-coordinates. These should be regularly spaced. y -- Array of y-coordinates. These should be regularly spaced. z -- Array of z values for the x, y values given. The values should be computed such that the z values are computed as x varies fastest and y next. If z is None then no scalars are associated with the structured points. Only the structured points data set is created. """ nx = len(x) ny = len(y) if z: nz = Numeric.size(z) assert nx*ny == nz, "len(x)*len(y) != len(z)"\ "You passed nx=%d, ny=%d, nz=%d"%(nx, ny, nz) xmin, ymin = x[0], y[0] dx, dy= (x[1] - x[0]), (y[1] - y[0]) sp = vtk.vtkStructuredPoints() sp.SetDimensions(nx, ny, 1) sp.SetOrigin(xmin, ymin, 0) sp.SetSpacing(dx, dy, 1) if z: sc = array2vtk(z) sp.GetPointData().SetScalars(sc) return sp
def StructuredPointProbe(self, nx, ny, nz, bounding_box=None): """ Probe the unstructured grid dataset using a structured points dataset. """ probe = vtk.vtkProbeFilter () probe.SetSource (self.ugrid) sgrid = vtk.vtkStructuredPoints() bbox = [0.0,0.0, 0.0,0.0, 0.0,0.0] if bounding_box==None: bbox = self.ugrid.GetBounds() else: bbox = bounding_box sgrid.SetOrigin([bbox[0], bbox[2], bbox[4]]) sgrid.SetDimensions(nx, ny, nz) spacing = [0.0, 0.0, 0.0] if nx>1: spacing[0] = (bbox[1]-bbox[0])/(nx-1.0) if ny>1: spacing[1] = (bbox[3]-bbox[2])/(ny-1.0) if nz>1: spacing[2] = (bbox[5]-bbox[4])/(nz-1.0) sgrid.SetSpacing(spacing) probe.SetInput (sgrid) probe.Update () return probe.GetOutput()
def writePicture(filename, image): #image reshape imageLength = image.shape[0] imageWidth = image.shape[1] image = image.reshape(imageLength * imageWidth, 1) #create a data array to stock these values data_array = vtk.vtkFloatArray() data_array.SetNumberOfValues(len(image)) for i in range(0, len(image)): data_array.SetValue(i, image[i][0]) #create an ImageData called vtkStructuredPoints which stocks the pixel/voxel value of the image strPts = vtk.vtkStructuredPoints() strPts.SetDimensions(imageWidth, imageLength, 1) strPts.SetOrigin(0., 0., 0.) strPts.SetExtent(0, imageWidth - 1, 0, imageLength - 1, 0, 0) strPts.SetNumberOfScalarComponents(1) strPts.SetScalarTypeToFloat() strPts.AllocateScalars() strPts.GetPointData().SetScalars(data_array) strPts.Update() #print the image to an output file writer = vtk.vtkStructuredPointsWriter() writer.SetFileName(filename) writer.SetInput(strPts) writer.Update() writer.Write()
def main(): colors = vtk.vtkNamedColors() renderer = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(renderer) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) vol = vtk.vtkStructuredPoints() vol.SetDimensions(26, 26, 26) vol.SetOrigin(-0.5, -0.5, -0.5) sp = 1.0 / 25.0 vol.SetSpacing(sp, sp, sp) scalars = vtk.vtkDoubleArray() scalars.SetNumberOfComponents(1) scalars.SetNumberOfTuples(26 * 26 * 26) for k in range(0, 26): z = -0.5 + k * sp kOffset = k * 26 * 26 for j in range(0, 26): y = -0.5 + j * sp jOffset = j * 26 for i in range(0, 26): x = -0.5 + i * sp s = x * x + y * y + z * z - (0.4 * 0.4) offset = i + jOffset + kOffset scalars.InsertTuple1(offset, s) vol.GetPointData().SetScalars(scalars) contour = vtk.vtkContourFilter() contour.SetInputData(vol) contour.SetValue(0, 0.0) volMapper = vtk.vtkPolyDataMapper() volMapper.SetInputConnection(contour.GetOutputPort()) volMapper.ScalarVisibilityOff() volActor = vtk.vtkActor() volActor.SetMapper(volMapper) volActor.GetProperty().EdgeVisibilityOn() volActor.GetProperty().SetColor(colors.GetColor3d('Salmon')) renderer.AddActor(volActor) renderer.SetBackground(colors.GetColor3d('SlateGray')) renWin.SetSize(512, 512) renWin.SetWindowName('Vol') # Interact with the data. renWin.Render() iren.Start()
def VTKNumpytoSP(img_): img = img_.T H, W = img.shape sp = vtk.vtkStructuredPoints() sp.SetDimensions(H, W, 1) sp.AllocateScalars(10, 1) for i in range(H): for j in range(W): v = img[i, j] sp.SetScalarComponentFromFloat(i, j, 0, 0, v) return sp
def initialize (self): debug ("In StructuredPointsProbe::__init__ ()") self.spacing_var = Tkinter.StringVar() self.dimension_var = Tkinter.StringVar() self.conv_scalar_var = Tkinter.IntVar() self.conv_scalar_var.set(1) self.p_data = vtk.vtkStructuredPoints() self.p_data_gui = None self.init_p_data() self.fil = vtk.vtkProbeFilter () self.fil.SetSource (self.prev_fil.GetOutput ()) self.fil.SetInput(self.p_data) self.fil.Update () self.set_scaled_scalars() self.pipe_objs = self.fil
def simple_test(): """A simple example of how you can access the methods of a VTK object created from Python in C++ using weave.inline. """ a = vtk.vtkStructuredPoints() a.SetOrigin(1.0, 1.0, 1.0) print("sys.getrefcount(a) = ", sys.getrefcount(a)) code = r""" printf("a->ClassName() == %s\n", a->GetClassName()); printf("a->GetReferenceCount() == %d\n", a->GetReferenceCount()); double *origin = a->GetOrigin(); printf("Origin = %f, %f, %f\n", origin[0], origin[1], origin[2]); """ weave.inline(code, ['a'], include_dirs=inc_dirs, library_dirs=lib_dirs) print("sys.getrefcount(a) = ", sys.getrefcount(a))
def __init__(self, elements, cell): # Make sure element argument is a valid array if not isinstance(elements, np.ndarray): elements = np.array(elements) assert elements.dtype == int and elements.shape == (3,) self.elements = elements vtkBaseGrid.__init__(self, np.prod(self.elements), cell) # Create a VTK grid of structured points self.vtk_spts = vtkStructuredPoints() self.vtk_spts.SetWholeBoundingBox(self.cell.get_bounding_box()) self.vtk_spts.SetDimensions(self.elements) self.vtk_spts.SetSpacing(self.get_grid_spacing()) # Extract the VTK point data set self.set_point_data(self.vtk_spts.GetPointData())
def write(matrix, filename): dims = matrix.shape flat = matrix.ravel(order='F') vtkarray = numpy_support.numpy_to_vtk(flat, deep=True, array_type=vtk.VTK_FLOAT) vtkarray.SetName("curvatures") points = vtk.vtkStructuredPoints() points.SetDimensions(dims) points.GetPointData().AddArray(vtkarray) writer = vtk.vtkStructuredPointsWriter() writer.SetFileTypeToBinary() writer.SetFileName(filename) writer.SetInputData(points) writer.Write()
def __init__(self, elements, cell, origin=None): # Make sure element argument is a valid array if not isinstance(elements, np.ndarray): elements = np.array(elements) assert elements.dtype == int and elements.shape == (3, ) self.elements = elements vtkBaseGrid.__init__(self, np.prod(self.elements), cell) # Create a VTK grid of structured points self.vtk_spts = vtkStructuredPoints() self.vtk_spts.SetWholeBoundingBox(self.cell.get_bounding_box()) self.vtk_spts.SetDimensions(self.elements) self.vtk_spts.SetSpacing(self.get_grid_spacing()) if origin is not None: self.vtk_spts.SetOrigin(origin) # Extract the VTK point data set self.set_point_data(self.vtk_spts.GetPointData())
def execute_module(self): # FIXME: if this module ever becomes anything other than an experiment, build # this logic into yet another ProgrammableSource # make sure marker is up to date self._markerSource.GetStructuredPointsOutput().Update() self._maskSource.GetStructuredPointsOutput().Update() tempJ = vtk.vtkStructuredPoints() tempJ.DeepCopy(self._markerSource.GetStructuredPointsOutput()) self._imageErode.SetInput(tempJ) self._diff = vtk.vtkImageMathematics() self._diff.SetOperationToSubtract() self._accum = vtk.vtkImageAccumulate() self._accum.SetInput(self._diff.GetOutput()) # now begin our loop stable = False while not stable: # do erosion, get supremum of erosion and mask I self._sup.GetOutput().Update() # compare this result with tempJ self._diff.SetInput1(tempJ) self._diff.SetInput2(self._sup.GetOutput()) self._accum.Update() print "%f == %f ?" % (self._accum.GetMin()[0], self._accum.GetMax()[0]) if abs(self._accum.GetMin()[0] - self._accum.GetMax()[0]) < 0.0001: stable = True else: # not stable yet... print "Trying again..." tempJ.DeepCopy(self._sup.GetOutput())
def save(self, image): data = dti6to33(self._to_axis_aligned_lps_space(image)) spacing = image.spacing origin = image.origin # Convert numpy -> VTK table vtk_array = vtkFloatArray() vtk_array.SetNumberOfComponents(9) vtk_array.SetVoidArray(data, len(data.ravel()), 1) # Create VTK dataset structured_points = vtkStructuredPoints() structured_points.SetDimensions(data.shape[2], data.shape[1], data.shape[0]) structured_points.SetSpacing(spacing[2], spacing[1], spacing[0]) structured_points.SetOrigin(origin[2], origin[1], origin[0]) structured_points.GetPointData().SetTensors(vtk_array) # Write VTK file writer = vtkStructuredPointsWriter() writer.SetFileName(self._filename) writer.SetFileTypeToBinary() writer.SetInput(structured_points) writer.Update()
from vtk.util.misc import vtkGetDataRoot VTK_DATA_ROOT = vtkGetDataRoot() # Image pipeline image1 = vtk.vtkTIFFReader() image1.SetFileName(VTK_DATA_ROOT + "/Data/beach.tif") # "beach.tif" image contains ORIENTATION tag which is # ORIENTATION_TOPLEFT (row 0 top, col 0 lhs) type. The TIFF # reader parses this tag and sets the internal TIFF image # orientation accordingly. To overwrite this orientation with a vtk # convention of ORIENTATION_BOTLEFT (row 0 bottom, col 0 lhs ), invoke # SetOrientationType method with parameter value of 4. image1.SetOrientationType(4) image1.Update() sp = vtk.vtkStructuredPoints() sp.SetDimensions(image1.GetOutput().GetDimensions()) sp.SetExtent(image1.GetOutput().GetExtent()) sp.SetScalarType( image1.GetOutput().GetScalarType(), image1.GetOutputInformation(0)) sp.SetNumberOfScalarComponents( image1.GetOutput().GetNumberOfScalarComponents(), image1.GetOutputInformation(0)) sp.GetPointData().SetScalars(image1.GetOutput().GetPointData().GetScalars()) luminance = vtk.vtkImageLuminance() luminance.SetInputData(sp) # Let's create a dictionary to test the writers, the key will be the writer # and the value the file name used by the writer. filenames = ["tiff1.tif", "tiff2.tif", "bmp1.bmp", "bmp2.bmp",
x1 = bounds[1] xdm1 = x1 - x0 xd = int(x1 - x0 + 1) y0 = bounds[2] y1 = bounds[3] ydm1 = y1 - y0 yd = int(y1 - y0 + 1) z0 = bounds[4] z1 = bounds[5] zdm1 = z1 - z0 zd = int(z1 - z0 + 1) print "DATA DIMENSIONS ARE: %d %d %d" % (xd, yd, zd) vecinfo = reader.GetOutput().GetPointData().GetVectors() curlData = vtk.vtkStructuredPoints() curlData.SetDimensions(xd, yd, zd) curlData.SetSpacing(1, 1, 1) curlData.SetOrigin(0, 0, 0) divData = vtk.vtkStructuredPoints() divData.SetDimensions(xd, yd, zd) divData.SetSpacing(1, 1, 1) divData.SetOrigin(0, 0, 0) curlmagData = vtk.vtkStructuredPoints() curlmagData.SetDimensions(xd, yd, zd) curlmagData.SetSpacing(1, 1, 1) curlmagData.SetOrigin(0, 0, 0) div = vtk.vtkFloatArray()
def write_vti(filename, atoms, data=None): from vtk import vtkStructuredPoints, vtkDoubleArray, vtkXMLImageDataWriter #if isinstance(fileobj, str): # fileobj = paropen(fileobj, 'w') if isinstance(atoms, list): if len(atoms) > 1: raise ValueError('Can only write one configuration to a VTI file!') atoms = atoms[0] if data is None: raise ValueError('VTK XML Image Data (VTI) format requires data!') data = np.asarray(data) if data.dtype == complex: data = np.abs(data) cell = atoms.get_cell() assert np.all(cell==np.diag(cell.diagonal())), 'Unit cell must be orthogonal' bbox = np.array(list(zip(np.zeros(3),cell.diagonal()))).ravel() # Create a VTK grid of structured points spts = vtkStructuredPoints() spts.SetWholeBoundingBox(bbox) spts.SetDimensions(data.shape) spts.SetSpacing(cell.diagonal() / data.shape) #spts.SetSpacing(paw.gd.h_c * Bohr) #print 'paw.gd.h_c * Bohr=',paw.gd.h_c * Bohr #print 'atoms.cell.diagonal() / data.shape=', cell.diagonal()/data.shape #assert np.all(paw.gd.h_c * Bohr==cell.diagonal()/data.shape) #s = paw.wfs.kpt_u[0].psit_nG[0].copy() #data = paw.get_pseudo_wave_function(band=0, kpt=0, spin=0, pad=False) #spts.point_data.scalars = data.swapaxes(0,2).flatten() #spts.point_data.scalars.name = 'scalars' # Allocate a VTK array of type double and copy data da = vtkDoubleArray() da.SetName('scalars') da.SetNumberOfComponents(1) da.SetNumberOfTuples(np.prod(data.shape)) for i,d in enumerate(data.swapaxes(0,2).flatten()): da.SetTuple1(i,d) # Assign the VTK array as point data of the grid spd = spts.GetPointData() # type(spd) is vtkPointData spd.SetScalars(da) """ from vtk.util.vtkImageImportFromArray import vtkImageImportFromArray iia = vtkImageImportFromArray() #iia.SetArray(Numeric_asarray(data.swapaxes(0,2).flatten())) iia.SetArray(Numeric_asarray(data)) ida = iia.GetOutput() ipd = ida.GetPointData() ipd.SetName('scalars') spd.SetScalars(ipd.GetScalars()) """ # Save the ImageData dataset to a VTK XML file. w = vtkXMLImageDataWriter() if fast: w.SetDataModeToAppend() w.EncodeAppendedDataOff() else: w.SetDataModeToAscii() w.SetFileName(filename) w.SetInput(spts) w.Write()
def vtkrender(d1=None, d2=None): x = (arange(50.0)-25)/2.0 y = (arange(50.0)-25)/2.0 r = sqrt(x[:]**2+y**2) z = 5.0*signal.special.j0(r) # Bessel function of order 0 z1 = reshape(transpose(z), (-1,)) point_data = vtk.vtkPointData(vtk.vtkScalars(z1)) grid = vtk.vtkStructuredPoints((50,50, 1), (-12.5, -12.5, 0), (0.5, 0.5, 1)) data = vtk.VtkData(grid, point_data) data.tofile('/tmp/test.vtk') d1 = d2 = '/tmp/test.vtk' #v2,v1,data1,data2 = inputs() if d1 == None: d1 = "/home/danc/E0058brain.vtk" #d1 = "/home/danc/vtk/data1.vtk" if d2 == None: d2 = "/home/danc/E0058MEG.vtk" #d2='/home/danc/vtk/data2.vtk' #d2 = "/home/danc/mrvtk_0003overlay.vtk" v1 = vtk.vtkStructuredPointsReader() #v1.SetFileName("/home/danc/mrvtk.vtk") v1.SetFileName(d1) v2 = vtk.vtkStructuredPointsReader() #v2.SetFileName("/home/danc/mrvtk_overlay.vtk") v2.SetFileName(d2) v1.SetLookupTableName('/home/danc/colortable.lut') v1.SetReadAllColorScalars v1.Update() v2.Update() global xMax, xMin, yMin, yMax, zMin, zMax, current_widget, slice_number xMin, xMax, yMin, yMax, zMin, zMax = v1.GetOutput().GetWholeExtent() spacing = v1.GetOutput().GetSpacing() sx, sy, sz = spacing origin = v1.GetOutput().GetOrigin() ox, oy, oz = origin # An outline is shown for context. outline = vtk.vtkOutlineFilter() outline.SetInput(v1.GetOutput()) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInput(outline.GetOutput()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(outlineMapper) outlineActor.GetProperty().SetColor(1,1,1) # 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.SetInput(v1.GetOutput()) planeWidgetX.SetPlaneOrientationToXAxes() planeWidgetX.SetSliceIndex(int(round(xMax/2))) planeWidgetX.SetPicker(picker) planeWidgetX.SetKeyPressActivationValue("x") planeWidgetX.GetPlaneProperty().SetDiffuseColor((0,1,1)) #planeWidgetX.GetPlaneProperty().SetColor(0,1,1) #planeWidgetX.GetPlaneProperty().SetSpecularColor(0,1,1) #planeWidgetX.GetPlaneProperty().SetAmbientColor(0,1,1) planeWidgetX.GetPlaneProperty().SetFrontfaceCulling(10) planeWidgetX.GetPlaneProperty().SetRepresentationToWireframe #planeWidgetX.GetColorMap() #print planeWidgetX.GetColorMap() #planeWidgetX.SetHueRange(0.667,0.0) #planeWidgetX.SetLookupTable('/home/danc/colortable.lut') prop1 = planeWidgetX.GetPlaneProperty() prop1.SetDiffuseColor(1, 0, 0) prop1.SetColor(1,0,0) prop1.SetSpecularColor(0, 1, 1) #print planeWidgetX.GetLookupTable() g = planeWidgetX.GetLookupTable() #print g ## arrow = vtk.vtkArrowSource() #### arrow.SetShaftRadius(100) #### arrow.SetShaftResolution(80) #### arrow.SetTipRadius(100) #### arrow.SetTipLength(1000) #### #arrow.SetTipResolution(80) ## arrowMapper = vtk.vtkPolyDataMapper() ## arrowMapper.SetInput(arrow.GetOutput()) ## arrowActor = vtk.vtkActor() ## arrowActor.SetMapper(arrowMapper) ## arrowActor.SetPosition(0, 0, 0) ## arrowActor.GetProperty().SetColor(0, 1, 0) planeWidgetY = vtk.vtkImagePlaneWidget() planeWidgetY.DisplayTextOn() planeWidgetY.SetInput(v1.GetOutput()) planeWidgetY.SetPlaneOrientationToYAxes() planeWidgetY.SetSliceIndex(int(round(yMax/2))) planeWidgetY.SetPicker(picker) planeWidgetY.SetKeyPressActivationValue("y") prop2 = planeWidgetY.GetPlaneProperty() prop2.SetColor(1, 1, 0) planeWidgetY.SetLookupTable(planeWidgetX.GetLookupTable()) planeWidgetY.GetPlaneProperty().SetDiffuseColor(0,1,1) # 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.SetSliceIndex(100) planeWidgetZ.SetSlicePosition(100) planeWidgetZ.DisplayTextOn() planeWidgetZ.SetInput(v1.GetOutput()) planeWidgetZ.SetPlaneOrientationToZAxes() planeWidgetZ.SetSliceIndex(int(round(yMax/2))) planeWidgetZ.SetPicker(picker) planeWidgetZ.SetKeyPressActivationValue("z") prop3 = planeWidgetZ.GetPlaneProperty() prop3.SetColor(0, 0, 1) planeWidgetZ.SetLookupTable(planeWidgetX.GetLookupTable()) planeWidgetZ.GetPlaneProperty().SetDiffuseColor(0,1,1) filelist = [v2,v1]; for i in filelist: coloroniso = vtk.vtkStructuredPointsReader() coloroniso.SetFileName(i.GetFileName()) coloroniso.SetScalarsName("colors") coloroniso.Update() isosurface = vtk.vtkStructuredPointsReader() isosurface.SetFileName(i.GetFileName()) isosurface.SetScalarsName("scalars") isosurface.Update() iso = vtk.vtkContourFilter() iso.SetInput(i.GetOutput()) #iso.SetInput(isosurface.GetOutput()) if i == v1: iso.SetValue(0, 20) else: iso.SetValue(0,10) #iso.SetNumberOfContours(10) probe = vtk.vtkProbeFilter() probe.SetInput(iso.GetOutput()) probe.SetSource(coloroniso.GetOutput()) cast = vtk.vtkCastToConcrete() cast.SetInput(probe.GetOutput()) normals = vtk.vtkPolyDataNormals() #normals.SetMaxRecursionDepth(100) normals.SetInput(cast.GetPolyDataOutput()) normals.SetFeatureAngle(45) ## clut = vtk.vtkLookupTable() ## clut.SetHueRange(0, .67) ## clut.Build() ## clut.SetValueRange(coloroniso.GetOutput().GetScalarRange()) ## normals = vtk.vtkPolyDataNormals() ## normals.SetInput(iso.GetOutput()) ## normals.SetFeatureAngle(45) isoMapper = vtk.vtkPolyDataMapper() isoMapper.SetInput(normals.GetOutput()) isoMapper.ScalarVisibilityOn() #isoMapper.SetColorModeToMapScalars() isoMapper.ColorByArrayComponent(0, 100)#("VelocityMagnitude", 0) isoMapper.SetScalarRange([1, 200]) ## isoMapper.SetLookupTable(clut) isoActor = vtk.vtkActor() isoActor.SetMapper(isoMapper) ## isoActor.GetProperty().SetDiffuseColor([.5,.5,.5]) ## isoActor.GetProperty().SetSpecularColor([1,1,1]) ## isoActor.GetProperty().SetDiffuse(.5) ## isoActor.GetProperty().SetSpecular(.5) ## isoActor.GetProperty().SetSpecularPower(15) ## isoActor.GetProperty().SetOpacity(.6) isoActor.GetProperty().SetDiffuseColor(1, .2, .2) isoActor.GetProperty().SetSpecular(.7) isoActor.GetProperty().SetSpecularPower(20) isoActor.GetProperty().SetOpacity(0.5) if i == v1: print 'under' isoActorUnderlay = isoActor else: print 'over' isoActorOverlay = isoActor # Create the RenderWindow and Renderer ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) # Add the outline actor to the renderer, set the background color and size ren.AddActor(outlineActor) #ren.AddActor(sphereActor) renWin.SetSize(700, 700) ren.SetBackground(0, 0, 0) current_widget = planeWidgetZ mode_widget = planeWidgetZ # Create the GUI # We first create the supporting functions (callbacks) for the GUI # # Align the camera so that it faces the desired widget def AlignCamera(): #global ox, oy, oz, sx, sy, sz, xMax, xMin, yMax, yMin, zMax, \ # zMin, slice_number #global current_widget cx = ox+(0.5*(xMax-xMin))*sx cy = oy+(0.5*(yMax-yMin))*sy cz = oy+(0.5*(zMax-zMin))*sz vx, vy, vz = 0, 0, 0 nx, ny, nz = 0, 0, 0 iaxis = current_widget.GetPlaneOrientation() if iaxis == 0: vz = -1 nx = ox + xMax*sx cx = ox + slice_number*sx elif iaxis == 1: vz = -1 ny = oy+yMax*sy cy = oy+slice_number*sy else: vy = 1 nz = oz+zMax*sz cz = oz+slice_number*sz px = cx+nx*2 py = cy+ny*2 pz = cz+nz*3 camera = ren.GetActiveCamera() camera.SetViewUp(vx, vy, vz) camera.SetFocalPoint(cx, cy, cz) camera.SetPosition(px, py, pz) camera.OrthogonalizeViewUp() ren.ResetCameraClippingRange() renWin.Render() # Capture the display and place in a tiff def CaptureImage(): w2i = vtk.vtkWindowToImageFilter() writer = vtk.vtkTIFFWriter() w2i.SetInput(renWin) w2i.Update() writer.SetInput(w2i.GetOutput()) writer.SetFileName("/home/danc/image.tif") renWin.Render() writer.Write() # Align the widget back into orthonormal position, # set the slider to reflect the widget's position, # call AlignCamera to set the camera facing the widget def AlignXaxis(): global xMax, xMin, current_widget, slice_number po = planeWidgetX.GetPlaneOrientation() if po == 3: planeWidgetX.SetPlaneOrientationToXAxes() slice_number = (xMax-xMin)/2 planeWidgetX.SetSliceIndex(slice_number) else: slice_number = planeWidgetX.GetSliceIndex() current_widget = planeWidgetX slice.config(from_=xMin, to=xMax) slice.set(slice_number) AlignCamera() def AlignYaxis(): global yMin, yMax, current_widget, slice_number po = planeWidgetY.GetPlaneOrientation() if po == 3: planeWidgetY.SetPlaneOrientationToYAxes() slice_number = (yMax-yMin)/2 planeWidgetY.SetSliceIndex(slice_number) else: slice_number = planeWidgetY.GetSliceIndex() current_widget = planeWidgetY slice.config(from_=yMin, to=yMax) slice.set(slice_number) AlignCamera() def AlignZaxis(): global yMin, yMax, current_widget, slice_number po = planeWidgetZ.GetPlaneOrientation() if po == 3: planeWidgetZ.SetPlaneOrientationToZAxes() slice_number = (zMax-zMin)/2 planeWidgetZ.SetSliceIndex(slice_number) else: slice_number = planeWidgetZ.GetSliceIndex() current_widget = planeWidgetZ slice.config(from_=zMin, to=zMax) slice.set(slice_number) AlignCamera() ##################def flag(sw): def underlay(): print 'under' global overunderstatus overunderstatus = 'under' isoActor = isoActorUnderlay u_button.config(relief='sunken') o_button.config(relief='raised') six=planeWidgetX.GetSliceIndex() siy=planeWidgetY.GetSliceIndex() siz=planeWidgetZ.GetSliceIndex() data = v1 planeWidgetX.SetInput(data.GetOutput()) planeWidgetY.SetInput(data.GetOutput()) planeWidgetZ.SetInput(data.GetOutput()) planeWidgetX.SetSliceIndex(six) planeWidgetY.SetSliceIndex(siy) planeWidgetZ.SetSliceIndex(siz) renWin.Render() def overlay(): print 'over' global overunderstatus overunderstatus = 'over' isoActor = isoActorOverlay o_button.config(relief='sunken') u_button.config(relief='raised') six=planeWidgetX.GetSliceIndex() siy=planeWidgetY.GetSliceIndex() siz=planeWidgetZ.GetSliceIndex() data = v2 planeWidgetX.SetInput(data.GetOutput()) planeWidgetY.SetInput(data.GetOutput()) planeWidgetZ.SetInput(data.GetOutput()) planeWidgetX.SetSliceIndex(six) planeWidgetY.SetSliceIndex(siy) planeWidgetZ.SetSliceIndex(siz) renWin.Render() def render3d(): print '3d rend' global buttonpos try: if overunderstatus == 'under': isoActor = isoActorUnderlay else: isoActor = isoActorOverlay except NameError: isoActor = isoActorUnderlay try: buttonpos print buttonpos except NameError: buttonpos = 0 print buttonpos r_button.config(relief='sunken') ren.AddActor(isoActor) renWin.Render() else: if buttonpos == 0: buttonpos = 1 r_button.config(relief='raised') ren.RemoveActor(isoActor) ren.RemoveActor(isoActorUnderlay) ren.RemoveActor(isoActorOverlay) renWin.Render() else: buttonpos = 0 r_button.config(relief='sunken') print o_button ren.AddActor(isoActor) renWin.Render() return buttonpos # Set the widget's reslice interpolation mode # to the corresponding popup menu choice def SetInterpolation(): global mode_widget, mode if mode.get() == 0: mode_widget.TextureInterpolateOff() else: mode_widget.TextureInterpolateOn() mode_widget.SetResliceInterpolate(mode.get()) renWin.Render() # Share the popup menu among buttons, keeping track of associated # widget's interpolation mode def buttonEvent(event, arg=None): global mode, mode_widget, popm if arg == 0: mode_widget = planeWidgetX elif arg == 1: mode_widget = planeWidgetY elif arg == 2: mode_widget = planeWidgetZ else: return mode.set(mode_widget.GetResliceInterpolate()) popm.entryconfigure(arg, variable=mode) popm.post(event.x + event.x_root, event.y + event.y_root) def SetSlice(sl): global current_widget current_widget.SetSliceIndex(int(sl)) ren.ResetCameraClippingRange() renWin.Render() ### # Now actually create the GUI root = Tkinter.Tk() root.withdraw() top = Tkinter.Toplevel(root) # Define a quit method that exits cleanly. def quit(obj=root): print obj obj.quit() obj.destroy() #vtkrender.destroy() # Popup menu popm = Tkinter.Menu(top, tearoff=0) mode = Tkinter.IntVar() mode.set(1) popm.add_radiobutton(label="nearest", variable=mode, value=0, command=SetInterpolation) popm.add_radiobutton(label="linear", variable=mode, value=1, command=SetInterpolation) popm.add_radiobutton(label="cubic", variable=mode, value=2, command=SetInterpolation) display_frame = Tkinter.Frame(top) display_frame.pack(side="top", anchor="n", fill="both", expand="false") # Buttons ctrl_buttons = Tkinter.Frame(top) ctrl_buttons.pack(side="top", anchor="n", fill="both", expand="false") quit_button = Tkinter.Button(ctrl_buttons, text="Quit", command=quit) capture_button = Tkinter.Button(ctrl_buttons, text="Tif", command=CaptureImage) quit_button.config(background='#C0C0C0') x_button = Tkinter.Button(ctrl_buttons, text="x", command=AlignXaxis) y_button = Tkinter.Button(ctrl_buttons, text="y", command=AlignYaxis) z_button = Tkinter.Button(ctrl_buttons, text="z", command=AlignZaxis) u_button = Tkinter.Button(ctrl_buttons, text="underlay", command=underlay) o_button = Tkinter.Button(ctrl_buttons, text="overlay", command=overlay) r_button = Tkinter.Button(ctrl_buttons, text="3d render", command=render3d) o_button.config(background='#FFFFFF') u_button.config(relief='sunken') x_button.bind("<Button-3>", lambda e: buttonEvent(e, 0)) y_button.bind("<Button-3>", lambda e: buttonEvent(e, 1)) z_button.bind("<Button-3>", lambda e: buttonEvent(e, 2)) u_button.bind("<Button-3>", lambda e: buttonEvent(e, 3)) o_button.bind("<Button-3>", lambda e: buttonEvent(e, 4)) r_button.bind("<Button-3>", lambda e: buttonEvent(e, 5)) for i in (quit_button, capture_button, x_button, y_button, z_button, u_button, o_button, r_button): i.pack(side="left", expand="true", fill="both") # Create the render widget renderer_frame = Tkinter.Frame(display_frame) renderer_frame.pack(padx=3, pady=3,side="left", anchor="n", fill="both", expand="false") render_widget = vtkTkRenderWindowInteractor(renderer_frame, rw=renWin, width=600, height=600) for i in (render_widget, display_frame): i.pack(side="top", anchor="n",fill="both", expand="false") # Add a slice scale to browse the current slice stack slice_number = Tkinter.IntVar() slice_number.set(current_widget.GetSliceIndex()) slice = Tkinter.Scale(top, from_=zMin, to=zMax, orient="horizontal", command=SetSlice,variable=slice_number, label="Slice") slice.pack(fill="x", expand="false") # Done with the GUI. ### # Set the interactor for the widgets iact = render_widget.GetRenderWindow().GetInteractor() planeWidgetX.SetInteractor(iact) planeWidgetX.On() planeWidgetY.SetInteractor(iact) planeWidgetY.On() planeWidgetZ.SetInteractor(iact) planeWidgetZ.On() # Create an initial interesting view cam1 = ren.GetActiveCamera() cam1.Elevation(210) cam1.SetViewUp(1, -1, 1) cam1.Azimuth(-145) ren.ResetCameraClippingRange() # Render it render_widget.Render() iact.Initialize() renWin.Render() iact.Start() # Start Tkinter event loop root.mainloop()
def write_vti(filename, atoms, data=None): from vtk import vtkStructuredPoints, vtkDoubleArray, vtkXMLImageDataWriter # if isinstance(fileobj, str): # fileobj = paropen(fileobj, 'w') if isinstance(atoms, list): if len(atoms) > 1: raise ValueError('Can only write one configuration to a VTI file!') atoms = atoms[0] if data is None: raise ValueError('VTK XML Image Data (VTI) format requires data!') data = np.asarray(data) if data.dtype == complex: data = np.abs(data) cell = atoms.get_cell() if not np.all(cell == np.diag(np.diag(cell))): raise ValueError('Unit cell must be orthogonal') bbox = np.array(list(zip(np.zeros(3), cell.diagonal()))).ravel() # Create a VTK grid of structured points spts = vtkStructuredPoints() spts.SetWholeBoundingBox(bbox) spts.SetDimensions(data.shape) spts.SetSpacing(cell.diagonal() / data.shape) # spts.SetSpacing(paw.gd.h_c * Bohr) # print('paw.gd.h_c * Bohr=',paw.gd.h_c * Bohr) # print('atoms.cell.diagonal() / data.shape=', cell.diagonal()/data.shape) # assert np.all(paw.gd.h_c * Bohr==cell.diagonal()/data.shape) # s = paw.wfs.kpt_u[0].psit_nG[0].copy() # data = paw.get_pseudo_wave_function(band=0, kpt=0, spin=0, pad=False) # spts.point_data.scalars = data.swapaxes(0,2).flatten() # spts.point_data.scalars.name = 'scalars' # Allocate a VTK array of type double and copy data da = vtkDoubleArray() da.SetName('scalars') da.SetNumberOfComponents(1) da.SetNumberOfTuples(np.prod(data.shape)) for i, d in enumerate(data.swapaxes(0, 2).flatten()): da.SetTuple1(i, d) # Assign the VTK array as point data of the grid spd = spts.GetPointData() # type(spd) is vtkPointData spd.SetScalars(da) """ from vtk.util.vtkImageImportFromArray import vtkImageImportFromArray iia = vtkImageImportFromArray() #iia.SetArray(Numeric_asarray(data.swapaxes(0,2).flatten())) iia.SetArray(Numeric_asarray(data)) ida = iia.GetOutput() ipd = ida.GetPointData() ipd.SetName('scalars') spd.SetScalars(ipd.GetScalars()) """ # Save the ImageData dataset to a VTK XML file. w = vtkXMLImageDataWriter() if fast: w.SetDataModeToAppend() w.EncodeAppendedDataOff() else: w.SetDataModeToAscii() w.SetFileName(filename) w.SetInput(spts) w.Write()
import numpy as np import vtk from vtk.util import numpy_support ### STRUCTURED_POINTS - SCALARS ### reader = vtk.vtkStructuredPointsReader() reader.SetFileName("fMag.0001.vtk") reader.Update() vtk_data = reader.GetOutput() scalar_data = numpy_support.vtk_to_numpy(vtk_data.GetPointData().GetScalars()) mesh_shape = vtk_data.GetDimensions() origin = vtk_data.GetOrigin() spacing = vtk_data.GetSpacing() scalar_data_vtk = numpy_support.numpy_to_vtk(scalar_data) scalar_data_vtk.SetName('fMag') vtk_obj = vtk.vtkStructuredPoints() vtk_obj.SetDimensions(mesh_shape) vtk_obj.SetOrigin(origin) vtk_obj.SetSpacing(spacing) vtk_obj.GetPointData().SetScalars(scalar_data_vtk) writer = vtk.vtkGenericDataObjectWriter() writer.SetFileName("test_out.vtk") writer.SetInputDataObject(vtk_obj) writer.Update() writer.Write() # returns 1 on success, 0 on failure ### STRUCTURED_POINTS - VECTORS ### reader = vtk.vtkStructuredPointsReader() reader.SetFileName("u.0001.vtk") reader.Update() vtk_data = reader.GetOutput()
import vtk import sys infile = sys.argv[1] dimsin = sys.argv[2] inbits = infile.split(".") outputfile = inbits[0] + ".bin" sgr = vtk.vtkStructuredGridReader() sgr.SetFileName(infile) sgr.Update() p_data = vtk.vtkStructuredPoints() fil = vtk.vtkProbeFilter() fil.SetSource(sgr.GetOutput()) fil.SetInput(p_data) fil.Update() pd = p_data out = sgr.GetOutput() b = out.GetBounds() pd.SetOrigin(b[0], b[2], b[4]) l = [b[1] - b[0], b[3] - b[2], b[5] - b[4]] tot_len = float(l[0] + l[1] + l[2]) npnt = pow(out.GetNumberOfPoints(), 1. / 3.) + 0.5 fac = 3.0 * npnt / tot_len dims = eval(dimsin) pd.SetExtent(0, dims[0] - 1, 0, dims[1] - 1, 0, dims[2] - 1) pd.SetUpdateExtent(0, dims[0] - 1, 0, dims[1] - 1, 0, dims[2] - 1) pd.SetWholeExtent(0, dims[0] - 1, 0, dims[1] - 1, 0, dims[2] - 1)
#!/usr/bin/env python # -*- coding: utf-8 -*- # Example of "structured points" dataset # vtkStructuredPoints is a child class of vtkImageData import vtk dx = 0.2 grid = vtk.vtkStructuredPoints() #grid = vtk.vtkImageData() grid.SetOrigin(0.1, 0.1, 0.1) # default values grid.SetSpacing(dx, dx, dx) grid.SetDimensions(5, 8, 10) # number of points in each direction array = vtk.vtkDoubleArray() array.SetNumberOfComponents(1) # this is 3 for a vector array.SetNumberOfTuples(grid.GetNumberOfPoints()) for i in range(grid.GetNumberOfPoints()): array.SetValue(i, i/2.0) grid.GetPointData().AddArray(array) array.SetName("my_data1") # write structured points to disk... writer = vtk.vtkStructuredPointsWriter() writer.SetInputData(grid) writer.SetFileName("points.vtk") writer.Write() writer = vtk.vtkXMLImageDataWriter()
#!/usr/bin/env python # -*- coding: utf-8 -*- # Example of "structured points" dataset # vtkStructuredPoints is a child class of vtkImageData import vtk dx = 0.2 grid = vtk.vtkStructuredPoints() #grid = vtk.vtkImageData() grid.SetOrigin(0, 0, 0) # default values grid.SetSpacing(dx, dx, dx) grid.SetDimensions(5, 8, 10) # number of points in each direction array = vtk.vtkDoubleArray() array.SetNumberOfComponents(1) # this is 3 for a vector array.SetNumberOfTuples(grid.GetNumberOfPoints()) for i in range(grid.GetNumberOfPoints()): array.SetValue(i, i) grid.GetPointData().AddArray(array) array.SetName("my_data1") # write structured points to disk... writer = vtk.vtkStructuredPointsWriter() writer.SetInputData(grid) writer.SetFileName("points.vtk") writer.Write() # display grid... (to be finished)
def array2vtk(self, array, final_filename, path, origin=[0, 0, 0], spacing=[1, 1, 1]): """ Convert array into .vtk file - Params: inherited class parameters (see description at beginning of the class) array: array to be converted into .vtk file flag: parameter specifying if what is saved is a contour image or a binary mask 'contour': contour is saved 'binary': binary mask is saved origin: origin of coordinate system, by default (0,0,0) spacing: spacing of coordinate system, by default (1,1,1) """ vtk_writer = vtk.vtkStructuredPointsWriter() # Check if destination folder exists #print('Checking if destination folder exists\n') isdir = os.path.isdir(path) if not isdir: os.makedirs(path) print('Non-existing destination path. Created\n') # Check if files already exist in destination folder overwrite = 'y' exist = final_filename in os.listdir(path) if exist: overwrite = input( "File is already in folder. Do you want to overwrite? [y/n]") if overwrite == 'y' or overwrite == 'Y': vtk_writer.SetFileName(path + final_filename) else: print('\nOperation aborted\n') vtk_im = vtk.vtkStructuredPoints() vtk_im.SetDimensions((array.shape[1], array.shape[0], array.shape[2])) vtk_im.SetOrigin(origin) vtk_im.SetSpacing(spacing) pdata = vtk_im.GetPointData() vtk_array = numpy_to_vtk(array.swapaxes(0, 1).ravel(order='F'), deep=1) pdata.SetScalars(vtk_array) #vtk_writer.SetFileType(VTK_BINARY) vtk_writer.SetInputData(vtk_im) vtk_writer.Update()
def main(): colors = vtk.vtkNamedColors() Pr = 10.0 # The Lorenz parameters b = 2.667 r = 28.0 # x = 0.0 # y = 0.0 # z = 0.0 # starting (and current) x, y, z h = 0.01 # integration step size resolution = 200 # slice resolution iterations = 10000000 # number of iterations xmin = -30.0 # x, y, z range for voxels xmax = 30.0 ymin = -30.0 ymax = 30.0 zmin = -10.0 zmax = 60.0 # Take a stab at an integration step size. xIncr = resolution / (xmax - xmin) yIncr = resolution / (ymax - ymin) zIncr = resolution / (zmax - zmin) print('The Lorenz Attractor\n') print(' Pr =', Pr) print(' b =', b) print(' r =', r) print(' integration step size =', h) print(' slice resolution =', resolution) print(' # of iterations =', iter) print(' specified range:') print(' x: {:f}, {:f}'.format(xmin, xmax)) print(' y: {:f}, {:f}'.format(ymin, ymax)) print(' z: {:f}, {:f}'.format(zmin, zmax)) randomSequence = vtk.vtkMinimalStandardRandomSequence() randomSequence.SetSeed(8775070) x = randomSequence.GetRangeValue(xmin, xmax) randomSequence.Next() y = randomSequence.GetRangeValue(ymin, ymax) randomSequence.Next() z = randomSequence.GetRangeValue(zmin, zmax) randomSequence.Next() print(' starting at {:f}, {:f}, {:f}'.format(x, y, z)) # allocate memory for the slices sliceSize = resolution * resolution numPts = sliceSize * resolution scalars = vtk.vtkShortArray() for i in range(0, numPts): scalars.InsertTuple1(i, 0) for j in range(0, iterations): # Integrate to the next time step. xx = x + h * Pr * (y - x) yy = y + h * (x * (r - z) - y) zz = z + h * (x * y - (b * z)) x = xx y = yy z = zz # Calculate the voxel index. if xmax > x > xmin and ymax > y > ymin and zmax > z > zmin: xxx = int(float(xx - xmin) * xIncr) yyy = int(float(yy - ymin) * yIncr) zzz = int(float(zz - zmin) * zIncr) index = xxx + yyy * resolution + zzz * sliceSize scalars.SetTuple1(index, scalars.GetTuple1(index) + 1) volume = vtk.vtkStructuredPoints() volume.GetPointData().SetScalars(scalars) volume.SetDimensions(resolution, resolution, resolution) volume.SetOrigin(xmin, ymin, zmin) volume.SetSpacing((xmax - xmin) / resolution, (ymax - ymin) / resolution, (zmax - zmin) / resolution) print(' contouring...') # Do the graphics dance. renderer = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(renderer) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Create iso-surface contour = vtk.vtkContourFilter() contour.SetInputData(volume) contour.SetValue(0, 50) # Create mapper. mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(contour.GetOutputPort()) mapper.ScalarVisibilityOff() # Create actor. actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetColor(colors.GetColor3d('DodgerBlue')) renderer.AddActor(actor) renderer.SetBackground(colors.GetColor3d('PaleGoldenrod')) renWin.SetSize(640, 480) # interact with data renWin.Render() renWin.SetWindowName('Lorenz') camera = renderer.GetActiveCamera() camera.SetPosition(-67.645167, -25.714343, 63.483516) camera.SetFocalPoint(3.224902, -4.398594, 29.552112) camera.SetViewUp(-0.232264, 0.965078, 0.121151) camera.SetDistance(81.414176) camera.SetClippingRange(18.428905, 160.896031) iren.Start()
def main(): colors = vtk.vtkNamedColors() Pr = 10.0 # The Lorenz parameters b = 2.667 r = 28.0 # x = 0.0 # y = 0.0 # z = 0.0 # starting (and current) x, y, z h = 0.01 # integration step size resolution = 200 # slice resolution iterations = 10000000 # number of iterations xmin = -30.0 # x, y, z range for voxels xmax = 30.0 ymin = -30.0 ymax = 30.0 zmin = -10.0 zmax = 60.0 # Take a stab at an integration step size. xIncr = resolution / (xmax - xmin) yIncr = resolution / (ymax - ymin) zIncr = resolution / (zmax - zmin) print("The Lorenz Attractor\n") print(" Pr =", Pr) print(" b =", b) print(" r =", r) print(" integration step size =", h) print(" slice resolution =", resolution) print(" # of iterations =", iter) print(" specified range:") print(" x: {:f}, {:f}".format(xmin, xmax)) print(" y: {:f}, {:f}".format(ymin, ymax)) print(" z: {:f}, {:f}".format(zmin, zmax)) x = vtk.vtkMath.Random(xmin, xmax) y = vtk.vtkMath.Random(ymin, ymax) z = vtk.vtkMath.Random(zmin, zmax) print(" starting at {:f}, {:f}, {:f}".format(x, y, z)) # allocate memory for the slices sliceSize = resolution * resolution numPts = sliceSize * resolution scalars = vtk.vtkShortArray() for i in range(0, numPts): scalars.InsertTuple1(i, 0) for j in range(0, iterations): # Integrate to the next time step. xx = x + h * Pr * (y - x) yy = y + h * (x * (r - z) - y) zz = z + h * (x * y - (b * z)) x = xx y = yy z = zz # Calculate the voxel index. if xmax > x > xmin and ymax > y > ymin and zmax > z > zmin: xxx = int(float(xx - xmin) * xIncr) yyy = int(float(yy - ymin) * yIncr) zzz = int(float(zz - zmin) * zIncr) index = xxx + yyy * resolution + zzz * sliceSize scalars.SetTuple1(index, scalars.GetTuple1(index) + 1) volume = vtk.vtkStructuredPoints() volume.GetPointData().SetScalars(scalars) volume.SetDimensions(resolution, resolution, resolution) volume.SetOrigin(xmin, ymin, zmin) volume.SetSpacing((xmax - xmin) / resolution, (ymax - ymin) / resolution, (zmax - zmin) / resolution) print(" contouring...") # Do the graphics dance. renderer = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(renderer) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Create iso-surface contour = vtk.vtkContourFilter() contour.SetInputData(volume) contour.SetValue(0, 50) # Create mapper. mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(contour.GetOutputPort()) mapper.ScalarVisibilityOff() # Create actor. actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetColor(colors.GetColor3d("PaleTurquoise")) renderer.AddActor(actor) renderer.SetBackground(colors.GetColor3d("PeachPuff")) renWin.SetSize(640, 480) # interact with data renWin.Render() iren.Start()
pArray = map(ord,voxels.tostring()) #unpack pDims = shape(voxels) if debug: print pDims # need a reshuffle of indices ?? -- doesn't matter if cube (same xyz dims) pDims = [pDims[2],pDims[1],pDims[0]] scale = mmPerVox iSizes = [pDims[0]+2, pDims[1]+2, pDims[2]+2] nTotalValues = iSizes[0] * iSizes[1] * iSizes[2] pClassValues = vtk.vtkUnsignedCharArray() pClassValues.SetNumberOfValues(nTotalValues) pClassData = vtk.vtkStructuredPoints() pClassData.SetDimensions(iSizes[0], iSizes[1], iSizes[2]) pClassData.SetOrigin(-scale[0], -scale[1], -scale[2]) #??? pClassData.SetOrigin(-1, -1, -1) #??? pClassData.SetSpacing(scale[0], scale[1], scale[2]) for iSrcZ in range(pDims[2]): for iSrcY in range(pDims[1]): iSrcIndex = iSrcZ * pDims[1] * pDims[0] + iSrcY * pDims[0] iDstIndex = (iSrcZ+1) * iSizes[1] * iSizes[0] + (iSrcY+1) * iSizes[0] + 1 for iSrcX in range(pDims[0]):
def array2vtk(self, array, filename, path, origin=[0, 0, 0], spacing=[1, 1, 1]): """ Convert array into .vtk file - Params: inherited class parameters (see description at beginning of the class) array: array to be converted into .vtk file (array) filename: filename with which to save array as VTK file (str) path: path where to save VTK file (str) origin: origin of coordinate system, by default [0,0,0] (list of 3) spacing: spacing of coordinate system, by default [1,1,1] (list of 3) """ vtk_writer = vtk.vtkStructuredPointsWriter() # Check if destination folder exists #print('Checking if destination folder exists\n') isdir = os.path.isdir(path) if not isdir: os.makedirs(path) print('Non-existing destination path. Created\n') # Check if files already exist in destination folder exist = filename in os.listdir(path) overwrite = 'y' if exist: overwrite = input( "File is already in folder. Do you want to overwrite? [y/n]\n") if overwrite == 'y' or overwrite == 'Y': vtk_writer.SetFileName(path + filename) vtk_im = vtk.vtkStructuredPoints() vtk_im.SetDimensions( (array.shape[1], array.shape[0], array.shape[2])) vtk_im.SetOrigin(origin) vtk_im.SetSpacing(spacing) pdata = vtk_im.GetPointData() vtk_array = numpy_to_vtk(array.swapaxes(0, 1).ravel(order='F'), deep=1) pdata.SetScalars(vtk_array) vtk_writer.SetFileType(vtk.VTK_BINARY) vtk_writer.SetInputData(vtk_im) vtk_writer.Update() #print('VTK file saved successfully!\n') else: print('\nOperation aborted\n')
def init_concentration_field_actors(self, actor_specs, drawing_params=None): """ initializes concentration field actors :param actor_specs: :param drawing_params: :return: None """ actors_dict = actor_specs.actors_dict field_dim = self.currentDrawingParameters.bsd.fieldDim # dim_order = self.dimOrder(self.currentDrawingParameters.plane) # dim = self.planeMapper(dim_order, (field_dim.x, field_dim.y, field_dim.z))# [fieldDim.x, fieldDim.y, fieldDim.z] dim = [field_dim.x, field_dim.y, field_dim.z] field_name = drawing_params.fieldName scene_metadata = drawing_params.screenshot_data.metadata mdata = MetadataHandler(mdata=scene_metadata) try: isovalues = mdata.get('ScalarIsoValues', default=[]) isovalues = list([float(x) for x in isovalues]) except: print('Could not process isovalue list ') isovalues = [] try: numIsos = mdata.get('NumberOfContourLines', default=3) except: print('could not process NumberOfContourLines setting') numIsos = 0 hex_flag = False lattice_type_str = self.get_lattice_type_str() if lattice_type_str.lower() == 'hexagonal': hex_flag = True types_invisible = PlayerPython.vectorint() for type_label in drawing_params.screenshot_data.invisible_types: types_invisible.append(int(type_label)) # self.isovalStr = Configuration.getSetting("ScalarIsoValues", field_name) # if type(self.isovalStr) == QVariant: # self.isovalStr = str(self.isovalStr.toString()) # else: # self.isovalStr = str(self.isovalStr) con_array = vtk.vtkDoubleArray() con_array.SetName("concentration") con_array_int_addr = extract_address_int_from_vtk_object( vtkObj=con_array) cell_type_con = vtk.vtkIntArray() cell_type_con.SetName("concelltype") cell_type_con_int_addr = extract_address_int_from_vtk_object( vtkObj=cell_type_con) field_type = drawing_params.fieldType.lower() if field_type == 'confield': fill_successful = self.field_extractor.fillConFieldData3D( con_array_int_addr, cell_type_con_int_addr, field_name, types_invisible) elif field_type == 'scalarfield': fill_successful = self.field_extractor.fillScalarFieldData3D( con_array_int_addr, cell_type_con_int_addr, field_name, types_invisible) elif field_type == 'scalarfieldcelllevel': fill_successful = self.field_extractor.fillScalarFieldCellLevelData3D( con_array_int_addr, cell_type_con_int_addr, field_name, types_invisible) if not fill_successful: return range_array = con_array.GetRange() min_con = range_array[0] max_con = range_array[1] field_max = range_array[1] # print MODULENAME, ' initScalarFieldDataActors(): min,maxCon=',self.minCon,self.maxCon min_max_dict = self.get_min_max_metadata(scene_metadata=scene_metadata, field_name=field_name) min_range_fixed = min_max_dict['MinRangeFixed'] max_range_fixed = min_max_dict['MaxRangeFixed'] min_range = min_max_dict['MinRange'] max_range = min_max_dict['MaxRange'] # Note! should really avoid doing a getSetting with each step to speed up the rendering; # only update when changed in Prefs if min_range_fixed: min_con = min_range if max_range_fixed: max_con = max_range uGrid = vtk.vtkStructuredPoints() uGrid.SetDimensions( dim[0] + 2, dim[1] + 2, dim[2] + 2 ) # only add 2 if we're filling in an extra boundary (rf. FieldExtractor.cpp) # uGrid.SetDimensions(self.dim[0],self.dim[1],self.dim[2]) # uGrid.GetPointData().SetScalars(self.cellTypeCon) # cellType scalar field uGrid.GetPointData().SetScalars(con_array) # uGrid.GetPointData().AddArray(self.conArray) # additional scalar field voi = vtk.vtkExtractVOI() ## voi.SetInputConnection(uGrid.GetOutputPort()) # voi.SetInput(uGrid.GetOutput()) if VTK_MAJOR_VERSION >= 6: voi.SetInputData(uGrid) else: voi.SetInput(uGrid) voi.SetVOI(1, dim[0] - 1, 1, dim[1] - 1, 1, dim[2] - 1) # crop out the artificial boundary layer that we created isoContour = vtk.vtkContourFilter() # skinExtractorColor = vtk.vtkDiscreteMarchingCubes() # skinExtractorColor = vtk.vtkMarchingCubes() # isoContour.SetInput(uGrid) isoContour.SetInputConnection(voi.GetOutputPort()) isoNum = 0 for isoNum, isoVal in enumerate(isovalues): try: isoContour.SetValue(isoNum, isoVal) except: print( MODULENAME, ' initScalarFieldDataActors(): cannot convert to float: ', self.isovalStr[idx]) if isoNum > 0: isoNum += 1 delIso = (max_con - min_con) / (numIsos + 1 ) # exclude the min,max for isovalues isoVal = min_con + delIso for idx in range(numIsos): isoContour.SetValue(isoNum, isoVal) isoNum += 1 isoVal += delIso # UGLY hack to NOT display anything since our attempt to RemoveActor (below) don't seem to work if isoNum == 0: isoVal = field_max + 1.0 # go just outside valid range isoContour.SetValue(isoNum, isoVal) # concLut = vtk.vtkLookupTable() # concLut.SetTableRange(conc_vol.GetScalarRange()) # concLut.SetTableRange([self.minCon,self.maxCon]) self.scalarLUT.SetTableRange([min_con, max_con]) # concLut.SetNumberOfColors(256) # concLut.Build() # concLut.SetTableValue(39,0,0,0,0) # skinColorMapper = vtk.vtkPolyDataMapper() # skinColorMapper.SetInputConnection(skinNormals.GetOutputPort()) # self.conMapper.SetInputConnection(skinExtractorColor.GetOutputPort()) self.conMapper.SetInputConnection(isoContour.GetOutputPort()) self.conMapper.ScalarVisibilityOn() self.conMapper.SetLookupTable(self.scalarLUT) # # # print " this is conc_vol.GetScalarRange()=",conc_vol.GetScalarRange() # self.conMapper.SetScalarRange(conc_vol.GetScalarRange()) self.conMapper.SetScalarRange([min_con, max_con]) # self.conMapper.SetScalarRange(0,1500) # rwh - what does this do? # self.conMapper.SetScalarModeToUsePointFieldData() # self.conMapper.ColorByArrayComponent("concentration",0) # print MODULENAME,"initScalarFieldDataActors(): Plotting 3D Scalar field" # self.conMapper = vtk.vtkPolyDataMapper() # self.conActor = vtk.vtkActor() concentration_actor = actors_dict['concentration_actor'] concentration_actor.SetMapper(self.conMapper) self.init_min_max_actor( min_max_actor=actors_dict['min_max_text_actor'], range_array=range_array) if hex_flag: concentration_actor.SetScale(self.xScaleHex, self.yScaleHex, self.zScaleHex) if actor_specs.metadata is None: actor_specs.metadata = {'mapper': self.conMapper} else: actor_specs.metadata['mapper'] = self.conMapper if mdata.get('LegendEnable', default=False): self.init_legend_actors(actor_specs=actor_specs, drawing_params=drawing_params)
def isosurface(self, cubeobject, isovalue): me = Mesh.New() me2 = Mesh.New() faces = [] vertices = [] scalars = vtk.vtkFloatArray() for k in range(cubeobject.nz): for j in range(cubeobject.ny): for i in range(cubeobject.nx): scalars.InsertNextValue(cubeobject.data3d[k][j][i]) grid = vtk.vtkStructuredPoints() info = vtk.vtkInformation() grid.SetOrigin(cubeobject.origin[0], cubeobject.origin[1], cubeobject.origin[2]) grid.SetDimensions(cubeobject.nx, cubeobject.ny, cubeobject.nz) grid.SetSpacing(cubeobject.dx, cubeobject.dy, cubeobject.dz) grid.SetNumberOfScalarComponents( cubeobject.nx * cubeobject.ny * cubeobject.nz, info) grid.GetPointData().SetScalars(scalars) Marching = vtk.vtkContourFilter() Marching.SetInputData(grid) Marching.SetValue(0, isovalue) Marching.Update() contoursurface = Marching.GetOutput() for i in range(contoursurface.GetNumberOfPoints()): point = contoursurface.GetPoint(i) vertices.append([ point[0] + self.cursorXYZ[0], point[1] + self.cursorXYZ[1], point[2] + self.cursorXYZ[2] ]) me.verts.extend(vertices) me.materials = [materials["positivelobe"]] for i in range(contoursurface.GetNumberOfCells()): cell = contoursurface.GetCell(i) n1 = cell.GetPointId(0) n2 = cell.GetPointId(1) n3 = cell.GetPointId(2) faces.append([me.verts[n1], me.verts[n2], me.verts[n3]]) me.faces.extend(faces) for face in me.faces: face.smooth = True ob = self.scene.objects.new(me, 'Positive Lobe') Marching.SetValue(0, -isovalue) Marching.Update() contoursurface = Marching.GetOutput() vertices = [] for i in range(contoursurface.GetNumberOfPoints()): point = contoursurface.GetPoint(i) vertices.append([ point[0] + self.cursorXYZ[0], point[1] + self.cursorXYZ[1], point[2] + self.cursorXYZ[2] ]) me2.verts.extend(vertices) faces = [] for i in range(contoursurface.GetNumberOfCells()): cell = contoursurface.GetCell(i) n1 = cell.GetPointId(0) n2 = cell.GetPointId(1) n3 = cell.GetPointId(2) faces.append([me2.verts[n1], me2.verts[n2], me2.verts[n3]]) me2.faces.extend(faces) me2.materials = [materials["negativelobe"]] for face in me2.faces: face.smooth = True ob = self.scene.objects.new(me2, 'Negative Lobe')
def save_vtk_stru_point(path, vtk_dict, verbose=True): """ A routine to save a structured point vtk file given by a dictionary. Parameters ---------- path : string Path for the file to be saved to. vtk_dict : dict Dictionary containing information of a structured point vtk file. The following keywords are allowed: * ``"dimensions"``: (int, int, int) * ``"origin"``: (float, float, float) * ``"spacing"``: (float, float, float) * ``"header"``: string * ``"field_data"``: dict of {"name": array} * ``"point_data"``: dict of {"name": array} * ``"cell_data"``: dict of {"name": array} verbose : bool, optional Print information of the writing process. Default: True Notes ----- All data is assumed to be scalar. """ from numpy import ascontiguousarray as ascont from vtk import ( vtkStructuredPoints, vtkStructuredPointsWriter, vtkFieldData, ) from vtk.util.numpy_support import numpy_to_vtk as np2vtk out = vtkStructuredPoints() if verbose: print("Set 'dimensions', 'origin', 'spacing'") out.SetDimensions(vtk_dict["dimensions"]) out.SetOrigin(vtk_dict["origin"]) out.SetSpacing(vtk_dict["spacing"]) if vtk_dict["field_data"]: if verbose: print("Set 'field_data'") data = vtkFieldData() for sgl_data in vtk_dict["field_data"]: if verbose: print(" Set '" + sgl_data + "'") arr = np2vtk( ascont(vtk_dict["field_data"][sgl_data].reshape(-1, order="F"))) arr.SetName(sgl_data) data.AddArray(arr) out.SetFieldData(data) if vtk_dict["point_data"]: if verbose: print("Set 'point_data'") data = out.GetPointData() for sgl_data in vtk_dict["point_data"]: if verbose: print(" Set '" + sgl_data + "'") arr = np2vtk( ascont(vtk_dict["point_data"][sgl_data].reshape(-1, order="F"))) arr.SetName(sgl_data) data.AddArray(arr) if vtk_dict["cell_data"]: if verbose: print("Set 'cell_data'") data = out.GetCellData() for sgl_data in vtk_dict["cell_data"]: if verbose: print(" Set '" + sgl_data + "'") arr = np2vtk( ascont(vtk_dict["cell_data"][sgl_data].reshape(-1, order="F"))) arr.SetName(sgl_data) data.AddArray(arr) writer = vtkStructuredPointsWriter() writer.SetFileName(path) writer.SetInputData(out) if "header" in vtk_dict: writer.SetHeader(vtk_dict["header"]) writer.Write()
p.add_option("-v", action="store_true", dest="verbose", help="Verbose") p.add_option("-a", action="store_true", dest="ascii", help="ASCII, instead of binary, .vtu output") (opts, args) = p.parse_args() # get the com filename if len(args) != 2: p.print_help() sys.exit(1) (in_file, out_file) = args f = open(in_file + ".dat", 'r') #output = vtk.vtkPolyData() output = vtk.vtkStructuredPoints() nodes = [] nodes_array = vtk.vtkIntArray() nodes_array.SetName("nodes") node_x = [] node_y = [] node_z = [] counter = 0 point = vtk.vtkPoints() field_data = vtk.vtkFieldData() for line in f: if not line.split(): continue
def init_concentration_field_actors(self, actor_specs, drawing_params=None): """ initializes concentration field actors :param actor_specs: :param drawing_params: :return: None """ actors_dict = actor_specs.actors_dict field_dim = self.currentDrawingParameters.bsd.fieldDim # dim_order = self.dimOrder(self.currentDrawingParameters.plane) # dim = self.planeMapper(dim_order, (field_dim.x, field_dim.y, field_dim.z))# [fieldDim.x, fieldDim.y, fieldDim.z] dim = [field_dim.x, field_dim.y, field_dim.z] field_name = drawing_params.fieldName scene_metadata = drawing_params.screenshot_data.metadata mdata = MetadataHandler(mdata=scene_metadata) try: isovalues = mdata.get('ScalarIsoValues',default=[]) isovalues = list(map(lambda x: float(x), isovalues)) except: print('Could not process isovalue list ') isovalues = [] try: numIsos = mdata.get('NumberOfContourLines',default=3) except: print('could not process NumberOfContourLines setting') numIsos = 0 hex_flag = False lattice_type_str = self.get_lattice_type_str() if lattice_type_str.lower() == 'hexagonal': hex_flag = True import PlayerPython types_invisible = PlayerPython.vectorint() for type_label in drawing_params.screenshot_data.invisible_types: types_invisible.append(int(type_label)) # self.isovalStr = Configuration.getSetting("ScalarIsoValues", field_name) # if type(self.isovalStr) == QVariant: # self.isovalStr = str(self.isovalStr.toString()) # else: # self.isovalStr = str(self.isovalStr) con_array = vtk.vtkDoubleArray() con_array.SetName("concentration") con_array_int_addr = extract_address_int_from_vtk_object(field_extractor=self.field_extractor, vtkObj=con_array) cell_type_con = vtk.vtkIntArray() cell_type_con.SetName("concelltype") cell_type_con_int_addr = extract_address_int_from_vtk_object(field_extractor=self.field_extractor, vtkObj=cell_type_con) field_type = drawing_params.fieldType.lower() if field_type == 'confield': fill_successful = self.field_extractor.fillConFieldData3D(con_array_int_addr, cell_type_con_int_addr, field_name, types_invisible) elif field_type == 'scalarfield': fill_successful = self.field_extractor.fillScalarFieldData3D(con_array_int_addr, cell_type_con_int_addr, field_name, types_invisible) elif field_type == 'scalarfieldcelllevel': fill_successful = self.field_extractor.fillScalarFieldCellLevelData3D(con_array_int_addr, cell_type_con_int_addr, field_name, types_invisible) if not fill_successful: return range_array = con_array.GetRange() min_con = range_array[0] max_con = range_array[1] field_max = range_array[1] # print MODULENAME, ' initScalarFieldDataActors(): min,maxCon=',self.minCon,self.maxCon min_max_dict = self.get_min_max_metadata(scene_metadata=scene_metadata, field_name=field_name) min_range_fixed = min_max_dict['MinRangeFixed'] max_range_fixed = min_max_dict['MaxRangeFixed'] min_range = min_max_dict['MinRange'] max_range = min_max_dict['MaxRange'] # Note! should really avoid doing a getSetting with each step to speed up the rendering; # only update when changed in Prefs if min_range_fixed: min_con = min_range if max_range_fixed: max_con = max_range uGrid = vtk.vtkStructuredPoints() uGrid.SetDimensions(dim[0] + 2, dim[1] + 2, dim[ 2] + 2) # only add 2 if we're filling in an extra boundary (rf. FieldExtractor.cpp) # uGrid.SetDimensions(self.dim[0],self.dim[1],self.dim[2]) # uGrid.GetPointData().SetScalars(self.cellTypeCon) # cellType scalar field uGrid.GetPointData().SetScalars(con_array) # uGrid.GetPointData().AddArray(self.conArray) # additional scalar field voi = vtk.vtkExtractVOI() ## voi.SetInputConnection(uGrid.GetOutputPort()) # voi.SetInput(uGrid.GetOutput()) if VTK_MAJOR_VERSION >= 6: voi.SetInputData(uGrid) else: voi.SetInput(uGrid) voi.SetVOI(1, dim[0] - 1, 1, dim[1] - 1, 1, dim[2] - 1) # crop out the artificial boundary layer that we created isoContour = vtk.vtkContourFilter() # skinExtractorColor = vtk.vtkDiscreteMarchingCubes() # skinExtractorColor = vtk.vtkMarchingCubes() # isoContour.SetInput(uGrid) isoContour.SetInputConnection(voi.GetOutputPort()) isoNum = 0 for isoNum, isoVal in enumerate(isovalues): try: isoContour.SetValue(isoNum, isoVal) except: print MODULENAME, ' initScalarFieldDataActors(): cannot convert to float: ', self.isovalStr[idx] if isoNum > 0: isoNum += 1 delIso = (max_con - min_con) / (numIsos + 1) # exclude the min,max for isovalues isoVal = min_con + delIso for idx in xrange(numIsos): isoContour.SetValue(isoNum, isoVal) isoNum += 1 isoVal += delIso # UGLY hack to NOT display anything since our attempt to RemoveActor (below) don't seem to work if isoNum == 0: isoVal = field_max + 1.0 # go just outside valid range isoContour.SetValue(isoNum, isoVal) # concLut = vtk.vtkLookupTable() # concLut.SetTableRange(conc_vol.GetScalarRange()) # concLut.SetTableRange([self.minCon,self.maxCon]) self.scalarLUT.SetTableRange([min_con, max_con]) # concLut.SetNumberOfColors(256) # concLut.Build() # concLut.SetTableValue(39,0,0,0,0) # skinColorMapper = vtk.vtkPolyDataMapper() # skinColorMapper.SetInputConnection(skinNormals.GetOutputPort()) # self.conMapper.SetInputConnection(skinExtractorColor.GetOutputPort()) self.conMapper.SetInputConnection(isoContour.GetOutputPort()) self.conMapper.ScalarVisibilityOn() self.conMapper.SetLookupTable(self.scalarLUT) # # # print " this is conc_vol.GetScalarRange()=",conc_vol.GetScalarRange() # self.conMapper.SetScalarRange(conc_vol.GetScalarRange()) self.conMapper.SetScalarRange([min_con, max_con]) # self.conMapper.SetScalarRange(0,1500) # rwh - what does this do? # self.conMapper.SetScalarModeToUsePointFieldData() # self.conMapper.ColorByArrayComponent("concentration",0) # print MODULENAME,"initScalarFieldDataActors(): Plotting 3D Scalar field" # self.conMapper = vtk.vtkPolyDataMapper() # self.conActor = vtk.vtkActor() concentration_actor = actors_dict['concentration_actor'] concentration_actor.SetMapper(self.conMapper) self.init_min_max_actor(min_max_actor=actors_dict['min_max_text_actor'], range_array=range_array) if hex_flag: concentration_actor.SetScale(self.xScaleHex, self.yScaleHex, self.zScaleHex) if actor_specs.metadata is None: actor_specs.metadata = {'mapper': self.conMapper} else: actor_specs.metadata['mapper'] = self.conMapper if mdata.get('LegendEnable',default=False): print 'Enabling legend' self.init_legend_actors(actor_specs=actor_specs, drawing_params=drawing_params)
from vtk.util.misc import vtkGetDataRoot VTK_DATA_ROOT = vtkGetDataRoot() # Image pipeline image1 = vtk.vtkTIFFReader() image1.SetFileName(VTK_DATA_ROOT + "/Data/beach.tif") # "beach.tif" image contains ORIENTATION tag which is # ORIENTATION_TOPLEFT (row 0 top, col 0 lhs) type. The TIFF # reader parses this tag and sets the internal TIFF image # orientation accordingly. To overwrite this orientation with a vtk # convention of ORIENTATION_BOTLEFT (row 0 bottom, col 0 lhs ), invoke # SetOrientationType method with parameter value of 4. image1.SetOrientationType(4) image1.Update() sp = vtk.vtkStructuredPoints() sp.SetDimensions(image1.GetOutput().GetDimensions()) sp.SetExtent(image1.GetOutput().GetExtent()) sp.SetScalarType(image1.GetOutput().GetScalarType(), image1.GetOutputInformation(0)) sp.SetNumberOfScalarComponents( image1.GetOutput().GetNumberOfScalarComponents(), image1.GetOutputInformation(0)) sp.GetPointData().SetScalars(image1.GetOutput().GetPointData().GetScalars()) luminance = vtk.vtkImageLuminance() luminance.SetInputData(sp) # Let's create a dictionary to test the writers, the key will be the writer # and the value the file name used by the writer. filenames = [