def __init__(self, module_manager): SimpleVTKClassModuleBase.__init__( self, module_manager, vtk.vtkStructuredPointsReader(), 'Reading vtkStructuredPoints.', (), ('vtkStructuredPoints',), replaceDoc=True, inputFunctions=None, outputFunctions=None)
def main(argv): if len(argv) < 2: print "usage:",argv[0]," data.vtk" exit(1) data_fn = argv[1] reader = vtk.vtkStructuredPointsReader() reader.SetFileName(data_fn) reader.Update() data = reader.GetOutput() updateColorOpacity() # composite function (using ray tracing) compositeFunction = vtk.vtkVolumeRayCastCompositeFunction() volumeMapper = vtk.vtkVolumeRayCastMapper() volumeMapper.SetVolumeRayCastFunction(compositeFunction) volumeMapper.SetInput(data) # make the volume #volume = vtk.vtkVolume() global volume volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) # renderer renderer = vtk.vtkRenderer() renderWin = vtk.vtkRenderWindow() renderWin.AddRenderer(renderer) renderInteractor = vtk.vtkRenderWindowInteractor() renderInteractor.SetRenderWindow(renderWin) renderInteractor.AddObserver( vtk.vtkCommand.KeyPressEvent, keyPressed ) renderer.AddVolume(volume) renderer.SetBackground(0,0,0) renderWin.SetSize(400, 400) renderInteractor.Initialize() renderWin.Render() renderInteractor.Start()
def load_data_file(filename): reader = vtk.vtkStructuredPointsReader() reader.SetFileName(filename) reader.Update() Image = reader.GetOutput() array = VTKtoNumpy(Image) array = array.astype(float) return array
def ReadVTKImageFile(self): if (self.InputFileName == ''): self.PrintError('Error: no InputFileName.') self.PrintLog('Reading VTK image file.') reader = vtk.vtkStructuredPointsReader() reader.SetFileName(self.InputFileName) reader.Update() self.Image = reader.GetOutput()
def readSimulationData(self,_i): # self.counter+=1 # if self.counter>3: # return # print "self.drawMutex=",self.drawMutex self.drawMutex.lock() # print "self.readFileSem.available()=",self.readFileSem.available() self.readFileSem.acquire() self.newFileBeingLoaded=True # this flag is used to prevent calling draw function when new data is read from hard drive # print "LOCKED self.newFileBeingLoaded=",self.newFileBeingLoaded # self.drawMutex.lock() if _i >= len(self.ldsFileList): return fileName = self.ldsFileList[_i] self.simulationDataReader = vtk.vtkStructuredPointsReader() self.currentFileName = os.path.join(self.ldsDir,fileName) self.simulationDataReader.SetFileName(self.currentFileName) # print "path= ", os.path.join(self.ldsDir,fileName) self.simulationDataReader.Update() self.simulationData = self.simulationDataReader.GetOutput() # print "self.simulationData",self.simulationData # print 'dimensions=',self.simulationData.GetDimensions() #updating fieldDim each time we read data import CompuCell self.fieldDimPrevious=self.fieldDim # self.fieldDimPrevious=CompuCell.Dim3D() dimFromVTK=self.simulationData.GetDimensions() self.fieldDim=CompuCell.Dim3D(dimFromVTK[0],dimFromVTK[1],dimFromVTK[2]) # # self.fieldDim.x=dimFromVTK[0] # self.fieldDim.y=dimFromVTK[1] # self.fieldDim.z=dimFromVTK[2] # print 'self.fieldDim=',self.fieldDim # print "vtkStructuredPointsReader ERROR CODE=",self.simulationDataReader.GetErrorCode() self.currentStep = self.frequency * _i self.setCurrentStep(self.currentStep) # print "self.frequency=",self.frequency," _i=",self.frequency # print "\n\n\n\n FINISHED RUNNING readSimulationData step ",self.currentStep," \n\n\n" self.drawMutex.unlock() self.readFileSem.release()
def readVTKSP(fn): ''' reads a vtk structured points object from a file ''' sp_reader = vtk.vtkStructuredPointsReader() sp_reader.SetFileName(fn) sp_reader.Update() sp = sp_reader.GetOutput() return sp
def createReader(self,fileName): #I dont care about different types of readers for now #If i get a different file then i can mod reader here or something reader = vtk.vtkStructuredPointsReader() reader.SetFileName(fileName) reader.ReadAllVectorsOn() reader.ReadAllScalarsOn() reader.Update() self.determineCenterForCuttingPlane(reader) return reader
def VTKSPtoNumpyFromFile(fn): ''' reads a .vts file into a numpy array args: @a fn - string, filename of .sp file to read ''' reader = vtk.vtkStructuredPointsReader() reader.SetFileName(fn) reader.Update() sp = reader.GetOutput() return VTKSPtoNumpy(sp)
def readVTKVolume(name): try: reader = vtk.vtkStructuredPointsReader() reader.SetFileName( name ) reader.Update() print "Input volume:", name vol = reader.GetOutput() reader = None return vol except: print "VTK volume reader failed" exc_type, exc_value, exc_traceback = sys.exc_info() traceback.print_exception(exc_type, exc_value, exc_traceback, limit=2, file=sys.stdout) return None
def calculate_vtk_max_pointwise_difference(file1,file2,tol=1e-6): arrays = [0]*2 reader = vtk.vtkStructuredPointsReader() for i, fname in enumerate([file1, file2]): reader.SetFileName(fname) reader.Update() data = reader.GetOutput().GetPointData() arrays[i] = np.array([vtk_to_numpy(data.GetArray(n)) for n in range(data.GetNumberOfArrays())]) try: return np.allclose(arrays[0],arrays[1],rtol=0,atol=tol), np.max(np.abs(arrays[0]-arrays[1])) except: return False, np.inf
def parse_vtk(vtk_file, sim_dict, data_fields): dim = sim_dict['dim'] reader = vtk.vtkStructuredPointsReader() # reader = vtkUnstructuredGridReader() reader.SetFileName(vtk_file) reader.Update() field_data = reader.GetOutput() out_data = {} for data_field in data_fields: out_data[data_field] = vtk_to_numpy( field_data.GetPointData().GetArray(data_field)).reshape((dim['x'], dim['y'])) reader.CloseVTKFile() return out_data
def main(argv): if len(argv) < 2: print "usage:",argv[0]," data.vtk" exit(1) data_fn = argv[1] reader = vtk.vtkStructuredPointsReader() reader.SetFileName(data_fn) reader.Update() data = reader.GetOutput() skin = vtk.vtkMarchingCubes() skin.ComputeNormalsOn() skin.ComputeGradientsOn() skin.SetValue(0, rgb[0][0]) skin.SetInput(data) skin_mapper = vtk.vtkPolyDataMapper() skin_mapper.SetInputConnection(skin.GetOutputPort()) skin_mapper.ScalarVisibilityOff() skin_actor = vtk.vtkActor() skin_property = vtk.vtkProperty() skin_property.SetColor(rgb[0][1], rgb[0][2], rgb[0][3]) skin_property.SetOpacity(opacity[0][1]) skin_actor.SetProperty(skin_property) skin_actor.SetMapper(skin_mapper) bone = vtk.vtkMarchingCubes() bone.ComputeNormalsOn() bone.ComputeGradientsOn() bone.SetValue(0, rgb[1][0]) bone.SetInput(data) bone_mapper = vtk.vtkPolyDataMapper() bone_mapper.SetInputConnection(bone.GetOutputPort()) bone_mapper.ScalarVisibilityOff() bone_actor = vtk.vtkActor() bone_actor.GetProperty().SetColor(rgb[1][1], rgb[1][2], rgb[1][3]) bone_actor.GetProperty().SetOpacity(opacity[1][1]) bone_actor.SetMapper(bone_mapper) renderer = vtk.vtkRenderer() renderWin = vtk.vtkRenderWindow() renderWin.AddRenderer(renderer) renderInteractor = vtk.vtkRenderWindowInteractor() renderInteractor.SetRenderWindow(renderWin) renderer.AddActor(skin_actor) #renderer.AddActor(bone_actor) renderer.SetBackground(0,0,0) renderWin.SetSize(400, 400) renderInteractor.Initialize() renderWin.Render() renderInteractor.Start()
def create_reader (self): "Create the corresponding reader." debug ("In VtkDataReader::create_reader ()") # set up the reader if self.file_name == "": raise IOError, "No filename specifed for the data handler!" self.grid_type = find_data_type (self.file_name) if self.grid_type == "STRUCTURED_GRID": self.reader = vtk.vtkStructuredGridReader () elif self.grid_type == "STRUCTURED_POINTS": self.reader = vtk.vtkStructuredPointsReader () elif self.grid_type == "RECTILINEAR_GRID": self.reader = vtk.vtkRectilinearGridReader () elif self.grid_type == "POLYDATA": self.reader = vtk.vtkPolyDataReader () elif self.grid_type == "UNSTRUCTURED_GRID": self.reader = vtk.vtkUnstructuredGridReader ()
def _create_structured_points_pyvtk(x, y, z): """Creates a vtkStructuredPoints object given input data in the form of arrays. This uses pyvtk to do the job and generates a temporary file in the process. 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. """ import pyvtk import tempfile, os nx = len(x) ny = len(y) nz = len(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]) # create a vtk data file sp = pyvtk.StructuredPoints ((nx, ny, 1), (xmin, ymin, 0), (dx, dy, 1)) pd = pyvtk.PointData(pyvtk.Scalars(z, name='Scalars', lookup_table="default")) d = pyvtk.VtkData(sp, pd, "Surf data") file_name = tempfile.mktemp(suffix='.vtk') d.tofile(file_name, format='ascii') # read the created file - yes this is circuitous but works for now. reader = vtk.vtkStructuredPointsReader() reader.SetFileName(file_name) reader.Update() # cleanup. os.remove(file_name) return reader.GetOutput()
def load_maps(mol,rendmod,gfx,atomcol): mol.reader = vtk.vtkStructuredPointsReader() mol.reader.SetFileName(mol.mod.dfn) mol.reader.Update() #by calling Update() we read the file mol.iso = vtk.vtkMarchingContourFilter() mol.iso.UseScalarTreeOn() mol.iso.ComputeNormalsOn() mol.iso.SetInputConnection(mol.reader.GetOutputPort()) mol.iso.SetValue(0,mol.mod.isov*mol.mod.sigavg[0]+mol.mod.sigavg[1]) clean = vtk.vtkCleanPolyData() clean.SetInputConnection(mol.iso.GetOutputPort()) clean.ConvertStripsToPolysOn() smooth = vtk.vtkWindowedSincPolyDataFilter() smooth.SetInputConnection(clean.GetOutputPort()) smooth.BoundarySmoothingOn() smooth.GenerateErrorVectorsOn() smooth.GenerateErrorScalarsOn() smooth.NormalizeCoordinatesOn() smooth.NonManifoldSmoothingOn() smooth.FeatureEdgeSmoothingOn() smooth.SetEdgeAngle(90) smooth.SetFeatureAngle(90) smooth.Update() mol.mapper = vtk.vtkOpenGLPolyDataMapper() mol.mapper.SetInputConnection(smooth.GetOutputPort()) ### <- connection here mol.mapper.ScalarVisibilityOff() mol.mapper.Update() mol.acteur= vtk.vtkOpenGLActor() mol.acteur.SetMapper(mol.mapper) mol.acteur.GetProperty().SetColor(mol.col) if rendmod==5: mol.acteur.GetProperty().SetRepresentationToSurface() elif rendmod==6: mol.acteur.GetProperty().SetRepresentationToWireframe() elif rendmod==7: mol.acteur.GetProperty().SetRepresentationToPoints() else : mol.acteur.GetProperty().SetRepresentationToSurface() mol.acteur.GetProperty().SetInterpolationToGouraud() mol.acteur.GetProperty().SetSpecular(.4) mol.acteur.GetProperty().SetSpecularPower(10) gfx.renderer.AddActor(mol.acteur) gfx.renwin.Render()
def read_data(file_in,dens_inc=False): """ Reads in data from file_in.vtk into x, y, z, b, u """ import vtk as vtk from vtk.util.numpy_support import vtk_to_numpy from numpy import rollaxis, reshape, array #Some vtk bookkeeping and object stuff reader = vtk.vtkStructuredPointsReader() reader.SetFileName(file_in) reader.ReadAllVectorsOn() reader.ReadAllScalarsOn() reader.Update() data = reader.GetOutput() dim = data.GetDimensions() nx = dim[0] - 1 ny = dim[1] - 1 nz = dim[2] - 1 D = data.GetSpacing() N = (nx, ny, nz) #Read the raw data from the vtk file #u = vtk_to_numpy(data.GetCellData().GetArray('velocity')).reshape(nx, ny, nz, 3,order='F') #b = vtk_to_numpy(data.GetCellData().GetArray('cell_centered_B')).reshape(nx, ny, nz, 3,order='F') ## #Convert to C-order and make a the 1st array index the vector component #b = array([b[...,0].ravel(order='F').reshape(nx,ny,nz), b[...,1].ravel(order='F').reshape(nx,ny,nz), b[...,2].ravel(order='F').reshape(nx,ny,nz)]) #u = array([u[...,0].ravel(order='F').reshape(nx,ny,nz), u[...,1].ravel(order='F').reshape(nx,ny,nz), u[...,2].ravel(order='F').reshape(nx,ny,nz)]) ## #Read the raw data from the vtk file u = vtk_to_numpy(data.GetCellData().GetArray('velocity')).reshape(nz,ny,nx,3) b = vtk_to_numpy(data.GetCellData().GetArray('cell_centered_B')).reshape(nz, ny, nx,3) if(dens_inc): rho = vtk_to_numpy(data.GetCellData().GetArray('density')).reshape(nz,ny,nx) return (N,D,b.T,u.T,rho.T) #u = ascontiguousarray(array([u[...,0], u[...,1], u[...,2]])) #b = ascontiguousarray(array([b[...,0], b[...,1], b[...,2]])) #u = u.transpose(3,2,1,0) #b = b.transpose(3,2,1,0) return (N, D, b.T, u.T)
def read_vtk(filename, skipGrid = False, reshape = False): reader = vtkStructuredPointsReader() reader.SetFileName(filename) # reader.SetDataByteOrderToBigEndian() # reader.ReadAllVectorsOn() # reader.ReadAllScalarsOn() reader.Update() data = reader.GetOutput() dim = data.GetDimensions() vec = list(dim) vec = [i-1 for i in dim] vec.append(3) # print dim # print vec # print data.GetPointData() try: u = VN.vtk_to_numpy(data.GetPointData().GetArray('Re')) except AttributeError: #older file format u = VN.vtk_to_numpy(data.GetPointData().GetArray('scalar_field')) x = np.zeros(data.GetNumberOfPoints()) y = np.zeros(data.GetNumberOfPoints()) z = np.zeros(data.GetNumberOfPoints()) if not skipGrid: # Looping over all the point takes a while... perhaps there is a faster way for i in range(data.GetNumberOfPoints()): x[i],y[i],z[i] = data.GetPoint(i) if reshape: u = u.reshape(dim,order='F') x = x.reshape(dim,order='F') y = y.reshape(dim,order='F') z = z.reshape(dim,order='F') return (u, np.array([x,y,z]))
def readvtk(path, datatype='polydata'): """Read VTK-file. Args: path: Path to file. type: 'imagedata', 'polydata', 'unstructeredgrid' """ if datatype=='imagedata': reader = vtk.vtkStructuredPointsReader() elif datatype=='polydata': reader = vtk.vtkPolyDataReader() elif datatype=='unstructeredgrid': reader = vtk.vtkUnstructuredGridReader() else: print 'Invalid datatype' reader.SetFileName(path) reader.Update() return reader.GetOutput()
def readDisplacement(filename): reader = vtk.vtkStructuredPointsReader();reader.SetFileName(filename); reader.Update(); grid = reader.GetOutput(); Dimensions=grid.GetExtent(); NumPixX=Dimensions[1]+1; NumPixY=Dimensions[3]+1; centre = grid.GetCenter(); bounds = grid.GetBounds(); reader.SetScalarsName(reader.GetScalarsNameInFile(0));reader.Update();structuredPoints = reader.GetOutput(); pd=structuredPoints.GetPointData(); scalars=pd.GetScalars(reader.GetScalarsNameInFile(0)); numPoints = scalars.GetSize(); U=numpy.zeros([numPoints/2,1]); V=numpy.zeros([numPoints/2,1]); for i in range(0,(numPoints-1)/2): U[i]=scalars.GetValue(2*i); V[i]=scalars.GetValue(2*i+1); return {'U':U.reshape(NumPixY,NumPixX), 'V':V.reshape(NumPixY,NumPixX) }
def readSimulationDataNonBlocking(self,_i): self.newFileBeingLoaded=True # this flag is used to prevent calling draw function when new data is read from hard drive # print "LOCKED self.newFileBeingLoaded=",self.newFileBeingLoaded # self.drawMutex.lock() if _i >= len(self.ldsFileList): return False fileName = self.ldsFileList[_i] self.simulationDataReader = vtk.vtkStructuredPointsReader() self.currentFileName = os.path.join(self.ldsDir,fileName) print 'self.currentFileName=',self.currentFileName extractedMCS = self.extractMCSNumberFromFileName(self.currentFileName) if extractedMCS < 0: extractedMCS = _i self.simulationDataReader.SetFileName(self.currentFileName) # print "path= ", os.path.join(self.ldsDir,fileName) dataReaderIntAddr = self.__ui.extractAddressIntFromVtkObject(self.simulationDataReader) self.__ui.fieldExtractor.readVtkStructuredPointsData(dataReaderIntAddr) # swig wrapper on top of vtkStructuredPointsReader.Update() - releases GIL, hence can be used in multithreaded program that does not block GUI # # # self.simulationDataReader.Update() # does not erlease GIL - VTK ISSUE - cannot be used in multithreaded program - blocks GUI self.simulationData = self.simulationDataReader.GetOutput() import CompuCell self.fieldDimPrevious=self.fieldDim # self.fieldDimPrevious=CompuCell.Dim3D() dimFromVTK=self.simulationData.GetDimensions() self.fieldDim=CompuCell.Dim3D(dimFromVTK[0],dimFromVTK[1],dimFromVTK[2]) self.currentStep = extractedMCS # # # self.currentStep = self.frequency * _i # this is how we set CMS for CML reading before self.setCurrentStep(self.currentStep) return True
def readPicture(filename): reader = vtk.vtkStructuredPointsReader() reader.SetFileName(filename) reader.Update() grid = reader.GetOutput() Dimensions=grid.GetExtent() NumPixX=Dimensions[1]+1 NumPixY=Dimensions[3]+1 centre = grid.GetCenter() bounds = grid.GetBounds() reader.SetScalarsName(reader.GetScalarsNameInFile(0)); reader.Update(); structuredPoints = reader.GetOutput(); pd=structuredPoints.GetPointData(); scalars=pd.GetScalars(reader.GetScalarsNameInFile(0)); numPoints = scalars.GetSize() Img=numpy.zeros([numPoints,1]) for i in range(0,(numPoints-1)): Img[i]=scalars.GetValue(i); return Img.reshape(NumPixY,NumPixX);
def __init__(self, module_manager): # call parent constructor ModuleBase.__init__(self, module_manager) self._reader = vtk.vtkStructuredPointsReader() # ctor for this specific mixin FilenameViewModuleMixin.__init__( self, 'Select a filename', 'VTK data (*.vtk)|*.vtk|All files (*)|*', {'vtkStructuredPointsReader': self._reader}) module_utils.setup_vtk_object_progress( self, self._reader, 'Reading vtk structured points data') # set up some defaults self._config.filename = '' self.sync_module_logic_with_config()
def LoadVolume(self): """ loads the volume - this only happens once during the lifetime of the application """ if len(sys.argv) < 2: print " Error - please provide a file name (.vtk)" exit fileName = sys.argv[1] extension = fileName.split('.')[-1] if extension == "vtk": reader = vtk.vtkStructuredPointsReader() reader.SetFileName( fileName ) reader.Update() elif extension == "tif": reader = vtk.vtkTIFFReader() reader.SetFileName( fileName ) reader.Update() else: print " Unknown file type ", extension return reader.GetOutput()
def transformVolume(self, inputVolume, outputVolume, transformationMatrix): # Normalize matrix so it preserve its scaling (diagonal elements are # equal to 1) M = self.__normalizeMatrix(transformationMatrix) reader = vtk.vtkStructuredPointsReader() reader.SetFileName(inputVolume) reader.Update() reader.GetOutput().UpdateInformation() matrix = vtk.vtkMatrix4x4() matrix.DeepCopy(( M[0,0], M[0,1], M[0,2], M[0,3], M[1,0], M[1,1], M[1,2], M[1,3], M[2,0], M[2,1], M[2,2], M[2,3], M[3,0], M[3,1], M[3,2], M[3,3] )) # Extract a slice in the desired orientation reslice = vtk.vtkImageReslice() reslice.SetInputConnection(reader.GetOutputPort()) reslice.SetResliceAxes(matrix) reslice.AutoCropOutputOff() reslice.SetInterpolationModeToNearestNeighbor() #reslice.SetInterpolationModeToLinear() print >>sys.stderr,'M=\n',M ch = vtk.vtkImageChangeInformation() ch.SetInput(reslice.GetOutput()) ch.SetOutputOrigin(*OUTPUT_VOLUME_ORIGIN) ch.SetOutputSpacing(*OUTPUT_VOLUME_SPACING) ch.Update() writer = vtk.vtkStructuredPointsWriter() writer.SetFileTypeToBinary() writer.SetInput(ch.GetOutput()) writer.SetFileName(outputVolume) writer.Update()
def readStrain(filename): reader = vtk.vtkStructuredPointsReader();reader.SetFileName(filename); reader.Update(); grid = reader.GetOutput(); Dimensions=grid.GetExtent(); NumPixX=Dimensions[1]+1; NumPixY=Dimensions[3]+1; centre = grid.GetCenter(); bounds = grid.GetBounds(); reader.SetScalarsName(reader.GetScalarsNameInFile(0));reader.Update();structuredPoints = reader.GetOutput(); pd=structuredPoints.GetPointData(); scalars=pd.GetScalars(reader.GetScalarsNameInFile(0)); numPoints = scalars.GetSize(); grad11=numpy.zeros([numPoints/4,1]); grad12=numpy.zeros([numPoints/4,1]); grad21=numpy.zeros([numPoints/4,1]); grad22=numpy.zeros([numPoints/4,1]); for i in range(0,(numPoints-1)/4): grad11[i]=scalars.GetValue(4*i); grad12[i]=scalars.GetValue(4*i+1); grad21[i]=scalars.GetValue(4*i+2); grad22[i]=scalars.GetValue(4*i+3); return {'grad11':grad11.reshape(NumPixY,NumPixX), 'grad12':grad12.reshape(NumPixY,NumPixX),'grad21':grad21.reshape(NumPixY,NumPixX),'grad22':grad22.reshape(NumPixY,NumPixX)}
ipwz.EnabledOn() self.Xswitch = 1 self.Yswitch = 1 self.Zswitch = 1 elif key == "l": if self.liver == 1: renderer.RemoveActor(liverActor) self.liver = 0 self.render_window.Render() else: renderer.AddActor(liverActor) self.liver = 1 self.render_window.Render() # image reader filename1 = "ctscan_ez.vtk" reader1 = vtk.vtkStructuredPointsReader() reader1.SetFileName( filename1 ) reader1.Update() W,H,D = reader1.GetOutput().GetDimensions() a1,b1 = reader1.GetOutput().GetScalarRange() print "Range of image: %d--%d" %(a1,b1) filename2 = "ctscan_ez_bin.vtk" reader2 = vtk.vtkStructuredPointsReader() reader2.SetFileName( filename2 ) reader2.Update() a2,b2 = reader2.GetOutput().GetScalarRange() print "Range of segmented image: %d--%d" %(a2,b2)
def Main(): global ren print "data: %s" % sys.argv[1] reader = vtk.vtkStructuredPointsReader() reader.SetFileName(sys.argv[1]) # Create the standard renderer, render window and interactor ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) iren.RemoveObservers('RightButtonPressEvent') iren.AddObserver('RightButtonPressEvent', print_camera_settings, 1.0) iren.AddObserver('RightButtonPressEvent', after_print_camera_settings, -1.0) datapoints = [[420, 0.1, 0.1, 1, 0.0001], [950, 0, 0.8, 1, 0.0002], [1642, 0.1, 0, 1, 1]] # Create transfer mapping scalar value to opacity opacityTransferFunction = vtk.vtkPiecewiseFunction() for p in datapoints: opacityTransferFunction.AddPoint(p[0], p[4]) # Create transfer mapping scalar value to color colorTransferFunction = vtk.vtkColorTransferFunction() for p in datapoints: colorTransferFunction.AddHSVPoint(p[0], p[1], p[2], p[3]) # The property describes how the data will look volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(colorTransferFunction) volumeProperty.SetScalarOpacity(opacityTransferFunction) volumeProperty.ShadeOn() volumeProperty.SetInterpolationTypeToLinear() # The mapper / ray cast function know how to render the data compositeFunction = vtk.vtkVolumeRayCastCompositeFunction() volumeMapper = vtk.vtkVolumeRayCastMapper() volumeMapper.SetVolumeRayCastFunction(compositeFunction) volumeMapper.SetInputConnection(reader.GetOutputPort()) volumeMapper.SetSampleDistance(0.1) print "sample distance: %f" % volumeMapper.GetSampleDistance() # The volume holds the mapper and the property and # can be used to position/orient the volume volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) ren.AddVolume(volume) ren.SetBackground(0, 0, 0) ren.GetActiveCamera().SetViewUp(-0.033792287793636924, 0.000854723562570334, -0.9994285120674231) ren.GetActiveCamera().SetPosition(-308.155681140229, -119.92183136577268, 117.3094068139949) ren.GetActiveCamera().SetFocalPoint(91.14654767513275, 104.1683804243803, 104.0) ren.GetActiveCamera().SetClippingRange(191.00826351112892, 795.369621458024) renWin.SetSize(1600, 900) renWin.Render() renWin.AddObserver("AbortCheckEvent", CheckAbort) iren.Initialize() renWin.Render() iren.Start()
# This is a simple volume rendering example that uses a # vtkVolumeRayCast mapper import vtk from vtk.util.misc import vtkGetDataRoot VTK_DATA_ROOT = vtkGetDataRoot() # Create the standard renderer, render window and interactor ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Create the reader for the data reader = vtk.vtkStructuredPointsReader() reader.SetFileName(VTK_DATA_ROOT + "/Data/ironProt.vtk") # Create transfer mapping scalar value to opacity opacityTransferFunction = vtk.vtkPiecewiseFunction() opacityTransferFunction.AddPoint(20, 0.0) opacityTransferFunction.AddPoint(255, 0.2) # Create transfer mapping scalar value to color colorTransferFunction = vtk.vtkColorTransferFunction() colorTransferFunction.AddRGBPoint(0.0, 0.0, 0.0, 0.0) colorTransferFunction.AddRGBPoint(64.0, 1.0, 0.0, 0.0) colorTransferFunction.AddRGBPoint(128.0, 0.0, 0.0, 1.0) colorTransferFunction.AddRGBPoint(192.0, 0.0, 1.0, 0.0) colorTransferFunction.AddRGBPoint(255.0, 0.0, 0.2, 0.0)
def main(): fileName = r"carotid.vtk" colors = vtk.vtkNamedColors() ren1 = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Create the pipeline. reader = vtk.vtkStructuredPointsReader() reader.SetFileName(fileName) psource = vtk.vtkPointSource() psource.SetNumberOfPoints(25) psource.SetCenter(133.1, 116.3, 5.0) psource.SetRadius(2.0) threshold = vtk.vtkThresholdPoints() threshold.SetInputConnection(reader.GetOutputPort()) threshold.ThresholdByUpper(275) streamers = vtk.vtkStreamTracer() streamers.SetInputConnection(reader.GetOutputPort()) streamers.SetSourceConnection(psource.GetOutputPort()) streamers.SetMaximumPropagation(100.0) streamers.SetInitialIntegrationStep(0.2) streamers.SetTerminalSpeed(.01) streamers.Update() scalarRange = [0] * 2 scalarRange[0] = streamers.GetOutput().GetPointData().GetScalars( ).GetRange()[0] scalarRange[1] = streamers.GetOutput().GetPointData().GetScalars( ).GetRange()[1] tubes = vtk.vtkTubeFilter() tubes.SetInputConnection(streamers.GetOutputPort()) tubes.SetRadius(0.3) tubes.SetNumberOfSides(6) tubes.SetVaryRadius(0) lut = vtk.vtkLookupTable() lut.SetHueRange(.667, 0.0) lut.Build() streamerMapper = vtk.vtkPolyDataMapper() streamerMapper.SetInputConnection(tubes.GetOutputPort()) streamerMapper.SetScalarRange(scalarRange[0], scalarRange[1]) streamerMapper.SetLookupTable(lut) streamerActor = vtk.vtkActor() streamerActor.SetMapper(streamerMapper) # Speed contours. iso = vtk.vtkContourFilter() iso.SetInputConnection(reader.GetOutputPort()) iso.SetValue(0, 175) isoMapper = vtk.vtkPolyDataMapper() isoMapper.SetInputConnection(iso.GetOutputPort()) isoMapper.ScalarVisibilityOff() isoActor = vtk.vtkActor() isoActor.SetMapper(isoMapper) isoActor.GetProperty().SetRepresentationToWireframe() isoActor.GetProperty().SetOpacity(0.25) # Outline outline = vtk.vtkOutlineFilter() outline.SetInputConnection(reader.GetOutputPort()) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInputConnection(outline.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(outlineMapper) outlineActor.GetProperty().SetColor(0., 0., 0.) # Add the actors to the renderer, set the background and size. ren1.AddActor(outlineActor) ren1.AddActor(streamerActor) ren1.AddActor(isoActor) ren1.SetBackground(1., 1., 1.) renWin.SetSize(640, 480) ren1.ResetCamera() ren1.ResetCameraClippingRange() # Render the image. renWin.Render() iren.Start()
def main(): fileName = get_program_parameters() colors = vtk.vtkNamedColors() ren1 = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Create the pipeline. # reader = vtk.vtkStructuredPointsReader() reader.SetFileName(fileName) psource = vtk.vtkPointSource() psource.SetNumberOfPoints(25) psource.SetCenter(133.1, 116.3, 5.0) psource.SetRadius(2.0) threshold = vtk.vtkThresholdPoints() threshold.SetInputConnection(reader.GetOutputPort()) threshold.ThresholdByUpper(275) streamers = vtk.vtkStreamTracer() streamers.SetInputConnection(reader.GetOutputPort()) streamers.SetSourceConnection(psource.GetOutputPort()) # streamers.SetMaximumPropagationUnitToTimeUnit() streamers.SetMaximumPropagation(100.0) # streamers.SetInitialIntegrationStepUnitToCellLengthUnit() streamers.SetInitialIntegrationStep(0.2) streamers.SetTerminalSpeed(.01) streamers.Update() scalarRange = [0] * 2 scalarRange[0] = streamers.GetOutput().GetPointData().GetScalars( ).GetRange()[0] scalarRange[1] = streamers.GetOutput().GetPointData().GetScalars( ).GetRange()[1] print("range: ", scalarRange[0], ", ", scalarRange[1]) tubes = vtk.vtkTubeFilter() tubes.SetInputConnection(streamers.GetOutputPort()) tubes.SetRadius(0.3) tubes.SetNumberOfSides(6) tubes.SetVaryRadius(0) lut = vtk.vtkLookupTable() lut.SetHueRange(.667, 0.0) lut.Build() streamerMapper = vtk.vtkPolyDataMapper() streamerMapper.SetInputConnection(tubes.GetOutputPort()) streamerMapper.SetScalarRange(scalarRange[0], scalarRange[1]) streamerMapper.SetLookupTable(lut) streamerActor = vtk.vtkActor() streamerActor.SetMapper(streamerMapper) # Speed contours. iso = vtk.vtkContourFilter() iso.SetInputConnection(reader.GetOutputPort()) iso.SetValue(0, 175) isoMapper = vtk.vtkPolyDataMapper() isoMapper.SetInputConnection(iso.GetOutputPort()) isoMapper.ScalarVisibilityOff() isoActor = vtk.vtkActor() isoActor.SetMapper(isoMapper) isoActor.GetProperty().SetRepresentationToWireframe() isoActor.GetProperty().SetOpacity(0.25) # Outline outline = vtk.vtkOutlineFilter() outline.SetInputConnection(reader.GetOutputPort()) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInputConnection(outline.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(outlineMapper) outlineActor.GetProperty().SetColor(colors.GetColor3d("Black")) # Add the actors to the renderer, set the background and size. # ren1.AddActor(outlineActor) ren1.AddActor(streamerActor) ren1.AddActor(isoActor) ren1.SetBackground(colors.GetColor3d("Wheat")) renWin.SetSize(640, 480) cam1 = vtk.vtkCamera() cam1.SetClippingRange(17.4043, 870.216) cam1.SetFocalPoint(136.71, 104.025, 23) cam1.SetPosition(204.747, 258.939, 63.7925) cam1.SetViewUp(-0.102647, -0.210897, 0.972104) cam1.Zoom(1.6) ren1.SetActiveCamera(cam1) # Render the image. # renWin.Render() iren.Start()
def main(): fileNames = [""] * 2 fileNames[0], fileNames[1] = get_program_parameters() # Generate the other vecAnim file names. There are 8 of them. tmpFn = fileNames[1][:-5] for i in range(2, 9): fileNames.append(tmpFn + str(i) + ".vtk") colors = vtk.vtkNamedColors() # Setup the render window, renderer, and interactor. renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(renderWindow) # Read the data. # # Create the pipeline. # reader = vtk.vtkStructuredPointsReader() reader.SetFileName(fileNames[0]) threshold = vtk.vtkThresholdPoints() threshold.SetInputConnection(reader.GetOutputPort()) threshold.ThresholdByUpper(200) line = vtk.vtkLineSource() line.SetResolution(1) lines = vtk.vtkGlyph3D() lines.SetInputConnection(threshold.GetOutputPort()) lines.SetSourceConnection(line.GetOutputPort()) lines.SetScaleFactor(0.005) lines.SetScaleModeToScaleByScalar() lines.Update() vectorMapper = vtk.vtkPolyDataMapper() vectorMapper.SetInputConnection(lines.GetOutputPort()) vectorMapper.SetScalarRange(lines.GetOutput().GetScalarRange()) vectorActor = vtk.vtkActor() vectorActor.SetMapper(vectorMapper) vectorActor.GetProperty().SetOpacity(0.99) vectorActor.GetProperty().SetLineWidth(1.5) # Outline outline = vtk.vtkOutlineFilter() outline.SetInputConnection(reader.GetOutputPort()) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInputConnection(outline.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(outlineMapper) outlineActor.GetProperty().SetColor(colors.GetColor3d("Black")) # Texture maps. textureMaps = list() for i in range(2, len(fileNames)): tmap = vtk.vtkStructuredPointsReader() tmap.SetFileName(fileNames[i]) texture = vtk.vtkTexture() texture.SetInputConnection(tmap.GetOutputPort()) texture.InterpolateOff() texture.RepeatOff() textureMaps.append(texture) vectorActor.SetTexture(textureMaps[0]) # Add the actors to the renderer, set the background and size. # renderer.AddActor(vectorActor) renderer.AddActor(outlineActor) cam1 = vtk.vtkCamera() cam1.SetClippingRange(17.4043, 870.216) cam1.SetFocalPoint(136.71, 104.025, 23) cam1.SetPosition(204.747, 258.939, 63.7925) cam1.SetViewUp(-0.102647, -0.210897, 0.972104) cam1.Zoom(1.5) renderer.SetActiveCamera(cam1) renderer.SetBackground(colors.GetColor3d("Wheat")) renderWindow.SetSize(640, 480) # Go into a loop. for j in range(0, 100): for i in range(0, len(textureMaps)): vectorActor.SetTexture(textureMaps[i]) renderWindow.Render() interactor.Start()
def Main(): global ren print "data: %s" % sys.argv[1] reader = vtk.vtkStructuredPointsReader() reader.SetFileName(sys.argv[1]) # Create the standard renderer, render window and interactor ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) iren.RemoveObservers('RightButtonPressEvent') iren.AddObserver('RightButtonPressEvent', print_camera_settings, 1.0) iren.AddObserver('RightButtonPressEvent', after_print_camera_settings, -1.0) datapoints = [[0, 0.66, 0, 1, 0], [900, 0.66, 0.1, 1, 0.009], [10000, 0.66, 0.3, 1, 0.01], [20000, 0.66, 0.5, 1, 0.3], [30000, 0.66, 1, 1, 1]] # Create transfer mapping scalar value to opacity opacityTransferFunction = vtk.vtkPiecewiseFunction() for p in datapoints: opacityTransferFunction.AddPoint(p[0], p[4]) # Create transfer mapping scalar value to color colorTransferFunction = vtk.vtkColorTransferFunction() for p in datapoints: colorTransferFunction.AddHSVPoint(p[0], p[1], p[2], p[3]) # The property describes how the data will look volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(colorTransferFunction) volumeProperty.SetScalarOpacity(opacityTransferFunction) volumeProperty.ShadeOn() volumeProperty.SetInterpolationTypeToLinear() # The mapper / ray cast function know how to render the data compositeFunction = vtk.vtkVolumeRayCastCompositeFunction() volumeMapper = vtk.vtkVolumeRayCastMapper() volumeMapper.SetVolumeRayCastFunction(compositeFunction) volumeMapper.SetInputConnection(reader.GetOutputPort()) volumeMapper.SetSampleDistance(0.1) print "sample distance: %f" % volumeMapper.GetSampleDistance() # The volume holds the mapper and the property and # can be used to position/orient the volume volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) ren.AddVolume(volume) ren.SetBackground(0, 0, 0) ren.GetActiveCamera().SetViewUp(0.2320640509325283, 0.6216278154231228, 0.748147803149258) ren.GetActiveCamera().SetPosition(-86.30842917477719, -55.80182530081589, 297.63908735650085) ren.GetActiveCamera().SetFocalPoint(199.18608617782593, 149.5, 38.5) ren.GetActiveCamera().SetClippingRange(4.197001562269691, 982.4499004768599) renWin.SetSize(1600, 900) renWin.Render() renWin.AddObserver("AbortCheckEvent", CheckAbort) iren.Initialize() renWin.Render() iren.Start()
def testimageMCAll(self): # Create the RenderWindow, Renderer and both Actors # ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) # create pipeline # slc = vtk.vtkStructuredPointsReader() slc.SetFileName(VTK_DATA_ROOT + "/Data/ironProt.vtk") colors = ["flesh", "banana", "grey", "pink", "carrot", "gainsboro", "tomato", "gold", "thistle", "chocolate"] types = ["UnsignedChar", "Char", "Short", "UnsignedShort", "Int", "UnsignedInt", "Long", "UnsignedLong", "Float", "Double"] i = 1 c = 0 clip = list() cast = list() iso = list() mapper = list() actor = list() colorWrapper = self.Colors() for idx, vtkType in enumerate(types): clip.append(vtk.vtkImageClip()) clip[idx].SetInputConnection(slc.GetOutputPort()) clip[idx].SetOutputWholeExtent(-1000, 1000, -1000, 1000, i, i + 5) i += 5 cast.append(vtk.vtkImageCast()) eval('cast[idx].SetOutputScalarTypeTo' + vtkType + '()') cast[idx].SetInputConnection(clip[idx].GetOutputPort()) cast[idx].ClampOverflowOn() iso.append(vtk.vtkMarchingContourFilter()) iso[idx].SetInputConnection(cast[idx].GetOutputPort()) iso[idx].GenerateValues(1, 30, 30) mapper.append(vtk.vtkPolyDataMapper()) mapper[idx].SetInputConnection(iso[idx].GetOutputPort()) mapper[idx].ScalarVisibilityOff() actor.append(vtk.vtkActor()) actor[idx].SetMapper(mapper[idx]) # actor[idx].Actor.GetProperty().SetDiffuseColor(lindex.colors.c.lindex.colors.c+1.lindex.colors.c+1) actor[idx].GetProperty().SetDiffuseColor(colorWrapper.GetRGBColor(colors[c])) actor[idx].GetProperty().SetSpecularPower(30) actor[idx].GetProperty().SetDiffuse(.7) actor[idx].GetProperty().SetSpecular(.5) c += 1 ren.AddActor(actor[idx]) outline = vtk.vtkOutlineFilter() outline.SetInputConnection(slc.GetOutputPort()) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInputConnection(outline.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(outlineMapper) outlineActor.VisibilityOff() # Add the actors to the renderer, set the background and size # ren.AddActor(outlineActor) ren.SetBackground(0.9, .9, .9) ren.ResetCamera() ren.GetActiveCamera().SetViewAngle(30) ren.GetActiveCamera().Elevation(20) ren.GetActiveCamera().Azimuth(20) ren.GetActiveCamera().Zoom(1.5) ren.ResetCameraClippingRange() renWin.SetSize(400, 400) # render and interact with data iRen = vtk.vtkRenderWindowInteractor() iRen.SetRenderWindow(renWin); renWin.Render() img_file = "imageMCAll.png" vtk.test.Testing.compareImage(iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25) vtk.test.Testing.interact()
def createVisualization(self): if self.alreadyCall: return self.alreadyCall = True global renderer, renderWindow, renderWindowInteractor, reader, reader_Bones, reader_Blood, reader_Skin, isovalue, BonesMapper, BonesActor, BloodActor, BloodMapper, SkinActor, SkinMapper, volume, volumeMapper, ClippingPlane, ImagePlane, iss, ctf renderWindow = self.getView('-1') renderer = renderWindow.GetRenderers().GetFirstRenderer() # Read the volumetric image filename_vol = "CT.vtk" reader = vtk.vtkStructuredPointsReader() reader.SetFileName(filename_vol) reader.Update() # Read the meshes filename_mesh = "Bones.obj" reader_Bones = vtk.vtkOBJReader() reader_Bones.SetFileName(filename_mesh) reader_Bones.Update() filename_mesh = "Skin.obj" reader_Skin = vtk.vtkOBJReader() reader_Skin.SetFileName(filename_mesh) reader_Skin.Update() filename_mesh = "Blood.obj" reader_Blood = vtk.vtkOBJReader() reader_Blood.SetFileName(filename_mesh) reader_Blood.Update() # Shift and scale input data between 0 and 255 range = 255 a, b = reader.GetOutput().GetScalarRange() iss = vtk.vtkImageShiftScale() iss.SetInputData(reader.GetOutput()) iss.SetShift(-a) iss.SetScale(range / (b - a)) iss.SetOutputScalarTypeToUnsignedChar() # Volume mapper volumeMapper = vtk.vtkGPUVolumeRayCastMapper() volumeMapper.SetInputConnection(iss.GetOutputPort()) volumeMapper.SetBlendModeToIsoSurface() ####################### COLOR FUNCTION ####################### colorTransferFunction = vtk.vtkColorTransferFunction() #Background colorTransferFunction.AddRGBPoint(0.0, 0.0, 0.0, 0.0) #Lungs colorTransferFunction.AddRGBPoint(30.0, 0.9059, 0.6314, 0.6902) colorTransferFunction.AddRGBPoint(40.0, 0.9059, 0.6314, 0.6902) #General Tissue colorTransferFunction.AddRGBPoint(50, 1.0, 1.0, 0.0) colorTransferFunction.AddRGBPoint(60, 1.0, 1.0, 0.0) #Cardiac Tissue 1.0000 0.3882 0.2784 colorTransferFunction.AddRGBPoint(61.0, 1.0, 0.3882, 0.2784) colorTransferFunction.AddRGBPoint(75.0, 1.0, 0.3882, 0.2784) #Blood colorTransferFunction.AddRGBPoint(85, 1.0, 0.0, 0.0) colorTransferFunction.AddRGBPoint(105, 1.0, 0.0, 0.0) #Bones colorTransferFunction.AddRGBPoint(110, 1.0, 1.0, 1.0) ####################### OPACITY FUNCTION ####################### opacityTransferFunction_ct = vtk.vtkPiecewiseFunction() #Background opacityTransferFunction_ct.AddPoint(25.0, 0.0) #Lungs opacityTransferFunction_ct.AddPoint(30.0, 0.0) opacityTransferFunction_ct.AddPoint(40.0, 0.0) opacityTransferFunction_ct.AddPoint(40.1, 0.1) #General Tissue opacityTransferFunction_ct.AddPoint(50.0, 0.05) opacityTransferFunction_ct.AddPoint(64.0, 0.05) # Cardiac Tissue opacityTransferFunction_ct.AddPoint(65.0, 1) opacityTransferFunction_ct.AddPoint(75.0, 1) # Blood opacityTransferFunction_ct.AddPoint(85.0, 0.03) opacityTransferFunction_ct.AddPoint(100.0, 0.03) #Bones opacityTransferFunction_ct.AddPoint(110.0, 0.5) ####################### GRADIENT FUNCTION ####################### val_grad = 0 gradient_function_ct = vtk.vtkPiecewiseFunction() gradient_function_ct.AddPoint(val_grad, 1.0) ####################### VOLUME ####################### #Properties isovalue = 75.0 volumeProperty = vtk.vtkVolumeProperty() volumeProperty.GetIsoSurfaceValues().SetValue(0, isovalue) volumeProperty.SetColor(colorTransferFunction) volumeProperty.SetScalarOpacity(opacityTransferFunction_ct) volumeProperty.SetGradientOpacity(gradient_function_ct) volumeProperty.ShadeOn() volumeProperty.SetInterpolationTypeToLinear() #Volume volume = self.volume volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) volume.VisibilityOn() # Mesh Mappers and actors BonesMapper = vtk.vtkPolyDataMapper() BonesActor = vtk.vtkActor() BonesMapper.SetInputConnection(reader_Bones.GetOutputPort()) BonesActor.SetMapper(BonesMapper) BonesActor.GetProperty().SetColor(0.93, 0.92, 0.756) BonesActor.GetProperty().SetOpacity(0.9) BloodMapper = vtk.vtkPolyDataMapper() BloodActor = vtk.vtkActor() BloodMapper.SetInputConnection(reader_Blood.GetOutputPort()) BloodActor.SetMapper(BloodMapper) BloodActor.GetProperty().SetColor(1.0, 0, 0) SkinMapper = vtk.vtkPolyDataMapper() SkinActor = vtk.vtkActor() SkinMapper.SetInputConnection(reader_Skin.GetOutputPort()) SkinActor.SetMapper(SkinMapper) SkinActor.GetProperty().SetColor(1.0, 0.8, 0.8) SkinActor.GetProperty().SetOpacity(0.6) # Renderer & renderWindow renderer.AddVolume(volume) renderer.AddActor(BonesActor) renderer.AddActor(SkinActor) renderer.AddActor(BloodActor) # Clipping ImagePlane ClippingPlane = vtk.vtkPlane() ClippingPlane.SetNormal([1.0, 0.0, 0.0]) xmin, xmax, ymin, ymax, zmin, zmax = volume.GetBounds() ClippingPlane.SetOrigin((xmin + xmax) / 2, (ymin + ymax) / 2, (zmin + zmax) / 2) volumeMapper.AddClippingPlane(ClippingPlane) volume.Update() # Outline outlineData = vtk.vtkOutlineFilter() outlineData.SetInputConnection(reader.GetOutputPort()) mapOutline = vtk.vtkPolyDataMapper() mapOutline.SetInputConnection(outlineData.GetOutputPort()) outline = vtk.vtkActor() outline.SetMapper(mapOutline) outline.GetProperty().SetColor(1.0, 1.0, 0.0) renderer.AddActor(outline) # Cutter BonesMapper.AddClippingPlane(ClippingPlane) SkinMapper.AddClippingPlane(ClippingPlane) BloodMapper.AddClippingPlane(ClippingPlane) ####################### CREATE PLANES ####################### # Grayscale Colormap ctf = vtk.vtkLookupTable() ctf.SetTableRange(0, 1) ctf.SetHueRange(1.0, 1.0) ctf.SetSaturationRange(0.0, 0.0) ctf.SetValueRange(0, 1) ctf.Build() # Window Interactor renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) renderWindowInteractor.GetInteractorStyle( ).SetCurrentStyleToTrackballCamera() renderWindowInteractor.EnableRenderOff() # ImagePlane ImagePlane = vtk.vtkImagePlaneWidget() ImagePlane.SetInputConnection(iss.GetOutputPort()) ImagePlane.SetPlaneOrientationToXAxes() ImagePlane.SetLookupTable(ctf) ImagePlane.SetSlicePosition(int((ymax + ymin) / 2)) # ImagePlane.SetPicker(picker) ImagePlane.DisplayTextOn() ImagePlane.SetInteractor(renderWindowInteractor) ImagePlane.EnabledOn() ImagePlane.SetLeftButtonAction(1) ImagePlane.SetMiddleButtonAction(0) def ImagePlaneScript(obj, event): ClipPlaneOrigin = tuple( map(sum, zip(obj.GetOrigin(), tuple(-i for i in obj.GetNormal())))) ClippingPlane.SetOrigin(ClipPlaneOrigin) ClippingPlane.SetNormal(obj.GetNormal()) ImagePlane.AddObserver('InteractionEvent', ImagePlaneScript) ImagePlane.InteractionOn() # Renderer & render window renderer.ResetCamera() renderWindow.Render() return self.resetCamera()
def Main(): global isovalue, contours, planeSource1, planeSource2, planeSource3, plane1, plane2, plane3, clipper1, clipper2, clipper3, clipX, clipY, clipZ print "data: %s" % sys.argv[1] reader = vtk.vtkStructuredPointsReader() reader.SetFileName(sys.argv[1]) reader.Update() clipX = 0 clipY = 0 clipZ = 0 r = reader.GetOutput().GetScalarRange() datamin = r[0] datamax = r[1] isovalue = (datamax+datamin)/2.0 for i in range(2, len(sys.argv)): if sys.argv[i] == "--val": isovalue = float(sys.argv[i+1]) print "isovalue: %f"%isovalue if sys.argv[i] == "--clip": clipX = float(sys.argv[i+1]) clipY = float(sys.argv[i+2]) clipZ = float(sys.argv[i+3]) print "clip (%f,%f,%f)" %(clipX,clipY,clipZ) contours = vtk.vtkContourFilter() contours.SetInputConnection(reader.GetOutputPort()); contours.ComputeNormalsOn() contours.SetValue(0, isovalue) lut = vtk.vtkColorTransferFunction() lut.SetColorSpaceToHSV() lut.AddHSVPoint(datamin,0,1,1) dis = (datamax-datamin)/7 for i in range(0,8): lut.AddHSVPoint(datamin+dis*i,0.1*i,1,1) planeSource1 = vtk.vtkPlaneSource() planeSource1.SetNormal(1,0,0) planeSource1.SetOrigin(clipX,0,0) planeSource2 = vtk.vtkPlaneSource() planeSource2.SetNormal(0,1,0) planeSource2.SetOrigin(0,clipY,0) planeSource3 = vtk.vtkPlaneSource() planeSource3.SetNormal(0,0,1) planeSource3.SetOrigin(0,0,clipZ) plane1 = vtk.vtkPlane() plane1.SetNormal(planeSource1.GetNormal()) plane1.SetOrigin(planeSource1.GetOrigin()) clipper1 = vtk.vtkClipPolyData() clipper1.SetClipFunction(plane1) clipper1.SetInputConnection(contours.GetOutputPort()) clipper1.Update() plane2 = vtk.vtkPlane() plane2.SetNormal(planeSource2.GetNormal()) plane2.SetOrigin(planeSource2.GetOrigin()) clipper2 = vtk.vtkClipPolyData() clipper2.SetClipFunction(plane2) clipper2.SetInputConnection(clipper1.GetOutputPort()) clipper2.Update() plane3 = vtk.vtkPlane() plane3.SetNormal(planeSource3.GetNormal()) plane3.SetOrigin(planeSource3.GetOrigin()) clipper3 = vtk.vtkClipPolyData() clipper3.SetClipFunction(plane3) clipper3.SetInputConnection(clipper2.GetOutputPort()) clipper3.Update() clipperMapper = vtk.vtkPolyDataMapper() clipperMapper.SetLookupTable(lut) clipperMapper.SetInputConnection(clipper3.GetOutputPort()) colorBar = vtkScalarBarActor() colorBar.SetLookupTable(clipperMapper.GetLookupTable()) colorBar.SetTitle("isovalue") colorBar.SetNumberOfLabels(6) colorBar.SetLabelFormat("%4.0f") colorBar.SetPosition(0.9, 0.1) colorBar.SetWidth(0.1) colorBar.SetHeight(0.7) clipperActor=vtk.vtkActor() clipperActor.GetProperty().SetRepresentationToWireframe() clipperActor.SetMapper(clipperMapper) backFaces = vtk.vtkProperty() backFaces.SetSpecular(0) backFaces.SetDiffuse(0) backFaces.SetAmbient(0) backFaces.SetAmbientColor(1,0,0) clipperActor.SetBackfaceProperty(backFaces) ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) ren.AddActor(clipperActor) ren.AddActor(colorBar) ren.ResetCamera() ren.SetBackground(0.2,0.3,0.4) ren.ResetCameraClippingRange() renWin.SetSize(1200, 600) isovalueSlider = vtk.vtkSliderRepresentation2D() isovalueSlider.SetMinimumValue(datamin) isovalueSlider.SetMaximumValue(datamax) isovalueSlider.SetValue(isovalue) isovalueSlider.SetTitleText("isovalue") isovalueSlider.GetPoint1Coordinate().SetCoordinateSystemToNormalizedDisplay() isovalueSlider.GetPoint1Coordinate().SetValue(0.0, 0.4) isovalueSlider.GetPoint2Coordinate().SetCoordinateSystemToNormalizedDisplay() isovalueSlider.GetPoint2Coordinate().SetValue(0.2, 0.4) isovalueSlider.SetSliderLength(0.02) isovalueSlider.SetSliderWidth(0.03) isovalueSlider.SetEndCapLength(0.01) isovalueSlider.SetEndCapWidth(0.03) isovalueSlider.SetTubeWidth(0.005) isovalueSlider.SetLabelFormat("%3.0lf") isovalueSlider.SetTitleHeight(0.02) isovalueSlider.SetLabelHeight(0.02) SliderWidget1 = vtk.vtkSliderWidget() SliderWidget1.SetInteractor(iren) SliderWidget1.SetRepresentation(isovalueSlider) SliderWidget1.KeyPressActivationOff() SliderWidget1.SetAnimationModeToAnimate() SliderWidget1.SetEnabled(True) SliderWidget1.AddObserver("InteractionEvent", isovalueSliderHandler) clipXSlider = vtk.vtkSliderRepresentation2D() clipXSlider.SetMinimumValue(0) clipXSlider.SetMaximumValue(300) clipXSlider.SetValue(clipX) clipXSlider.SetTitleText("X") clipXSlider.GetPoint1Coordinate().SetCoordinateSystemToNormalizedDisplay() clipXSlider.GetPoint1Coordinate().SetValue(0.0, 0.3) clipXSlider.GetPoint2Coordinate().SetCoordinateSystemToNormalizedDisplay() clipXSlider.GetPoint2Coordinate().SetValue(0.2, 0.3) clipXSlider.SetSliderLength(0.02) clipXSlider.SetSliderWidth(0.03) clipXSlider.SetEndCapLength(0.01) clipXSlider.SetEndCapWidth(0.03) clipXSlider.SetTubeWidth(0.005) clipXSlider.SetLabelFormat("%1.2lf") clipXSlider.SetTitleHeight(0.02) clipXSlider.SetLabelHeight(0.02) SliderWidget2 = vtk.vtkSliderWidget() SliderWidget2.SetInteractor(iren) SliderWidget2.SetRepresentation(clipXSlider) SliderWidget2.KeyPressActivationOff() SliderWidget2.SetAnimationModeToAnimate() SliderWidget2.SetEnabled(True) SliderWidget2.AddObserver("InteractionEvent", clipXSliderHandler) clipYSlider = vtk.vtkSliderRepresentation2D() clipYSlider.SetMinimumValue(0) clipYSlider.SetMaximumValue(300) clipYSlider.SetValue(clipY) clipYSlider.SetTitleText("Y") clipYSlider.GetPoint1Coordinate().SetCoordinateSystemToNormalizedDisplay() clipYSlider.GetPoint1Coordinate().SetValue(0.0, 0.2) clipYSlider.GetPoint2Coordinate().SetCoordinateSystemToNormalizedDisplay() clipYSlider.GetPoint2Coordinate().SetValue(0.2, 0.2) clipYSlider.SetSliderLength(0.02) clipYSlider.SetSliderWidth(0.03) clipYSlider.SetEndCapLength(0.01) clipYSlider.SetEndCapWidth(0.03) clipYSlider.SetTubeWidth(0.005) clipYSlider.SetLabelFormat("%1.2lf") clipYSlider.SetTitleHeight(0.02) clipYSlider.SetLabelHeight(0.02) SliderWidget3 = vtk.vtkSliderWidget() SliderWidget3.SetInteractor(iren) SliderWidget3.SetRepresentation(clipYSlider) SliderWidget3.KeyPressActivationOff() SliderWidget3.SetAnimationModeToAnimate() SliderWidget3.SetEnabled(True) SliderWidget3.AddObserver("InteractionEvent", clipYSliderHandler) clipZSlider = vtk.vtkSliderRepresentation2D() clipZSlider.SetMinimumValue(0) clipZSlider.SetMaximumValue(300) clipZSlider.SetValue(clipZ) clipZSlider.SetTitleText("Z") clipZSlider.GetPoint1Coordinate().SetCoordinateSystemToNormalizedDisplay() clipZSlider.GetPoint1Coordinate().SetValue(0.0, 0.1) clipZSlider.GetPoint2Coordinate().SetCoordinateSystemToNormalizedDisplay() clipZSlider.GetPoint2Coordinate().SetValue(0.2, 0.1) clipZSlider.SetSliderLength(0.02) clipZSlider.SetSliderWidth(0.03) clipZSlider.SetEndCapLength(0.01) clipZSlider.SetEndCapWidth(0.03) clipZSlider.SetTubeWidth(0.005) clipZSlider.SetLabelFormat("%1.2lf") clipZSlider.SetTitleHeight(0.02) clipZSlider.SetLabelHeight(0.02) SliderWidget4 = vtk.vtkSliderWidget() SliderWidget4.SetInteractor(iren) SliderWidget4.SetRepresentation(clipZSlider) SliderWidget4.KeyPressActivationOff() SliderWidget4.SetAnimationModeToAnimate() SliderWidget4.SetEnabled(True) SliderWidget4.AddObserver("InteractionEvent", clipZSliderHandler) # Render iren.Initialize() renWin.Render() iren.Start()
def main(argv): if len(argv) < 2: print "usage: ",argv[0]," <data>" exit(1) data_fn = argv[1] data = None if data_fn.find('.vtk') != -1: reader = vtk.vtkStructuredPointsReader() reader.SetFileName(data_fn) reader.Update() data = reader.GetOutput() elif data_fn.find('.dcm') != -1: reader =vtk.vtkDICOMImageReader() reader.SetFileName(data_fn) reader.Update() data = reader.GetOutput() ptdata = data.GetPointData() scalars = ptdata.GetScalars() data_range = scalars.GetValueRange() print "data range:",data_range contourer = vtk.vtkContourFilter() if data_fn.find('body') != -1: contourer.GenerateValues(10,data_range[0],data_range[1]) #contourer.GenerateValues(5,data_range[0],data_range[1]) elif data_fn.find('brain') != -1: contourer.GenerateValues(10,data_range[0],data_range[1]) elif data_fn.find('artichoke') != -1: contourer.GenerateValues(50,data_range[0],data_range[1]) elif data_fn.find('watermelon') != -1: contourer.GenerateValues(20,data_range[0],data_range[1]) #contourer.GenerateValues(5,data_range[0],data_range[1]) else: contourer.GenerateValues(10,data_range[0],data_range[1]) #contourer.SetNumberOfContours(3) #contourer.SetValue(0, 100) #contourer.SetValue(1, 300) #contourer.SetValue(2, 400) contourer.SetInput(data) contourer.Update() mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(contourer.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.SetSize(700,700) renderWindow.AddRenderer(renderer) renderer.AddActor(actor) renderer.SetBackground(0.4,0.3,0.2) interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(renderWindow) renderWindow.Render() interactor.Start()
def main(): # vtkFlyingEdges3D was introduced in VTK >= 8.2 use_flying_edges = vtk_version_ok(8, 2, 0) colors = vtk.vtkNamedColors() colors.SetColor('SkinColor', [240, 184, 160, 255]) colors.SetColor('BackfaceColor', [255, 229, 200, 255]) colors.SetColor('BkgColor', [51, 77, 102, 255]) file_name, threshold, largest_surface = get_program_parameters() # Load data reader = vtk.vtkStructuredPointsReader() reader.SetFileName(file_name) # Create a 3D model using flying edges or marching cubes if use_flying_edges: try: mc = vtk.vtkFlyingEdges3D() except AttributeError: mc = vtk.vtkMarchingCubes() else: mc = vtk.vtkMarchingCubes() mc.SetInputConnection(reader.GetOutputPort()) mc.ComputeNormalsOn() mc.ComputeGradientsOn() mc.SetValue(0, threshold) # second value acts as threshold # To remain largest region confilter = vtk.vtkPolyDataConnectivityFilter() confilter.SetInputConnection(mc.GetOutputPort()) confilter.SetExtractionModeToLargestRegion() # Create a mapper mapper = vtk.vtkPolyDataMapper() if largest_surface: mapper.SetInputConnection(confilter.GetOutputPort()) else: mapper.SetInputConnection(mc.GetOutputPort()) mapper.ScalarVisibilityOff() # Visualize actor = vtk.vtkActor() actor.GetProperty().SetColor(colors.GetColor3d('SkinColor')) back_prop = vtk.vtkProperty() back_prop.SetDiffuseColor(colors.GetColor3d('BackfaceColor')) actor.SetBackfaceProperty(back_prop) actor.SetMapper(mapper) renderer = vtk.vtkRenderer() renderer.AddActor(actor) renderer.SetBackground(colors.GetColor3d('SlateGray')) renderer.GetActiveCamera().SetViewUp(0.0, 0.0, 1.0) renderer.GetActiveCamera().SetPosition(0.0, 1.0, 0.0) renderer.GetActiveCamera().SetFocalPoint(0.0, 0.0, 0.0) renderer.ResetCamera() renderer.GetActiveCamera().Azimuth(30.0) renderer.GetActiveCamera().Elevation(30.0) ren_win = vtk.vtkRenderWindow() ren_win.AddRenderer(renderer) ren_win.SetSize(640, 480) ren_win.SetWindowName('ExtractLargestIsosurface') iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(ren_win) ren_win.Render() iren.Initialize() iren.Start()
def read_files(loc): """ :rtype : vector """ dircont = sorted(glob.glob(loc + '/test*.vtk')) if len(dircont) == 0: print 'po de fichiers' print 'con' #quit() count = 0 for i in dircont: # reader = vtkRectilinearGridReader() reader = vtkStructuredPointsReader() reader.SetFileName(i) reader.ReadAllScalarsOn() reader.ReadAllVectorsOn() reader.Update() data = reader.GetOutput() dim = data.GetDimensions() nx = dim[0] #- 1 ny = dim[1] #- 1 nz = dim[2] #- 1 bounds = data.GetBounds() xmin = bounds[0] xmax = bounds[1] ymin = bounds[2] ymax = bounds[3] zmin = bounds[4] zmax = bounds[5] domain = np.array([xmin, xmax, ymin, ymax, zmin, zmax]) print 'file:', i print 'dim:', dim # arrowglyph = data.GetCellData().GetArray('internalMesh/U') arrowglyph = data.GetPointData().GetArray('U') # print data.GetCellData() vectU = vn.vtk_to_numpy(arrowglyph) # vectU[vectU < -20] = 'NaN' # if np.all(vectU) < np.array([1e-8,1e-8,1e-8])): if (count == 0): U = np.empty((nx, ny, nz, len(dim), len(dircont))) s = i = j = k = 0 for k in xrange(nz): for j in xrange(ny): for i in xrange(nx): U[i, j, k, :, count] = vectU[s] s += 1 count += 1 dt = 0.05 tphys = count * dt print 'tphys = ', tphys print 'Files read' print '<<<<<<<<<>>>>>>>>>>' return U, nx, ny, nz, dim, tphys, dt, domain
def Main(): global ren # Create the RenderWindow, Renderer and both Actors ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.SetMultiSamples(0) renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) iren.RemoveObservers('RightButtonPressEvent') iren.AddObserver('RightButtonPressEvent', print_camera_settings, 1.0) iren.AddObserver('RightButtonPressEvent', after_print_camera_settings, -1.0) print "data: %s %s" % (sys.argv[1], sys.argv[2]) cfdreader = vtk.vtkStructuredPointsReader() cfdreader.SetFileName(sys.argv[1]) # setup wing data wingReader = vtk.vtkUnstructuredGridReader() wingReader.SetFileName(sys.argv[2]) wingReader.Update() wingMapper = vtk.vtkDataSetMapper() wingMapper.SetInputConnection(wingReader.GetOutputPort()) wingActor = vtk.vtkActor() wingActor.SetMapper(wingMapper) wingActor.GetProperty().SetColor(.4, .4, .4) bRakesToActor = [True, True, True] bWingToActor = True datamin = 0 datamax = 230 lut = vtk.vtkColorTransferFunction() lut.SetColorSpaceToHSV() lut.AddHSVPoint(datamin, 0, 1, 1) dis = float(datamax - datamin) / 7 for i in range(0, 8): lut.AddHSVPoint(float(datamin + dis * i), 0.1 * i, 1, 1) colorBar = vtk.vtkScalarBarActor() colorBar.SetLookupTable(lut) colorBar.SetTitle("") colorBar.SetNumberOfLabels(6) colorBar.SetLabelFormat("%4.0f") colorBar.SetPosition(0.9, 0.1) colorBar.SetWidth(0.05) colorBar.SetHeight(0.4) ren.AddActor(colorBar) rakes = [vtk.vtkLineSource(), vtk.vtkLineSource(), vtk.vtkLineSource()] rakes[0].SetPoint1(-230, -230, 0) rakes[0].SetPoint2(230, 230, 0) rakes[0].SetResolution(50) rakes[1].SetPoint1(230, -230, 0) rakes[1].SetPoint2(-230, 230, 0) rakes[1].SetResolution(50) # rakes[2].SetPoint1(0, -200, 10) # rakes[2].SetPoint2(0, 200, 10) # rakes[2].SetResolution(50) for i in range(0, len(rakes)): rakeMapper = vtk.vtkPolyDataMapper() rakeMapper.SetInputConnection(rakes[i].GetOutputPort()) rakeActor = vtk.vtkActor() rakeActor.SetMapper(rakeMapper) integ = vtk.vtkRungeKutta4() streamLine = vtk.vtkStreamLine() streamLine.SetInputConnection(cfdreader.GetOutputPort()) streamLine.SetSourceConnection(rakes[i].GetOutputPort()) streamLine.SetMaximumPropagationTime(50) streamLine.SetIntegrationStepLength(.1) streamLine.SetStepLength(0.001) streamLine.SetIntegrationDirectionToForward() streamLine.SetIntegrator(integ) streamLine.SpeedScalarsOn() scalarSurface = vtk.vtkRuledSurfaceFilter() scalarSurface.SetInputConnection(streamLine.GetOutputPort()) scalarSurface.SetOffset(0) scalarSurface.SetOnRatio(0) # scalarSurface.PassLinesOn() scalarSurface.SetRuledModeToPointWalk() # scalarSurface.SetDistanceFactor(40) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(scalarSurface.GetOutputPort()) mapper.SetLookupTable(lut) mapper.SetScalarRange(cfdreader.GetOutput().GetScalarRange()) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetColor(0, 1, 0) actor.GetProperty().SetOpacity(0.5) if bRakesToActor[i]: ren.AddActor(actor) if bWingToActor: ren.AddActor(wingActor) ren.SetBackground(0, 0, 0) renWin.SetSize(1600, 900) ren.ResetCamera() ren.GetActiveCamera().SetClippingRange(417.55784439078775, 1491.5763714138557) ren.GetActiveCamera().SetFocalPoint(118.72183980792761, 0.00012969970703125, 36.469017028808594) ren.GetActiveCamera().SetPosition(680.0192576650034, 16.65944318371372, 790.5781258299678) ren.GetActiveCamera().SetViewUp(-0.802117714199773, -0.005112780752923929, 0.5971440630533839) # Render iren.Initialize() renWin.Render() iren.Start()
def __init__(self,dti): self.print_counter=11 ren = vtk.vtkRenderer() self.dti_reader = vtk.vtkStructuredPointsReader() self.dti_reader.SetFileName(dti) self.geo_Mapper=vtk.vtkPolyDataMapper() self.geo_Mapper.SetInputConnection(self.dti_reader.GetOutputPort()) #glyph actor #geo_actor = vtk.vtkActor() #geo_actor.SetMapper(geo_Mapper) #ren.AddActor(geo_actor) self.arrowColor = vtk.vtkColorTransferFunction() self.update_look_up_table() self.plane1=None for i in range(0,3): if i==0: x=126.0 y=0.0 z=0.0 if i==1: x=126.0 y=126.0 z=0.0 if i==2: x=0.0 y=0.0 z=69.0 plane_mapper=self.create_cut_acto_plane(x,y,z,i) ren.AddActor(self.create_glyph(plane_mapper)) #this is done #Add renderer to renderwindow and render self.renWin = vtk.vtkRenderWindow() self.renWin.AddRenderer(ren) self.renWin.SetSize(1920, 1080) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(self.renWin) iren.AddObserver('RightButtonPressEvent', self.capture_image, 1.0) """ #Slider 1 sliderRep1=vtk.vtkSliderWidget() sliderRep1.SetInteractor(iren) sliderRep1.SetRepresentation(self.create_color_slider("X-Position",0.02,0.15,0,220,65)) sliderRep1.SetEnabled(True) sliderRep1.AddObserver("InteractionEvent", self.change_iso) """ # Scalar Bar actor scalar_bar = vtk.vtkScalarBarActor() scalar_bar.SetOrientationToHorizontal() scalar_bar.SetLookupTable(self.arrowColor) scalar_bar.SetTitle("Color map") scalar_bar.SetLabelFormat("%5.2f") scalar_bar.SetMaximumHeightInPixels(300) scalar_bar.SetMaximumWidthInPixels(100) # Scalar Bar Widget scalar_bar_widget = vtk.vtkScalarBarWidget() scalar_bar_widget.SetInteractor(iren) scalar_bar_widget.SetScalarBarActor(scalar_bar) scalar_bar_widget.On() ren.SetBackground(0,0,0) self.renWin.Render() iren.Start()
def testimageMCAll(self): # Create the RenderWindow, Renderer and both Actors # ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) # create pipeline # slc = vtk.vtkStructuredPointsReader() slc.SetFileName(VTK_DATA_ROOT + "/Data/ironProt.vtk") colors = [ "flesh", "banana", "grey", "pink", "carrot", "gainsboro", "tomato", "gold", "thistle", "chocolate" ] types = [ "UnsignedChar", "Char", "Short", "UnsignedShort", "Int", "UnsignedInt", "Long", "UnsignedLong", "Float", "Double" ] i = 1 c = 0 clip = list() cast = list() iso = list() mapper = list() actor = list() colorWrapper = self.Colors() for idx, vtkType in enumerate(types): clip.append(vtk.vtkImageClip()) clip[idx].SetInputConnection(slc.GetOutputPort()) clip[idx].SetOutputWholeExtent(-1000, 1000, -1000, 1000, i, i + 5) i += 5 cast.append(vtk.vtkImageCast()) eval('cast[idx].SetOutputScalarTypeTo' + vtkType + '()') cast[idx].SetInputConnection(clip[idx].GetOutputPort()) cast[idx].ClampOverflowOn() iso.append(vtk.vtkMarchingContourFilter()) iso[idx].SetInputConnection(cast[idx].GetOutputPort()) iso[idx].GenerateValues(1, 30, 30) mapper.append(vtk.vtkPolyDataMapper()) mapper[idx].SetInputConnection(iso[idx].GetOutputPort()) mapper[idx].ScalarVisibilityOff() actor.append(vtk.vtkActor()) actor[idx].SetMapper(mapper[idx]) # actor[idx].Actor.GetProperty().SetDiffuseColor(lindex.colors.c.lindex.colors.c+1.lindex.colors.c+1) actor[idx].GetProperty().SetDiffuseColor( colorWrapper.GetRGBColor(colors[c])) actor[idx].GetProperty().SetSpecularPower(30) actor[idx].GetProperty().SetDiffuse(.7) actor[idx].GetProperty().SetSpecular(.5) c += 1 ren.AddActor(actor[idx]) outline = vtk.vtkOutlineFilter() outline.SetInputConnection(slc.GetOutputPort()) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInputConnection(outline.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(outlineMapper) outlineActor.VisibilityOff() # Add the actors to the renderer, set the background and size # ren.AddActor(outlineActor) ren.SetBackground(0.9, .9, .9) ren.ResetCamera() ren.GetActiveCamera().SetViewAngle(30) ren.GetActiveCamera().Elevation(20) ren.GetActiveCamera().Azimuth(20) ren.GetActiveCamera().Zoom(1.5) ren.ResetCameraClippingRange() renWin.SetSize(400, 400) # render and interact with data iRen = vtk.vtkRenderWindowInteractor() iRen.SetRenderWindow(renWin) renWin.Render() img_file = "imageMCAll.png" vtk.test.Testing.compareImage( iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25) vtk.test.Testing.interact()
def _read(self): reader = vtkStructuredPointsReader() reader.SetFileName(self.filename) reader.Update() self._image = reader.GetOutput()
def main(): dataFn1, dataFn2, textureFn = get_program_parameters() colors = vtk.vtkNamedColors() # Read the data. pl3d = vtk.vtkMultiBlockPLOT3DReader() pl3d.SetXYZFileName(dataFn1) pl3d.SetQFileName(dataFn2) pl3d.SetScalarFunctionNumber(100) pl3d.SetVectorFunctionNumber(202) pl3d.Update() output = pl3d.GetOutput().GetBlock(0) # Make the wall (floor). wall = vtk.vtkStructuredGridGeometryFilter() wall.SetInputData(output) wall.SetExtent(0, 100, 0, 0, 0, 100) wallMap = vtk.vtkPolyDataMapper() wallMap.SetInputConnection(wall.GetOutputPort()) wallMap.ScalarVisibilityOff() wallActor = vtk.vtkActor() wallActor.SetMapper(wallMap) wallActor.GetProperty().SetColor(colors.GetColor3d("PeachPuff")) # Make the fin (rear wall) fin = vtk.vtkStructuredGridGeometryFilter() fin.SetInputData(output) fin.SetExtent(0, 100, 0, 100, 0, 0) finMap = vtk.vtkPolyDataMapper() finMap.SetInputConnection(fin.GetOutputPort()) finMap.ScalarVisibilityOff() finActor = vtk.vtkActor() finActor.SetMapper(finMap) finActor.GetProperty().SetColor(colors.GetColor3d("DarkSlateGray")) # Get the texture. tmap = vtk.vtkStructuredPointsReader() tmap.SetFileName(textureFn) texture = vtk.vtkTexture() texture.SetInputConnection(tmap.GetOutputPort()) texture.InterpolateOff() texture.RepeatOff() # Create the rendering window, renderer, and interactive renderer. ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Make the planes to threshold and texture. plane = list() thresh = list() planeMap = list() planeActor = list() # Define the extents of planes that we will use. planeExtents = [[10, 10, 0, 100, 0, 100], [30, 30, 0, 100, 0, 100], [35, 35, 0, 100, 0, 100]] # Now set up the pipeline. for i in range(0, len(planeExtents)): plane.append(vtk.vtkStructuredGridGeometryFilter()) plane[i].SetInputData(output) plane[i].SetExtent(*planeExtents[i]) thresh.append(vtk.vtkThresholdTextureCoords()) thresh[i].SetInputConnection(plane[i].GetOutputPort()) thresh[i].SetInputConnection(plane[i].GetOutputPort()) # If you want an image similar to Fig 9-43(a) in the VTK textbook, # set thresh[i].ThresholdByUpper(1.5) for all planes. if i == 1: thresh[i].ThresholdByLower(1.5) elif i == 2: thresh[i].ThresholdBetween(1.5, 1.8) else: thresh[i].ThresholdByUpper(1.5) planeMap.append(vtk.vtkDataSetMapper()) planeMap[i].SetInputConnection(thresh[i].GetOutputPort()) planeMap[i].SetScalarRange(output.GetScalarRange()) planeActor.append(vtk.vtkActor()) planeActor[i].SetMapper(planeMap[i]) planeActor[i].SetTexture(texture) # The slight transparency gives a nice effect. planeActor[i].GetProperty().SetOpacity(0.999) ren.AddActor(planeActor[i]) # Get an outline of the data set for context. outline = vtk.vtkStructuredGridOutlineFilter() outline.SetInputData(output) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInputConnection(outline.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(outlineMapper) outlineProp = outlineActor.GetProperty() outlineProp.SetColor(colors.GetColor3d("Black")) # Add the remaining actors to the renderer, set the background and size. ren.AddActor(outlineActor) ren.AddActor(wallActor) ren.AddActor(finActor) ren.SetBackground(colors.GetColor3d("MistyRose")) renWin.SetSize(512, 512) cam = vtk.vtkCamera() cam.SetClippingRange(1.51176, 75.5879) cam.SetFocalPoint(2.33749, 2.96739, 3.61023) cam.SetPosition(10.8787, 5.27346, 15.8687) cam.SetViewAngle(30) cam.SetViewUp(-0.0610856, 0.987798, -0.143262) ren.SetActiveCamera(cam) iren.Initialize() iren.Start()
def Main(): global ren print "data: %s" % sys.argv[1] reader = vtk.vtkStructuredPointsReader() reader.SetFileName(sys.argv[1]) isosurfaces = [ [3413, 0.1, 0.2, 1, 0.4], [18090, 0.1, 0.6, 1, 0.6], [41983, 0.1, 0.9, 1, 0.9], ] ren = vtk.vtkRenderer() for surface in isosurfaces: lut = vtk.vtkColorTransferFunction() lut.SetColorSpaceToHSV() lut.AddHSVPoint(surface[0], surface[1], surface[2], surface[3]) contours = vtk.vtkContourFilter() contours.SetInputConnection(reader.GetOutputPort()) contours.ComputeNormalsOn() contours.SetValue(0, surface[0]) mapper = vtk.vtkDataSetMapper() mapper.SetInputConnection(contours.GetOutputPort()) mapper.SetLookupTable(lut) mapper.ImmediateModeRenderingOff() actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetOpacity(surface[4]) ren.AddActor(actor) renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) iren.RemoveObservers('RightButtonPressEvent') iren.AddObserver('RightButtonPressEvent', print_camera_settings, 1.0) iren.AddObserver('RightButtonPressEvent', after_print_camera_settings, -1.0) # for depth peeling ren.SetUseDepthPeeling(1) ren.SetMaximumNumberOfPeels(4) # default 4 ren.SetOcclusionRatio(0) # default 0 ren.ResetCamera() ren.SetBackground(0, 0, 0) ren.GetActiveCamera().SetViewUp(0.2320640509325283, 0.6216278154231228, 0.748147803149258) ren.GetActiveCamera().SetPosition(-86.30842917477719, -55.80182530081589, 297.63908735650085) ren.GetActiveCamera().SetFocalPoint(199.18608617782593, 149.5, 38.5) ren.GetActiveCamera().SetClippingRange(4.197001562269691, 982.4499004768599) # for depth peeling renWin.SetAlphaBitPlanes(1) renWin.SetMultiSamples(0) renWin.SetSize(1600, 900) # Render iren.Initialize() renWin.Render() iren.Start()
def read_file(filename): reader = vtk.vtkStructuredPointsReader() reader.SetFileName(filename) reader.Update() return reader
lut.RemovePoint(colorVar1) colorVar1 = pos lut.AddRGBPoint(colorVar1, 0, 0.25, 0.5) def vtkSliderCallback2(obj, event): sliderRepres2 = obj.GetRepresentation() pos = sliderRepres2.GetValue() global colorVar2 lut.RemovePoint(colorVar2) colorVar2 = pos lut.AddRGBPoint(colorVar2, 1, 1, 0.5) # Load bathymetry dataset bathymetryReader = vtk.vtkStructuredPointsReader() bathymetryReader.SetFileName(sys.argv[1]) colorVar1 = -4500 colorVar2 = 2000 # Setup color mapping lut = vtk.vtkColorTransferFunction() lut.SetColorSpaceToRGB() lut.AddRGBPoint(-9000, 0, 0, 0) lut.AddRGBPoint(colorVar1, 0, 0.25, 0.5) lut.AddRGBPoint(-1, 0, 1, 1) lut.AddRGBPoint(0, 0.25, 0.75, 0) lut.AddRGBPoint(colorVar2, 1, 1, 0.5) lut.AddRGBPoint(4000, 1, 1, 1)
def testContour3DAll(self): # On older Macs, 10 is too low. Due to what looks like a driver bug # spectral lighting behaves sort of weird and produces small differences threshold = 30 # Create the RenderWindow, Renderer and both Actors # ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) # create pipeline # slc = vtk.vtkStructuredPointsReader() slc.SetFileName(VTK_DATA_ROOT + "/Data/ironProt.vtk") actorColors = ["flesh", "banana", "grey", "pink", "carrot", "gainsboro", "tomato", "gold", "thistle", "chocolate"] types = ["UnsignedChar", "Char", "Short", "UnsignedShort", "Int", "UnsignedInt", "Long", "UnsignedLong", "Float", "Double"] i = 1 c = 0 clip = list() cast = list() iso = list() mapper = list() actor = list() colors = self.Colors() for idx, vtkType in enumerate(types): clip.append(vtk.vtkImageClip()) clip[idx].SetInputConnection(slc.GetOutputPort()) clip[idx].SetOutputWholeExtent(-1000, 1000, -1000, 1000, i, i + 5) i += 5 cast.append(vtk.vtkImageCast()) eval("cast[idx].SetOutputScalarTypeTo" + vtkType) cast[idx].SetInputConnection(clip[idx].GetOutputPort()) cast[idx].ClampOverflowOn() iso.append(vtk.vtkContourFilter()) iso[idx].SetInputConnection(cast[idx].GetOutputPort()) iso[idx].GenerateValues(1, 30, 30) iso[idx].ComputeScalarsOff() iso[idx].ComputeGradientsOff() mapper.append(vtk.vtkPolyDataMapper()) mapper[idx].SetInputConnection(iso[idx].GetOutputPort()) mapper[idx].ImmediateModeRenderingOn() actor.append(vtk.vtkActor()) actor[idx].SetMapper(mapper[idx]) eval('actor[idx].GetProperty().SetDiffuseColor(colors.GetRGBColor("' + actorColors[idx] + '"))') actor[idx].GetProperty().SetSpecularPower(30) actor[idx].GetProperty().SetDiffuse(.7) actor[idx].GetProperty().SetSpecular(.5) c += 3 ren.AddActor(actor[idx]) outline = vtk.vtkOutlineFilter() outline.SetInputConnection(slc.GetOutputPort()) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInputConnection(outline.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(outlineMapper) outlineActor.VisibilityOff() # Add the actors to the renderer, set the background and size # ren.AddActor(outlineActor) ren.SetBackground(0.9, .9, .9) ren.ResetCamera() ren.GetActiveCamera().SetViewAngle(30) ren.GetActiveCamera().Elevation(20) ren.GetActiveCamera().Azimuth(20) ren.GetActiveCamera().Zoom(1.5) ren.ResetCameraClippingRange() renWin.SetSize(400, 400) # render and interact with data iRen = vtk.vtkRenderWindowInteractor() iRen.SetRenderWindow(renWin); renWin.Render() img_file = "contour3DAll.png" vtk.test.Testing.compareImage(iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25) vtk.test.Testing.interact()
def streampoints(filename): reader = vtk.vtkStructuredPointsReader() reader.SetFileName(filename) reader.Update() outline=vtk.vtkOutlineFilter() outline.SetInputConnection(reader.GetOutputPort()) lineMapper = vtk.vtkDataSetMapper() lineMapper.SetInputConnection(outline.GetOutputPort()) lineActor = vtk.vtkActor() lineActor.SetMapper(lineMapper) pdata=vtk.vtkPolyData() points=vtk.vtkPoints() #Selecting source for Streamtracer ns=200 r=100 Z=25 for i in range(0, ns): a=(2*i*pi)/ns X=r*cos(a) Y=r*sin(a) # for Z in range(0,256): points.InsertNextPoint(float(X),float(Y),float(Z)) pdata.SetPoints(points) integ0 = vtk.vtkRungeKutta4() integ1 = vtk.vtkRungeKutta4() integ2 = vtk.vtkRungeKutta4() # Defining controller for vtkDistributedStreamTracer controller=vtk.vtkMPIController() Stream0 = vtk.vtkDistributedStreamTracer() #Stream0 = vtk.vtkStreamTracer() Stream0.SetInputConnection(reader.GetOutputPort()) Stream0.SetSource(line0.GetOutput()) #Stream0.SetSource(pdata) # Setting the parameters for Integration. Here you can change the integration parameters according to your desire. Stream0.SetMaximumPropagation(255) Stream0.SetController(controller) Stream0.SetInitialIntegrationStepUnitToCellLengthUnit() Stream0.SetMaximumIntegrationStep(2000) Stream0.SetInitialIntegrationStep(0.5) Stream0.SetIntegrator(integ0) Stream0.SetIntegrationDirectionToBoth() Stream0.Update() # Visualizing streamline as a tube.Here you can change the radius of the streamtube by changing the values of radius. streamTube0 = vtk.vtkTubeFilter() streamTube0.SetInputConnection(Stream0.GetOutputPort()) streamTube0.SetRadius(0.25) streamTube0.SetNumberOfSides(16) #streamTube0.SetVaryRadiusToVaryRadiusByVector() mapStreamTube0 = vtk.vtkPolyDataMapper() mapStreamTube0.SetInputConnection(streamTube0.GetOutputPort()) #mapStreamTube.SetScalarRange(reader.GetOutput()) streamTubeActor0 = vtk.vtkActor() streamTubeActor0.SetMapper(mapStreamTube0) streamTubeActor0.GetProperty().BackfaceCullingOn() streamTubeActor0.GetProperty().SetColor(0, 1, 1) Stream1 = vtk.vtkDistributedStreamTracer() #Stream0 = vtk.vtkStreamTracer() Stream1.SetInputConnection(reader.GetOutputPort()) Stream1.SetSource(line1.GetOutput()) #Stream0.SetSource(pdata) Stream1.SetMaximumPropagation(255) Stream1.SetController(controller) Stream1.SetInitialIntegrationStepUnitToCellLengthUnit() Stream1.SetMaximumIntegrationStep(2000) Stream1.SetInitialIntegrationStep(0.5) Stream1.SetIntegrator(integ1) Stream1.SetIntegrationDirectionToBoth() Stream1.Update() streamTube1= vtk.vtkTubeFilter() streamTube1.SetInputConnection(Stream0.GetOutputPort()) streamTube1.SetRadius(0.25) streamTube1.SetNumberOfSides(12) #streamTube1.SetVaryRadiusToVaryRadiusByVector() mapStreamTube1 = vtk.vtkPolyDataMapper() mapStreamTube1.SetInputConnection(streamTube1.GetOutputPort()) #mapStreamTube.SetScalarRange(reader.GetOutput()) streamTubeActor1 = vtk.vtkActor() streamTubeActor1.SetMapper(mapStreamTube1) streamTubeActor1.GetProperty().BackfaceCullingOn() streamTubeActor1.GetProperty().SetColor(0.5, 0.25, 1) #ren.AddActor(lineActor) Stream2 = vtk.vtkDistributedStreamTracer() #Stream0 = vtk.vtkStreamTracer() Stream2.SetInputConnection(reader.GetOutputPort()) Stream2.SetSource(line2.GetOutput()) #Stream2.SetSource(line1.GetOutput()) #Stream2.SetSource(line0.GetOutput()) #Stream0.SetSource(pdata) Stream2.SetMaximumPropagation(255) Stream2.SetController(controller) Stream2.SetInitialIntegrationStepUnitToCellLengthUnit() Stream2.SetMaximumIntegrationStep(2000) Stream2.SetInitialIntegrationStep(0.5) Stream2.SetIntegrator(integ2) Stream2.SetIntegrationDirectionToBoth() Stream2.Update() streamTube2= vtk.vtkTubeFilter() streamTube2.SetInputConnection(Stream0.GetOutputPort()) streamTube2.SetRadius(0.25) streamTube2.SetNumberOfSides(12) #streamTube2.SetVaryRadiusToVaryRadiusByVector() mapStreamTube2 = vtk.vtkPolyDataMapper() mapStreamTube2.SetInputConnection(streamTube2.GetOutputPort()) #mapStreamTube.SetScalarRange(reader.GetOutput()) streamTubeActor2 = vtk.vtkActor() streamTubeActor2.SetMapper(mapStreamTube2) streamTubeActor2.GetProperty().BackfaceCullingOn() streamTubeActor2.GetProperty().SetColor(0, .025, 0.125) # ren.AddActor(lineActor) # Adding the streanline to the actor for rendering ren.AddActor(streamTubeActor0) ren.AddActor(streamTubeActor1) #ren.AddActor(streamTubeActor2) renWin.Render() ren.ResetCamera() # Selecting renderer good position and focal point. Here You can change the camera positin for viewing a good image that you need. ren.GetActiveCamera().SetPosition(0, 1,0) ren.GetActiveCamera().SetFocalPoint(0,0,0) ren.GetActiveCamera().SetViewUp(0,0 , 1) ren.GetActiveCamera().Dolly(1.4) ren.ResetCameraClippingRange() largestreamline=vtk.vtkRenderLargeImage() largestreamline.SetInput(ren) largestreamline.SetMagnification(9) #cam1 = ren.GetActiveCamera().Zoom(z) #cam1 = ren.GetActiveCamera().Elevation(2) #cam1 = ren.GetActiveCamera().Azimuth(-5) #ren.SetActiveCamera(cam1) ren.ResetCamera() # Writing .PNG Images of the streamlines with images. writer = vtk.vtkPNGWriter() writer.SetInputConnection(largestreamline.GetOutputPort()) writer.SetFileName("Streamline.png") writer.Modified() writer.Write()
def main(): colors = vtk.vtkNamedColors() fileName = get_program_parameters() # hidden sphere sphere1 = vtk.vtkSphereSource() sphere1.SetRadius(0.5) innerMapper = vtk.vtkPolyDataMapper() innerMapper.SetInputConnection(sphere1.GetOutputPort()) innerSphere = vtk.vtkActor() innerSphere.SetMapper(innerMapper) innerSphere.GetProperty().SetColor(colors.GetColor3d('BlanchedAlmond')) # sphere to texture sphere2 = vtk.vtkSphereSource() sphere2.SetRadius(1.0) sphere2.SetPhiResolution(21) sphere2.SetThetaResolution(21) pts = [0.0] * 6 points = vtk.vtkPoints() points.SetNumberOfPoints(2) points.SetPoint(0, pts[:3]) points.SetPoint(1, pts[3:]) nrms = [0.0] * 6 nrms[0] = 1.0 nrms[4] = 1.0 normals = vtk.vtkDoubleArray() normals.SetNumberOfComponents(3) normals.SetNumberOfTuples(2) normals.SetTuple(0, nrms[:3]) normals.SetTuple(1, nrms[3:]) planes = vtk.vtkPlanes() planes.SetPoints(points) planes.SetNormals(normals) tcoords = vtk.vtkImplicitTextureCoords() tcoords.SetInputConnection(sphere2.GetOutputPort()) tcoords.SetRFunction(planes) outerMapper = vtk.vtkDataSetMapper() outerMapper.SetInputConnection(tcoords.GetOutputPort()) tmap = vtk.vtkStructuredPointsReader() tmap.SetFileName(fileName) texture = vtk.vtkTexture() texture.SetInputConnection(tmap.GetOutputPort()) texture.InterpolateOff() texture.RepeatOff() outerSphere = vtk.vtkActor() outerSphere.SetMapper(outerMapper) outerSphere.SetTexture(texture) outerSphere.GetProperty().SetColor(colors.GetColor3d('LightSalmon')) renWin = vtk.vtkRenderWindow() iren = vtk.vtkRenderWindowInteractor() aren = vtk.vtkRenderer() iren.SetRenderWindow(renWin) renWin.AddRenderer(aren) aren.AddActor(innerSphere) aren.AddActor(outerSphere) aren.SetBackground(colors.GetColor3d('SlateGray')) aren.GetActiveCamera().Azimuth(-30) aren.GetActiveCamera().Elevation(-30) aren.ResetCamera() renWin.SetSize(500, 500) renWin.SetWindowName('TextureCutSphere') # interact with data renWin.Render() iren.Initialize() iren.Start()
def __init__(self,dti): self.print_counter=0 ren = vtk.vtkRenderer() self.dti_reader = vtk.vtkStructuredPointsReader() self.dti_reader.SetFileName(dti) """ self.geo_Mapper=vtk.vtkPolyDataMapper() self.geo_Mapper.SetInputConnection(self.dti_reader.GetOutputPort()) """ tensor_extractor = vtk.vtkExtractTensorComponents() tensor_extractor.SetInputConnection(self.dti_reader.GetOutputPort()) tensor_extractor.ExtractScalarsOn() tensor_extractor.Update() self.dti_reader.GetOutput().GetPointData().SetScalars(tensor_extractor.GetOutput().GetPointData().GetScalars()) self.dti_reader.Update() self.arrowColor = vtk.vtkColorTransferFunction() self.update_look_up_table() #------------NEW CODE BEGINS HERE---------- [xposc, yposc, zposc] = self.dti_reader.GetOutput().GetCenter() for k in range(20, 30,2): for i in range(10, 20): ren.AddActor(self.create_hyper_stream_line(xposc+i, yposc+k, zposc)) #------------NEW CODE ENDS HERE------------ #Add renderer to renderwindow and render self.renWin = vtk.vtkRenderWindow() self.renWin.AddRenderer(ren) self.renWin.SetSize(1920, 1080) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(self.renWin) iren.AddObserver('RightButtonPressEvent', self.capture_image, 1.0) # Scalar Bar actor scalar_bar = vtk.vtkScalarBarActor() scalar_bar.SetOrientationToHorizontal() scalar_bar.SetLookupTable(self.arrowColor) scalar_bar.SetTitle("Color map") scalar_bar.SetLabelFormat("%5.5f") scalar_bar.SetMaximumHeightInPixels(300) scalar_bar.SetMaximumWidthInPixels(100) # Scalar Bar Widget scalar_bar_widget = vtk.vtkScalarBarWidget() scalar_bar_widget.SetInteractor(iren) scalar_bar_widget.SetScalarBarActor(scalar_bar) scalar_bar_widget.On() ren.SetBackground(0,0,0) self.renWin.Render() iren.Start()
def loadStructuredPoints(filename): """Load a ``vtkStructuredPoints`` object from file.""" reader = vtk.vtkStructuredPointsReader() reader.SetFileName(filename) reader.Update() return reader.GetOutput()
def main(): colors = vtk.vtkNamedColors() textureFile, motorFile = get_program_parameters() # Create the Renderer, RenderWindow and RenderWindowInteractor. ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Create the cutting planes. planes = vtk.vtkPlanes() points = vtk.vtkPoints() norms = vtk.vtkFloatArray() norms.SetNumberOfComponents(3) points.InsertPoint(0, 0.0, 0.0, 0.0) norms.InsertTuple3(0, 0.0, 0.0, 1.0) points.InsertPoint(1, 0.0, 0.0, 0.0) norms.InsertTuple3(1, -1.0, 0.0, 0.0) planes.SetPoints(points) planes.SetNormals(norms) # Get the texture. texReader = vtk.vtkStructuredPointsReader() texReader.SetFileName(textureFile) texture = vtk.vtkTexture() texture.SetInputConnection(texReader.GetOutputPort()) texture.InterpolateOff() texture.RepeatOff() # Set up the pipelines for the parts of the motor. # We will use lists of pipeline objects. numberOfParts = 5 byu = list() normals = list() tex = list() byuMapper = list() byuActor = list() partColours = [ 'cold_grey', 'peacock', 'raw_sienna', 'banana', 'peach_puff' ] # Use this to control which parts to display. displayParts = [True] * numberOfParts # If displayParts[2] = False then an image like that in the VTK tests is produced. # Build the pipelines. for i in range(0, numberOfParts): byu.append(vtk.vtkBYUReader()) byu[i].SetGeometryFileName(motorFile) byu[i].SetPartNumber(i + 1) normals.append(vtk.vtkPolyDataNormals()) normals[i].SetInputConnection(byu[i].GetOutputPort()) tex.append(vtk.vtkImplicitTextureCoords()) tex[i].SetInputConnection(normals[i].GetOutputPort()) tex[i].SetRFunction(planes) # tex[i].FlipTextureOn() byuMapper.append(vtk.vtkDataSetMapper()) byuMapper[i].SetInputConnection(tex[i].GetOutputPort()) byuActor.append(vtk.vtkActor()) byuActor[i].SetMapper(byuMapper[i]) byuActor[i].SetTexture(texture) byuActor[i].GetProperty().SetColor(colors.GetColor3d(partColours[i])) ren.AddActor(byuActor[i]) if displayParts[i]: byuActor[i].VisibilityOn() else: byuActor[i].VisibilityOff() ren.SetBackground(colors.GetColor3d('AliceBlue')) renWin.SetSize(512, 512) renWin.SetWindowName('Motor') camera = vtk.vtkCamera() camera.SetFocalPoint(0.0286334, 0.0362996, 0.0379685) camera.SetPosition(1.37067, 1.08629, -1.30349) camera.SetViewAngle(17.673) camera.SetClippingRange(1, 10) camera.SetViewUp(-0.376306, -0.5085, -0.774482) ren.SetActiveCamera(camera) # Render the image. iren.Initialize() iren.Start()
def Main(): global vmin, vmax, w_value, datamin, datamax, lut, SliderRepres1, SliderRepres2, SliderRepres3 # Load bathymetry dataset bathymetryReader = vtk.vtkStructuredPointsReader() bathymetryReader.SetFileName(sys.argv[1]) bathymetryReader.Update() r = bathymetryReader.GetOutput().GetPointData().GetScalars().GetRange() datamin = r[0] datamax = r[1] vmin = datamin + (datamax-datamin)*0.4 vmax = datamin + (datamax-datamin)*0.6 w_value = (datamax-datamin)/20 # Setup color mapping lut = vtk.vtkColorTransferFunction() lut.SetColorSpaceToHSV() # Load bathymetry data into Geometry Filter geometry = vtk.vtkImageDataGeometryFilter() geometry.SetInputConnection(bathymetryReader.GetOutputPort()) mapper = vtk.vtkDataSetMapper() mapper.SetInputConnection(geometry.GetOutputPort()) mapper.SetLookupTable(lut) mapper.ImmediateModeRenderingOff() # Setup color mapping bar colorBar = vtkScalarBarActor() colorBar.SetLookupTable(mapper.GetLookupTable()) colorBar.SetTitle("color map") colorBar.SetNumberOfLabels(6) colorBar.SetLabelFormat("%4.0f") colorBar.SetPosition(0.9, 0.1) colorBar.SetWidth(0.1) colorBar.SetHeight(0.7) actor = vtk.vtkActor() actor.SetMapper(mapper) # Create renderer stuff ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() # Specify interaction with 2D image style = vtk.vtkInteractorStyleImage() style.SetInteractionModeToImage2D() iren.SetInteractorStyle(style) iren.SetRenderWindow(renWin) # Add the actors to the renderer, set the background and size ren.AddActor(actor) ren.AddActor(colorBar) ren.ResetCamera() ren.SetBackground(0, 0, 0) ren.ResetCameraClippingRange() renWin.SetSize(1280, 800) # Add vtkSliderWidget SliderRepres1 = vtk.vtkSliderRepresentation2D() min = datamin+1 max = datamax-2 SliderRepres1.SetMinimumValue(min) SliderRepres1.SetMaximumValue(max) SliderRepres1.SetTitleText("vmin") SliderRepres1.GetPoint1Coordinate().SetCoordinateSystemToNormalizedDisplay() SliderRepres1.GetPoint1Coordinate().SetValue(0.1, 0.1) SliderRepres1.GetPoint2Coordinate().SetCoordinateSystemToNormalizedDisplay() SliderRepres1.GetPoint2Coordinate().SetValue(0.3, 0.1) SliderRepres1.SetSliderLength(0.02) SliderRepres1.SetSliderWidth(0.03) SliderRepres1.SetEndCapLength(0.01) SliderRepres1.SetEndCapWidth(0.03) SliderRepres1.SetTubeWidth(0.005) SliderRepres1.SetLabelFormat("%3.0lf") SliderRepres1.SetTitleHeight(0.02) SliderRepres1.SetLabelHeight(0.02) SliderWidget1 = vtk.vtkSliderWidget() SliderWidget1.SetInteractor(iren) SliderWidget1.SetRepresentation(SliderRepres1) SliderWidget1.KeyPressActivationOff() SliderWidget1.SetAnimationModeToAnimate() SliderWidget1.SetEnabled(True) SliderWidget1.AddObserver("InteractionEvent", vminSliderHandler) # Add vtkSliderWidget SliderRepres2 = vtk.vtkSliderRepresentation2D() min = datamin+2 max = datamax-1 SliderRepres2.SetMinimumValue(min) SliderRepres2.SetMaximumValue(max) SliderRepres2.SetTitleText("vmax") SliderRepres2.GetPoint1Coordinate().SetCoordinateSystemToNormalizedDisplay() SliderRepres2.GetPoint1Coordinate().SetValue(0.4, 0.1) SliderRepres2.GetPoint2Coordinate().SetCoordinateSystemToNormalizedDisplay() SliderRepres2.GetPoint2Coordinate().SetValue(0.6, 0.1) SliderRepres2.SetSliderLength(0.02) SliderRepres2.SetSliderWidth(0.03) SliderRepres2.SetEndCapLength(0.01) SliderRepres2.SetEndCapWidth(0.03) SliderRepres2.SetTubeWidth(0.005) SliderRepres2.SetLabelFormat("%3.0lf") SliderRepres2.SetTitleHeight(0.02) SliderRepres2.SetLabelHeight(0.02) SliderWidget2 = vtk.vtkSliderWidget() SliderWidget2.SetInteractor(iren) SliderWidget2.SetRepresentation(SliderRepres2) SliderWidget2.KeyPressActivationOff() SliderWidget2.SetAnimationModeToAnimate() SliderWidget2.SetEnabled(True) SliderWidget2.AddObserver("InteractionEvent", vmaxSliderHandler) # Add vtkSliderWidget SliderRepres3 = vtk.vtkSliderRepresentation2D() min = 1 max = (datamax-datamin)/10 SliderRepres3.SetMinimumValue(min) SliderRepres3.SetMaximumValue(max) SliderRepres3.SetTitleText("w") SliderRepres3.GetPoint1Coordinate().SetCoordinateSystemToNormalizedDisplay() SliderRepres3.GetPoint1Coordinate().SetValue(0.7, 0.1) SliderRepres3.GetPoint2Coordinate().SetCoordinateSystemToNormalizedDisplay() SliderRepres3.GetPoint2Coordinate().SetValue(0.9, 0.1) SliderRepres3.SetSliderLength(0.02) SliderRepres3.SetSliderWidth(0.03) SliderRepres3.SetEndCapLength(0.01) SliderRepres3.SetEndCapWidth(0.03) SliderRepres3.SetTubeWidth(0.005) SliderRepres3.SetLabelFormat("%3.0lf") SliderRepres3.SetTitleHeight(0.02) SliderRepres3.SetLabelHeight(0.02) SliderWidget3 = vtk.vtkSliderWidget() SliderWidget3.SetInteractor(iren) SliderWidget3.SetRepresentation(SliderRepres3) SliderWidget3.KeyPressActivationOff() SliderWidget3.SetAnimationModeToAnimate() SliderWidget3.SetEnabled(True) SliderWidget3.AddObserver("InteractionEvent", wSliderHandler) updateUI() iren.Initialize() renWin.Render() iren.Start()
def __init__(self, filename, renderer): self.renderer = renderer reader = vtk.vtkStructuredPointsReader() #reader.SetFileName('/home/mcc/src/devel/extract_mri_slices/braintest2.vtk') reader.SetFileName(filename) # we want to move this from its (.87 .92 .43) esque position to something more like 'the center' # how to do this?!? # ALTERNATIVELY: we want to use vtkInteractorStyleTrackballActor # somewhere instead of the interactor controlling the main window and 3 planes imagedata = reader.GetOutput() #reader.SetFileName(filename) cf = vtk.vtkContourFilter() cf.SetInput(imagedata) # ??? cf.SetValue(0, 1) deci = vtk.vtkDecimatePro() deci.SetInput(cf.GetOutput()) deci.SetTargetReduction(.1) deci.PreserveTopologyOn() smoother = vtk.vtkSmoothPolyDataFilter() smoother.SetInput(deci.GetOutput()) smoother.SetNumberOfIterations(100) # XXX try to call SetScale directly on actor.. #self.scaleTransform = vtk.vtkTransform() #self.scaleTransform.Identity() #self.scaleTransform.Scale(.1, .1, .1) #transformFilter = vtk.vtkTransformPolyDataFilter() #transformFilter.SetTransform(self.scaleTransform) #transformFilter.SetInput(smoother.GetOutput()) #cf.SetValue(1, 2) #cf.SetValue(2, 3) #cf.GenerateValues(0, -1.0, 1.0) #deci = vtk.vtkDecimatePro() #deci.SetInput(cf.GetOutput()) #deci.SetTargetReduction(0.8) # decimate_value normals = vtk.vtkPolyDataNormals() #normals.SetInput(transformFilter.GetOutput()) normals.SetInput(smoother.GetOutput()) normals.FlipNormalsOn() """ tags = vtk.vtkFloatArray() tags.InsertNextValue(1.0) tags.InsertNextValue(0.5) tags.InsertNextValue(0.7) tags.SetName("tag") """ lut = vtk.vtkLookupTable() lut.SetHueRange(0, 0) lut.SetSaturationRange(0, 0) lut.SetValueRange(0.2, 0.55) contourMapper = vtk.vtkPolyDataMapper() contourMapper.SetInput(normals.GetOutput()) contourMapper.SetLookupTable(lut) ###contourMapper.SetColorModeToMapScalars() ###contourMapper.SelectColorArray("tag") self.contours = vtk.vtkActor() self.contours.SetMapper(contourMapper) #if (do_wireframe): #self.contours.GetProperty().SetRepresentationToWireframe() #elif (do_surface): self.contours.GetProperty().SetRepresentationToSurface() self.contours.GetProperty().SetInterpolationToGouraud() self.contours.GetProperty().SetOpacity(1.0) self.contours.GetProperty().SetAmbient(0.1) self.contours.GetProperty().SetDiffuse(0.1) self.contours.GetProperty().SetSpecular(0.1) self.contours.GetProperty().SetSpecularPower(0.1) # XXX arbitrarily setting scale to this #self.contours.SetScale(.1, .1,.1) renderer.AddActor(self.contours) # XXX: mcc will this work?!? print "PlaneWidgetsXYZ.set_image_data: setting EventHandler.set_vtkactor(self.contours)!" EventHandler().set_vtkactor(self.contours)
def Main(): global ren print "data: %s" % sys.argv[1] reader = vtk.vtkStructuredPointsReader() reader.SetFileName(sys.argv[1]) isosurfaces = [ [500,0.1,0.3,1,0.3], [1158,0.1,0.6,1,0.5], [2750,0.1,1,1,1] ] ren = vtk.vtkRenderer() for surface in isosurfaces: lut = vtk.vtkColorTransferFunction() lut.SetColorSpaceToHSV() lut.AddHSVPoint(surface[0],surface[1],surface[2],surface[3]) contours = vtk.vtkContourFilter() contours.SetInputConnection(reader.GetOutputPort()); contours.ComputeNormalsOn() contours.SetValue(0, surface[0]) mapper = vtk.vtkDataSetMapper() mapper.SetInputConnection(contours.GetOutputPort()) mapper.SetLookupTable(lut) mapper.ImmediateModeRenderingOff() actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetOpacity(surface[4]) ren.AddActor(actor) renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) iren.RemoveObservers('RightButtonPressEvent') iren.AddObserver('RightButtonPressEvent', print_camera_settings, 1.0) iren.AddObserver('RightButtonPressEvent', after_print_camera_settings, -1.0) # for depth peeling ren.SetUseDepthPeeling(1) ren.SetMaximumNumberOfPeels(4) # default 4 ren.SetOcclusionRatio(0) # default 0 ren.ResetCamera() ren.SetBackground(0,0,0) ren.ResetCameraClippingRange() ren.GetActiveCamera().SetViewUp(-0.033792287793636924, 0.000854723562570334, -0.9994285120674231) ren.GetActiveCamera().SetPosition(-308.155681140229, -119.92183136577268, 117.3094068139949 ) ren.GetActiveCamera().SetFocalPoint(91.14654767513275, 104.1683804243803, 104.0) ren.GetActiveCamera().SetClippingRange(191.00826351112892, 795.369621458024) # for depth peeling renWin.SetAlphaBitPlanes(1) renWin.SetMultiSamples(0) renWin.SetSize(1600, 900) # Render iren.Initialize() renWin.Render() iren.Start()
def main(): fileName = get_program_parameters() colors = vtk.vtkNamedColors() # This is a simple volume rendering example that # uses a vtkFixedPointVolumeRayCastMapper # Create the standard renderer, render window # and interactor. ren1 = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Create the reader for the data. reader = vtk.vtkStructuredPointsReader() reader.SetFileName(fileName) # Create transfer mapping scalar value to opacity. opacityTransferFunction = vtk.vtkPiecewiseFunction() opacityTransferFunction.AddPoint(20, 0.0) opacityTransferFunction.AddPoint(255, 0.2) # Create transfer mapping scalar value to color. colorTransferFunction = vtk.vtkColorTransferFunction() colorTransferFunction.AddRGBPoint(0.0, 0.0, 0.0, 0.0) colorTransferFunction.AddRGBPoint(64.0, 1.0, 0.0, 0.0) colorTransferFunction.AddRGBPoint(128.0, 0.0, 0.0, 1.0) colorTransferFunction.AddRGBPoint(192.0, 0.0, 1.0, 0.0) colorTransferFunction.AddRGBPoint(255.0, 0.0, 0.2, 0.0) # The property describes how the data will look. volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(colorTransferFunction) volumeProperty.SetScalarOpacity(opacityTransferFunction) volumeProperty.ShadeOn() volumeProperty.SetInterpolationTypeToLinear() # The mapper / ray cast function know how to render the data. volumeMapper = vtk.vtkFixedPointVolumeRayCastMapper() volumeMapper.SetInputConnection(reader.GetOutputPort()) # The volume holds the mapper and the property and # can be used to position/orient the volume. volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) ren1.AddVolume(volume) ren1.SetBackground(colors.GetColor3d('Wheat')) ren1.GetActiveCamera().Azimuth(45) ren1.GetActiveCamera().Elevation(30) ren1.ResetCameraClippingRange() ren1.ResetCamera() renWin.SetSize(600, 600) renWin.SetWindowName('SimpleRayCast') renWin.Render() iren.Start()
def main(vector_file, magnitude_file): num_critical_points = 6 CriticalPoints = vtk.vtkPoints() CriticalPoints.InsertNextPoint(35, 14, 20) CriticalPoints.InsertNextPoint(55, 15, 20) CriticalPoints.InsertNextPoint(65, 45, 19) CriticalPoints.InsertNextPoint(45, 44.8, 20) CriticalPoints.InsertNextPoint(20, 29.7, 19.8) CriticalPoints.InsertNextPoint(10, 32.2, 16.1) ColorRange = vtk.vtkLookupTable() ColorRange.SetTableRange(0, 1) ColorRange.SetHueRange(0, 1) ColorRange.SetSaturationRange(1, 1) ColorRange.SetAlphaRange(0.3, 0.5) ColorRange.Build() reader = vtk.vtkStructuredPointsReader() reader.SetFileName(vector_file) reader.Update() mags = reader.GetOutput() range1 = mags.GetScalarRange() v0 = range1[0] v1 = range1[1] reader_magnitude = vtk.vtkStructuredPointsReader() reader_magnitude.SetFileName(magnitude_file) reader_magnitude.Update() # All entities initialized equal to number of critical points sphere1, stream1, scalarSurface1, tube1, dataMapper1, dataActor1, criticalMarker1, criticalMapper1, criticalActor1, probe1, mask1, glyph1, glyphMapper1, glyphActor1, plane1 = ( [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], ) for i in range(0, num_critical_points): sphere1.append(vtk.vtkSphereSource()) stream1.append(vtk.vtkStreamLine()) scalarSurface1.append(vtk.vtkRuledSurfaceFilter()) tube1.append(vtk.vtkTubeFilter()) dataMapper1.append(vtk.vtkPolyDataMapper()) dataActor1.append(vtk.vtkActor()) criticalMarker1.append(vtk.vtkSphereSource()) criticalMapper1.append(vtk.vtkPolyDataMapper()) criticalActor1.append(vtk.vtkActor()) probe1.append(vtk.vtkProbeFilter()) mask1.append(vtk.vtkMaskPoints()) glyph1.append(vtk.vtkGlyph3D()) glyphMapper1.append(vtk.vtkPolyDataMapper()) glyphActor1.append(vtk.vtkActor()) plane1.append(vtk.vtkPlaneSource()) integ = vtk.vtkRungeKutta4() cone = vtk.vtkConeSource() cone.SetResolution(8) cone.SetHeight(1.0) cone.SetRadius(0.2) transform = vtk.vtkTransform() transform.Translate(0, 0, 0) transformFilter = vtk.vtkTransformPolyDataFilter() transformFilter.SetInput(cone.GetOutput()) transformFilter.SetTransform(transform) outline = vtk.vtkOutlineFilter() outline.SetInput(reader.GetOutput()) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInput(outline.GetOutput()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(outlineMapper) outlineActor.GetProperty().SetColor(1, 1, 1) bar = vtk.vtkScalarBarActor() bar.SetLookupTable(ColorRange) renderer = vtk.vtkRenderer() for i in range(0, num_critical_points): sphere1[i].SetRadius(2) sphere1[i].SetCenter( CriticalPoints.GetPoint(i)[0], CriticalPoints.GetPoint(i)[1], CriticalPoints.GetPoint(i)[2] ) sphere1[i].SetThetaResolution(1) stream1[i].SetInput(reader.GetOutput()) stream1[i].SetSource(sphere1[i].GetOutput()) stream1[i].SetIntegrator(integ) stream1[i].SetMaximumPropagationTime(500) stream1[i].SetIntegrationStepLength(0.1) stream1[i].SetIntegrationDirectionToIntegrateBothDirections() stream1[i].SetStepLength(0.1) scalarSurface1[i].SetInput(stream1[i].GetOutput()) scalarSurface1[i].SetOffset(0) scalarSurface1[i].SetOnRatio(2) scalarSurface1[i].PassLinesOn() scalarSurface1[i].SetRuledModeToPointWalk() scalarSurface1[i].SetDistanceFactor(50) tube1[i].SetInput(scalarSurface1[i].GetOutput()) tube1[i].SetRadius(0.1) tube1[i].SetNumberOfSides(6) dataMapper1[i].SetInput(tube1[i].GetOutput()) dataMapper1[i].SetScalarRange(v0, v1) dataMapper1[i].SetLookupTable(ColorRange) dataActor1[i].SetMapper(dataMapper1[i]) # renderer.AddActor(dataActor1[i]) criticalMarker1[i].SetRadius(1.0) criticalMarker1[i].SetCenter( CriticalPoints.GetPoint(i)[0], CriticalPoints.GetPoint(i)[1], CriticalPoints.GetPoint(i)[2] ) criticalMarker1[i].SetThetaResolution(10) criticalMapper1[i].SetInput(criticalMarker1[i].GetOutput()) criticalActor1[i].SetMapper(criticalMapper1[i]) criticalActor1[i].GetProperty().SetColor(1, 1, 0) criticalActor1[i].GetProperty().SetOpacity(0.5) # renderer.AddActor(criticalActor1[i]) probe1[i].SetInput(stream1[i].GetOutput()) probe1[i].SetSource(reader.GetOutput()) mask1[i].SetInput(probe1[i].GetOutput()) mask1[i].SetOnRatio(60) mask1[i].RandomModeOn() glyph1[i].SetInput(mask1[i].GetOutput()) glyph1[i].SetSource(transformFilter.GetOutput()) glyph1[i].SetScaleModeToScaleByVector() glyph1[i].SetScaleFactor(2) glyph1[i].SetVectorModeToUseVector() glyph1[i].SetColorModeToColorByVector() glyphMapper1[i].SetInput(glyph1[i].GetOutput()) glyphMapper1[i].SetLookupTable(ColorRange) glyphActor1[i].SetMapper(glyphMapper1[i]) # renderer.AddActor(glyphActor1[i]) # removeActors1(renderer, dataActor, criticalActor, glyphActor, dataActor1, criticalActor1, glyphActor1) mags = reader.GetOutput() bounds = mags.GetBounds() x0 = bounds[0] x1 = bounds[1] y0 = bounds[2] y1 = bounds[3] z0 = bounds[4] z1 = bounds[5] range1 = mags.GetScalarRange() v0 = range1[0] v1 = range1[1] plane1[0].SetOrigin(x0, y0, z0) plane1[0].SetPoint1(x0, y1, z0) plane1[0].SetPoint2(x0, y0, z1) plane1[1].SetOrigin(x0, y0, z0) plane1[1].SetPoint1(x0, y1, z0) plane1[1].SetPoint2(x1, y0, z0) plane1[2].SetOrigin(x0, y0, z0) plane1[2].SetPoint1(x0, y0, z1) plane1[2].SetPoint2(x1, y0, z0) plane1[3].SetOrigin(x1, y1, z1) plane1[3].SetPoint1(x1, y1, z0) plane1[3].SetPoint2(x1, y0, z1) plane1[4].SetOrigin(x1, y1, z1) plane1[4].SetPoint1(x0, y1, z1) plane1[4].SetPoint2(x1, y1, z0) plane1[5].SetOrigin(x1, y1, z1) plane1[5].SetPoint1(x0, y1, z1) plane1[5].SetPoint2(x1, y1, z0) for i in range(0, num_critical_points): plane1[i].SetResolution(5, 5) stream1[i].SetSource(plane1[i].GetOutput()) renderer.AddActor(dataActor1[i]) renderer.AddActor(glyphActor1[i]) glyph1[i].SetScaleFactor(4) renderer.AddActor(bar) renderer.AddActor(outlineActor) for i in range(0, num_critical_points): renderer.AddActor(criticalActor1[i]) renderer_window = vtk.vtkRenderWindow() renderer_window.AddRenderer(renderer) renderer_window.SetSize(512, 512) interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(renderer_window) style = vtk.vtkInteractorStyleTrackballCamera() interactor.SetInteractorStyle(style) renderer.AddActor(bar) renderer.AddActor(outlineActor) renderer_window.Render() interactor.Start()
def Main(): global datamin, datamax, lut, renWin # Load bathymetry dataset bathymetryReader = vtk.vtkStructuredPointsReader() bathymetryReader.SetFileName(sys.argv[1]) bathymetryReader.Update() r = bathymetryReader.GetOutput().GetPointData().GetScalars().GetRange() datamin = r[0] datamax = r[1] loadContinuousFile(sys.argv[2]) loadDiscreteFile(sys.argv[3]) # Setup color mapping lut = vtk.vtkColorTransferFunction() lut.SetColorSpaceToHSV() # Load bathymetry data into Geometry Filter geometry = vtk.vtkImageDataGeometryFilter() geometry.SetInputConnection(bathymetryReader.GetOutputPort()) mapper = vtk.vtkDataSetMapper() mapper.SetInputConnection(geometry.GetOutputPort()) mapper.SetLookupTable(lut) mapper.ImmediateModeRenderingOff() # Setup color mapping bar colorBar = vtkScalarBarActor() colorBar.SetLookupTable(mapper.GetLookupTable()) colorBar.SetTitle("color map") colorBar.SetNumberOfLabels(6) colorBar.SetLabelFormat("%4.0f") colorBar.SetPosition(0.9, 0.1) colorBar.SetWidth(0.07) colorBar.SetHeight(0.8) actor = vtk.vtkActor() actor.SetMapper(mapper) # Create renderer stuff ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) renWin.SetSize(1280, 800) # Add the actors to the renderer, set the background and size ren.AddActor(actor) ren.AddActor(colorBar) ren.ResetCamera() ren.SetBackground(0, 0, 0) ren.ResetCameraClippingRange() root = Tkinter.Tk() root.title('Task 2. MRI Data') frame = Tkinter.Frame(root) frame.pack(fill=Tkinter.BOTH, expand="false", side=Tkinter.TOP) mode = Tkinter.IntVar() mode.set(1) Tkinter.Radiobutton(frame, text="Continuous color map", padx=20, variable=mode, value=1, command=showContinuous).pack(anchor=Tkinter.W) Tkinter.Radiobutton(frame, text="Discrete color map", padx=20, variable=mode, value=2, command=showDiscrete).pack(anchor=Tkinter.W) # Setup for rendering window interactor renWinInteract = vtkTkRenderWindowInteractor(frame, rw=renWin, width=1280, height=800) # Specify interaction with 2D image style = vtk.vtkInteractorStyleImage() style.SetInteractionModeToImage2D() renWinInteract.SetInteractorStyle(style) renWinInteract.Initialize() renWinInteract.pack(side='top', fill='both', expand="false") renWinInteract.Start() updateUI(0) renWin.Render() root.mainloop()
def __init__(self,delta,wing): self.arrowColor = vtk.vtkColorTransferFunction() self.update_look_up_table() self.print_counter=0 self.ren = vtk.vtkRenderer() self.geo_reader = vtk.vtkUnstructuredGridReader() self.geo_reader.SetFileName(wing) self.vec_reader = vtk.vtkStructuredPointsReader() self.vec_reader.SetFileName(delta) """ This is for drawing the wing,""" geo_Mapper=vtk.vtkDataSetMapper() geo_Mapper.SetInputConnection(self.geo_reader.GetOutputPort()) geo_actor = vtk.vtkActor() geo_actor.SetMapper(geo_Mapper) self.ren.AddActor(geo_actor) """End of adding the wing """ self.ren.AddActor(self.create_stream_line(25,150,0,0.5)) #Add renderer to renderwindow and render self.renWin = vtk.vtkRenderWindow() self.renWin.AddRenderer(self.ren) self.renWin.SetSize(1920, 1080) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(self.renWin) iren.AddObserver('RightButtonPressEvent', self.capture_image, 1.0) # Scalar Bar actor scalar_bar = vtk.vtkScalarBarActor() scalar_bar.SetOrientationToHorizontal() scalar_bar.SetLookupTable(self.arrowColor) scalar_bar.SetTitle("Color map") scalar_bar.SetLabelFormat("%5.2f") scalar_bar.SetMaximumHeightInPixels(300) scalar_bar.SetMaximumWidthInPixels(60) # Scalar Bar Widget scalar_bar_widget = vtk.vtkScalarBarWidget() scalar_bar_widget.SetInteractor(iren) scalar_bar_widget.SetScalarBarActor(scalar_bar) scalar_bar_widget.On() self.ren.SetBackground(0,0,0) self.renWin.Render() iren.Start()