├── .gitignore ├── PointCloudReader ├── .gitignore ├── __init__.pyc ├── __init__.py └── PointCloudReader.py ├── MeshReader ├── .gitignore ├── __init__.pyc ├── __init__.py └── MeshReader.py ├── vtkCheckVersion.py ├── itkRegionalMaximaImageFilterDemo.py ├── itkCreateRegion.py ├── vtkCreateBuiltinShape.py ├── itkFixedArrayDemo.py ├── vtkSeedWidgetDemo.py ├── vtkMatrix.py ├── vtkImagedataReader.py ├── vtkResliceViewerDemo.py ├── itkCannyDemo.py ├── vtkColorActor.py ├── vtkMarchingCubes.py ├── vtkThresholdPoint.py ├── QuickViewDemo.py ├── tool_Replace_tab.py ├── vtkTransform.py ├── vtkScalarType.py ├── itkWatershedDemo.py ├── itkBasicExample.py ├── vtkUserDefinedEvent.py ├── vtkNumpy.py ├── vtkImagePlaneWidgetDemo.py ├── vtkMousePick.py ├── vtkSmoothPolydata.py ├── vtkLayeredRenderers.py ├── vtkSlidebar.py ├── vtkPolydataReaders.py ├── vtkOverlayDisplay.py ├── vtkManipulatePolyData.py ├── QuickView.py ├── vtkMousePickAddBall.py ├── vtkThreshold.py ├── vtkCombineToolandNormal.py ├── vtkCreateShadows.py ├── vtkModifySTLOrientation.py └── vtkInteractors.py /.gitignore: -------------------------------------------------------------------------------- 1 | 2 | 3 | * 4 | ** 5 | !*.py 6 | 7 | -------------------------------------------------------------------------------- /PointCloudReader/.gitignore: -------------------------------------------------------------------------------- 1 | 2 | !*.py 3 | 4 | 5 | 6 | -------------------------------------------------------------------------------- /MeshReader/.gitignore: -------------------------------------------------------------------------------- 1 | 2 | !*.py 3 | 4 | 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /MeshReader/__init__.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Beastmaster/itk-python-example/HEAD/MeshReader/__init__.pyc -------------------------------------------------------------------------------- /PointCloudReader/__init__.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Beastmaster/itk-python-example/HEAD/PointCloudReader/__init__.pyc -------------------------------------------------------------------------------- /MeshReader/__init__.py: -------------------------------------------------------------------------------- 1 | #Description: 2 | # 3 | #This module read mesh file that is supported by ITK 4 | #File suffix is: .msh 5 | # 6 | # 7 | # 8 | 9 | 10 | 11 | 'Read mesh and export to vtk' 12 | 13 | __author__ = 'Qin Shuo' 14 | 15 | from MeshReader import * 16 | 17 | 18 | -------------------------------------------------------------------------------- /PointCloudReader/__init__.py: -------------------------------------------------------------------------------- 1 | #Description: 2 | # 3 | #This module read A Plain Text point cloud file 4 | # 5 | #VTK Module with the same function: vtkSamplePointReader 6 | # 7 | 8 | 9 | 10 | 'Read point cloud and export to vtk' 11 | 12 | __author__ = 'Qin Shuo' 13 | 14 | from PointCloudReader import * 15 | 16 | 17 | 18 | -------------------------------------------------------------------------------- /vtkCheckVersion.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Author: QIN Shuo 3 | Date: 2012/12/17 4 | 5 | Description: 6 | this file demonstrate how to find the version of VTK 7 | ''' 8 | 9 | 10 | #!/bin/python 11 | 12 | 13 | import vtk 14 | import os 15 | import sys 16 | 17 | 18 | 19 | print vtk.VTK_MAJOR_VERSION # Major version 20 | print vtk.ver_MINOR_VERSION # Minor version 21 | 22 | print vtk.VTK_VERSION # full version of vtk 23 | print vtk.VTK_SOURCE_VERSION # same as VTK_VERSION 24 | -------------------------------------------------------------------------------- /itkRegionalMaximaImageFilterDemo.py: -------------------------------------------------------------------------------- 1 | 2 | ''' 3 | Author: QIN Shuo 4 | Date: 2015/11/5 5 | Description: 6 | This example demonstrate how to use regionalmaximaimagefilter in itk-python 7 | 8 | ''' 9 | 10 | import itk #algorithm 11 | import vtk # for display 12 | import QuickView 13 | 14 | # typedef for pixel or image 15 | PixelType = itk.UC 16 | ImageType = itk.Image[itk.UC,2] 17 | ReaderType = itk.ImageFileReader[ImageType] 18 | 19 | # read or create a image 20 | reader = ReaderType.New() 21 | fileName = 'C:/Users/qinsh/Desktop/test.dcm' 22 | reader.SetFileName(fileName) 23 | reader.Update() 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | -------------------------------------------------------------------------------- /itkCreateRegion.py: -------------------------------------------------------------------------------- 1 | # Author: QIN Shuo 2 | # Date: 2015/10/26 3 | # This is a test file for itk 4 | # This example demonstrates how to create a region in ITK 5 | # Only 2/3 dimensions (dimensions depend on your choice in cmake when compiling ITK) 6 | 7 | 8 | 9 | import itk 10 | 11 | # set start position 12 | startID_2 = [0,0] # for 2D region 13 | startID_3 = [0,0,0] # for 3D region 14 | 15 | # set region size 16 | size_2 = [100,100] # for 2D region 17 | size_3 = [100,100,100] # for 3D region 18 | 19 | 20 | # describe a region 21 | region_2 = itk.ImageRegion._2(startID_2,size_2) #2D region 22 | region_3 = itk.ImageRegion._3(startID_3,size_3) #3D region 23 | 24 | 25 | -------------------------------------------------------------------------------- /vtkCreateBuiltinShape.py: -------------------------------------------------------------------------------- 1 | #python for vtk test 2 | #Created by QinShuo 3 | #Date 2015.8.18 4 | # This Demo demonstrate how to create a cylinder and display 5 | 6 | 'test module' 7 | __author__ = 'Qin Shuo' 8 | 9 | 10 | import vtk 11 | from QuickView import visualize_poly 12 | from vtk.util.colors import tomato 13 | 14 | 15 | def vtk_cylinder(): 16 | #create a polygonal cylinder model 17 | cylinder = vtk.vtkCylinderSource() 18 | cylinder.SetResolution(8) 19 | cylinder.Update() 20 | return cylinder.GetOutput() 21 | 22 | 23 | def vtk_sphere(): 24 | sphereSrc = vtk.vtkSphereSource() 25 | sphereSrc.SetRadius(10.0) 26 | sphereSrc.SetCenter(0.0,0.0,0.0) 27 | sphereSrc.SetThetaResolution(20) 28 | sphereSrc.Update() 29 | return sphereSrc.GetOutput() 30 | 31 | 32 | -------------------------------------------------------------------------------- /itkFixedArrayDemo.py: -------------------------------------------------------------------------------- 1 | 2 | # Author: QIN Shuo 3 | # Date: 2015/10/26 4 | # This is a test file for itk 5 | # This example demonstrates how to use FixedArray class 6 | # 7 | # Note: 8 | # FixedArray calss implement operator[] for c++ 9 | # Use Set/GetElement function to access element instead in wrap languages(python for example) 10 | # There is no New() function in python wrap, but you should add () to initialize it 11 | 12 | import itk 13 | 14 | # created an fixed 3-length unsigned char array 15 | # Note: the () in the last is essential! 16 | array = itk.FixedArray[itk.UC,3]() 17 | 18 | print ("init is ",array) 19 | 20 | # use SetElement function to set menber instead of operator [] 21 | array.SetElement(0,1) 22 | array.SetElement(1,1) 23 | array.SetElement(2,1) 24 | 25 | print ("arr 2 is ",array) -------------------------------------------------------------------------------- /vtkSeedWidgetDemo.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | Created on Tue Jan 26 17:42:59 2016 4 | 5 | @author: qinshuo 6 | """ 7 | 8 | 9 | 10 | import vtk 11 | 12 | 13 | render = vtk.vtkRenderer() 14 | 15 | win = vtk.vtkRenderWindow() 16 | win.AddRenderer(render) 17 | 18 | interactor = vtk.vtkRenderWindowInteractor() 19 | interactor.SetRenderWindow(win) 20 | 21 | 22 | # create a representation 23 | handleRep = vtk.vtkPointHandleRepresentation2D() 24 | handleRep.GetProperty().SetColor(1,1,0) 25 | 26 | widgetRep = vtk.vtkSeedRepresentation() 27 | widgetRep.SetHandleRepresentation(handleRep) 28 | 29 | # create a seedwidget here 30 | seedWidget = vtk.vtkSeedWidget() 31 | 32 | seedWidget.SetInteractor(interactor) 33 | seedWidget.SetRepresentation(widgetRep) 34 | 35 | 36 | seedWidget.On() 37 | interactor.Start() 38 | 39 | 40 | -------------------------------------------------------------------------------- /vtkMatrix.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Author: QIN Shuo 3 | Date: 2015/12/18 4 | Description: 5 | This file demonstrate how to manipulate position/size/direction 6 | of a image. 7 | 8 | Matrix Operation: 9 | 1. create a matrix 10 | 2. Matrix initialization 11 | 3. Change matrix elements value 12 | 4. Get element value 13 | 14 | ''' 15 | 16 | 17 | 18 | import vtk 19 | 20 | # create a matrix instance 21 | matrix = vtk.vtkMatrix4x4() 22 | 23 | 24 | value = [1,2,3,4] 25 | 26 | # initialization 27 | matrix.DeepCopy((1,2,3,4, 28 | 5,6,7,8, 29 | 9,10,11,12, 30 | 0,0,0,1)) 31 | 32 | 33 | 34 | 35 | # change element value 36 | index_x = 0 # 37 | index_y = 0 # 38 | v = 100 39 | matrix.SetElement(index_x,index_y,v) 40 | 41 | 42 | # Get element value 43 | new_value = matrix.GetElement(index_x,index_y) 44 | print(new_value) 45 | -------------------------------------------------------------------------------- /vtkImagedataReader.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Author: Qin Shuo 3 | Date: 2017/1/16 4 | Description: 5 | This file demo some vtk Readers 6 | Return a vtkImageData format 7 | Support format (): 8 | 1. dicom 9 | 2. nii / nii.gz 10 | 3. mha/mhd 11 | ''' 12 | 13 | 14 | import vtk 15 | 16 | 17 | def MetaReader(ff): 18 | ''' 19 | http://www.vtk.org/Wiki/VTK/Examples/Cxx/IO/MetaImageReader 20 | ''' 21 | reader = vtk.vtkMetaImageReader() 22 | reader.SetFileName(ff) 23 | reader.Update() 24 | return reader.GetOutput() 25 | 26 | 27 | def NiftiReader(ff): 28 | reader = vtk.vtkNIFTIImageReader() 29 | reader.SetFileName(ff) 30 | reader.Update() 31 | return reader.GetOutput() 32 | 33 | 34 | 35 | 36 | def DicomReader(ff): 37 | reader = vtk.vtkDICOMImageReader() 38 | reader.SetFileName(ff) 39 | reader.Update() 40 | return reader.GetOutput() 41 | 42 | 43 | def DiconSeriesReader(path): 44 | ''' 45 | http://www.vtk.org/Wiki/VTK/Examples/Cxx/IO/ReadDICOMSeries 46 | ''' 47 | reader = vtk.vtkDICOMImageReader() 48 | reader.SetDirectoryName(ff) 49 | reader.Update() 50 | return reader.GetOutput() 51 | 52 | 53 | -------------------------------------------------------------------------------- /vtkResliceViewerDemo.py: -------------------------------------------------------------------------------- 1 | #Author: Qin Shuo 2 | #Date: 2015/10/27 3 | #Description: 4 | # This example how to use vtkResliceImageViewer 5 | # vtkResliceImageViewer display a image along a 2 cross hairs for reslicing 6 | # Usefule functions: reslice mode 7 | 8 | 9 | import vtk 10 | import sys 11 | 12 | directory = 'E:/test/ct_spine' 13 | 14 | def DisplayImageData(data): 15 | viewer = vtk.vtkResliceImageViewer() 16 | interactor = vtk.vtkRenderWindowInteractor() 17 | interactor.SetRenderWindow(viewer.GetRenderWindow()) 18 | 19 | viewer.SetupInteractor(interactor) 20 | viewer.SetInputData(data) 21 | 22 | # calculate index of middle slice in the dicom image 23 | midSlice = viewer.GetSliceMax()/2 24 | 25 | # set up reslice view properties 26 | viewer.SetSlice(midSlice) 27 | viewer.SetSliceOrientationToXY() 28 | viewer.GetRenderer().ResetCamera() 29 | viewer.Render() 30 | 31 | interactor.Start() 32 | 33 | #vtk dicom reader, input dicom directory 34 | def DisplayDicom(folder = directory): 35 | reader = vtk.vtkDICOMImageReader() 36 | reader.SetDirectoryName(directory) 37 | reader.Update() 38 | DisplayImageData(reader.GetOutput()) 39 | 40 | 41 | if __name__ == '__main__': 42 | DisplayDicom() 43 | 44 | -------------------------------------------------------------------------------- /itkCannyDemo.py: -------------------------------------------------------------------------------- 1 | #Author: Qin Shuo 2 | #Date: 2015/10/29 3 | #Description: 4 | # This example how to detect edge with 5 | # Canny Edge Detection Filter 6 | #Reference: 7 | # http://itk.org/ITKExamples/src/Filtering/ImageFeature/DetectEdgesWithCannyFilter/Documentation.html 8 | # 9 | 10 | 11 | 12 | import sys 13 | import itk 14 | import QuickView 15 | 16 | #define image type 17 | pixelType = itk.F 18 | dimension = 2 19 | imageType = itk.Image[pixelType,dimension] 20 | readerType = itk.ImageFileReader[imageType] 21 | 22 | name = "C:/Users/qinsh/Desktop/test.dcm" 23 | variance = 1.5 24 | lowerThreshold = 20 25 | upperThreshold = 40 26 | 27 | 28 | 29 | reader = readerType.New() 30 | reader.SetFileName(name) 31 | 32 | 33 | sobelType = itk.SobelEdgeDetectionImageFilter[imageType,imageType] 34 | sobelFilter = sobelType.New() 35 | sobelFilter.SetInput(reader.GetOutput()) 36 | 37 | 38 | filterType = itk.CannyEdgeDetectionImageFilter[imageType,imageType] 39 | cannyFilter = filterType.New() 40 | cannyFilter.SetInput(reader.GetOutput()) 41 | cannyFilter.SetVariance(variance) 42 | cannyFilter.SetLowerThreshold(lowerThreshold) 43 | cannyFilter.SetUpperThreshold(upperThreshold) 44 | 45 | 46 | # visualize 47 | viewer = QuickView.QuickView(imageType) 48 | viewer.AddImage(cannyFilter.GetOutput()) 49 | viewer.Visualize2() 50 | 51 | 52 | -------------------------------------------------------------------------------- /vtkColorActor.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Author: Qin Shuo 3 | Date: 2016/03/22 4 | Description: 5 | Create a sphere (vtkpolydata type) 6 | Assign color and display 7 | ''' 8 | 9 | 10 | 11 | import vtk 12 | import sys 13 | import string 14 | 15 | 16 | def CreateSphere(): 17 | # sphere source 18 | # Document: http://www.vtk.org/doc/nightly/html/classvtkSphereSource.html 19 | sphereSrc = vtk.vtkSphereSource() 20 | sphereSrc.SetRadius(10.0) 21 | sphereSrc.SetCenter(0.0,0.0,0.0) 22 | sphereSrc.SetThetaResolution(20) 23 | sphereSrc.Update() 24 | return sphereSrc.GetOutput() 25 | 26 | 27 | def display_color_actor(poly): 28 | # visualization 29 | print "visualizing..." 30 | mapper = vtk.vtkPolyDataMapper() 31 | mapper.SetInputData(poly) 32 | actor = vtk.vtkActor() 33 | actor.SetMapper(mapper) 34 | #============ key line =============# 35 | actor.GetProperty().SetColor(0.5,0.5,0.0) 36 | #============ key line =============# 37 | 38 | renderer = vtk.vtkRenderer() 39 | renderer.AddActor(actor) 40 | window = vtk.vtkRenderWindow() 41 | window.AddRenderer(renderer) 42 | interactor = vtk.vtkRenderWindowInteractor() 43 | window.SetInteractor(interactor) 44 | 45 | window.Render() 46 | interactor.Start() 47 | 48 | 49 | 50 | 51 | if __name__ == '__main__': 52 | 53 | sphere = CreateSphere() 54 | display_color_actor(sphere) 55 | -------------------------------------------------------------------------------- /vtkMarchingCubes.py: -------------------------------------------------------------------------------- 1 | ''' 2 | MarchingCubes 3 | 4 | Add ball 5 | 6 | mouse click 7 | 8 | ''' 9 | 10 | import vtk 11 | import sys 12 | 13 | def MarchingCubes(image,threshold): 14 | ''' 15 | http://www.vtk.org/Wiki/VTK/Examples/Cxx/Modelling/ExtractLargestIsosurface 16 | ''' 17 | mc = vtk.vtkMarchingCubes() 18 | mc.SetInputData(image) 19 | mc.ComputeNormalsOn() 20 | mc.ComputeGradientsOn() 21 | mc.SetValue(0, threshold) 22 | mc.Update() 23 | 24 | # To remain largest region 25 | confilter =vtk.vtkPolyDataConnectivityFilter() 26 | confilter.SetInputData(mc.GetOutput()) 27 | confilter.SetExtractionModeToLargestRegion() 28 | confilter.Update() 29 | 30 | return confilter.GetOutput() 31 | 32 | 33 | def Smooth_stl(stl): 34 | smoothFilter = vtk.vtkSmoothPolyDataFilter() 35 | smoothFilter.SetInputConnection(stl) 36 | smoothFilter.SetNumberOfIterations(15) 37 | smoothFilter.SetRelaxationFactor(0.1) 38 | smoothFilter.FeatureEdgeSmoothingOff() 39 | smoothFilter.BoundarySmoothingOn() 40 | smoothFilter.Update() 41 | 42 | if __name__ == '__main__': 43 | #from QuickView import visualize_poly 44 | ff = '1-L1_th.nii' 45 | reader = vtk.vtkNIFTIImageReader() 46 | reader.SetFileName(ff) 47 | reader.Update() 48 | im = reader.GetOutput() 49 | poly = MarchingCubes(im,1) 50 | #visualize_poly(poly) 51 | writer = vtk.vtkSTLWriter() 52 | writer.SetInputData(poly) 53 | writer.SetFileName('xx.stl') 54 | writer.Update() 55 | 56 | -------------------------------------------------------------------------------- /vtkThresholdPoint.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Author: QIN Shuo 3 | Date: 2016/01/28 4 | 5 | How to threshold Points and Cell in poly data 6 | 7 | ''' 8 | 9 | import vtk 10 | 11 | 12 | 13 | 14 | points = vtk.vtkPoints() 15 | 16 | points.InsertNextPoint(0,0,0); 17 | points.InsertNextPoint(1,1,1); 18 | points.InsertNextPoint(2,2,2); 19 | points.InsertNextPoint(3,3,3); 20 | points.InsertNextPoint(4,4,4); 21 | 22 | index = vtk.vtkIntArray(); 23 | index.SetNumberOfComponents(1); 24 | index.SetName("index"); 25 | index.InsertNextValue(0); 26 | index.InsertNextValue(1); 27 | index.InsertNextValue(2); 28 | index.InsertNextValue(3); 29 | index.InsertNextValue(4); 30 | 31 | 32 | polydata = vtk.vtkPolyData() 33 | polydata.SetPoints(points) 34 | polydata.GetPointData().AddArray(index) 35 | 36 | 37 | threshold = vtk.vtkThresholdPoints() 38 | threshold.SetInputData(polydata) 39 | 40 | threshold.ThresholdByLower(2) 41 | threshold.SetInputArrayToProcess(0, 0, 0, vtk.vtkDataObject.FIELD_ASSOCIATION_POINTS, "index") 42 | threshold.Update() 43 | 44 | 45 | 46 | polyMapper = vtk.vtkPolyDataMapper() 47 | polyMapper.SetInputData(threshold.GetOutput()) 48 | 49 | actor = vtk.vtkActor() 50 | actor.SetMapper(polyMapper) 51 | 52 | renderer = vtk.vtkRenderer() 53 | win = vtk.vtkRenderWindow() 54 | intact = vtk.vtkRenderWindowInteractor() 55 | style = vtk.vtkInteractorStyleTrackballCamera() 56 | 57 | win.AddRenderer(renderer) 58 | renderer.AddActor(actor) 59 | intact.SetInteractorStyle(style) 60 | intact.SetRenderWindow(win) 61 | win.Render() 62 | intact.Start() 63 | 64 | -------------------------------------------------------------------------------- /QuickViewDemo.py: -------------------------------------------------------------------------------- 1 | # Author: QIN Shuo 2 | # Date: 2015/10/26 3 | # This is a test file for itk 4 | # This example demonstrates simple visualization capabilities provided by the QuickView class. 5 | # Reference: http://farsight-toolkit.org/wiki/FARSIGHT_Tutorials/Quick_Start 6 | 7 | import itk 8 | import QuickView 9 | 10 | #definition for creation function 11 | def CreateImage(image): 12 | ImageType = itk.Image[itk.UC,2] 13 | corner = [0,0] 14 | NumRows = 200 15 | NumCols = 300 16 | size = [NumRows,NumCols] 17 | 18 | region = itk.ImageRegion._2(corner,size) 19 | 20 | image.SetRegions(region) 21 | image.Allocate() 22 | 23 | # make a square 24 | for r in range(40,100): 25 | for c in range(40,100): 26 | pixelIndex = [r,c] 27 | image.SetPixel(pixelIndex,15) 28 | 29 | return image 30 | 31 | 32 | 33 | ### start main function here ### 34 | # type defines for Image Type 35 | ImageType = itk.Image[itk.UC,2] 36 | # construct a image pointer 37 | image = ImageType.New() 38 | # invoke function defined previously 39 | CreateImage(image) 40 | # type defines for RescalIntensityImageFilter 41 | RescalFilterType = itk.RescaleIntensityImageFilter[ImageType,ImageType] 42 | rescaleFilter = RescalFilterType.New() 43 | rescaleFilter.SetInput(image) 44 | rescaleFilter.SetOutputMinimum(0) 45 | rescaleFilter.SetOutputMaximum(255) 46 | rescaleFilter.Update() 47 | 48 | #image = rescaleFilter.GetOutput() 49 | 50 | view = QuickView.QuickView(ImageType) 51 | view.AddImage(rescaleFilter.GetOutput()) 52 | view.Visualize2() 53 | 54 | 55 | -------------------------------------------------------------------------------- /tool_Replace_tab.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Author: Qin Shuo 3 | Date: 2016/04/16 4 | Description: 5 | Replace 'tab' key with 4 whitespace in file 6 | ''' 7 | 8 | import sys 9 | import string 10 | 11 | 12 | 13 | def replace_tab(file_name,index): 14 | print "option 1: replace 'tab \t' with 4 white space" 15 | print "option 2: replace 'self.Event' with 'self.e_Event'" 16 | 17 | # create a file handle 18 | fp = open(file_name,'r') 19 | 20 | if index == '1': 21 | content = fp.read() 22 | new_content = content.replace('\t',' ') 23 | elif index == '2': 24 | content = fp.readlines() 25 | new_content = "" 26 | for line in content: 27 | if line.rfind("self.")!=-1: 28 | id = line.rfind("self.")+len("self.") 29 | nline = line[:id]+"e_"+line[id:] 30 | else: 31 | nline = line 32 | new_content = new_content+nline 33 | fp.close() 34 | 35 | ind = file_name.rfind('.') 36 | new_name = file_name[:ind]+"new_"+file_name[ind:] 37 | print "New file name: "+new_name 38 | fp2 = open(new_name,'w+') 39 | fp2.write(new_content) 40 | fp2.close() 41 | 42 | 43 | if __name__ == '__main__': 44 | #file_name = sys.argv[1] 45 | if len(sys.argv)<3: 46 | print "no enough parameters..." 47 | print "file,[selection]" 48 | exit() 49 | else: 50 | file_name = sys.argv[1] 51 | print "replacing: "+ file_name 52 | replace_tab(file_name,sys.argv[2]) 53 | 54 | 55 | -------------------------------------------------------------------------------- /vtkTransform.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Author: QIN Shuo 3 | Date: 2015/12/17 4 | 5 | Description: 6 | This file demonstrate how to change properties ( direction / 7 | size/ transformation) of an image object. THis method is 8 | different the method to change vtkActor 9 | 10 | ''' 11 | 12 | 13 | import vtk 14 | 15 | coneSource = vtk.vtkConeSource() 16 | coneSource.Update() 17 | 18 | # original source 19 | mapper1 = vtk.vtkPolyDataMapper() 20 | mapper1.SetInputData(coneSource.GetOutput()) 21 | actor1 = vtk.vtkActor() 22 | actor1.SetMapper(mapper1) 23 | 24 | # apply a transform to a source 25 | translation = vtk.vtkTransform() 26 | translation.Translate(1,0,0) 27 | #translation.Scale(1,2,2) 28 | print("translation",translation.GetScale()) 29 | 30 | transformFilter = vtk.vtkTransformFilter() 31 | transformFilter.SetInputData(coneSource.GetOutput()) 32 | transformFilter.SetTransform(translation) 33 | transformFilter.Update() 34 | 35 | #print("applying transform",transformFilter.GetScale()) 36 | 37 | mapper2 = vtk.vtkPolyDataMapper() 38 | mapper2.SetInputData(transformFilter.GetOutput()) 39 | actor2 = vtk.vtkActor() 40 | actor2.SetMapper(mapper2) 41 | 42 | 43 | 44 | 45 | renderer = vtk.vtkRenderer() 46 | renderWin = vtk.vtkRenderWindow() 47 | interactor = vtk.vtkRenderWindowInteractor() 48 | renderWin.AddRenderer(renderer) 49 | interactor.SetRenderWindow(renderWin) 50 | interactor.SetInteractorStyle(vtk.vtkInteractorStyleTrackballActor()) 51 | 52 | # 53 | renderer.AddActor(actor1) 54 | renderer.AddActor(actor2) 55 | renderer.SetBackground(1,1,1) 56 | 57 | renderWin.Render() 58 | interactor.Start() 59 | 60 | 61 | 62 | 63 | -------------------------------------------------------------------------------- /vtkScalarType.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Author: QIN Shuo 3 | Date: 2016/1/28 4 | This is a example file for vtk 5 | Description: 6 | Get scalar type of imagedata 7 | 8 | 9 | type list: 10 | 11 | #define VTK_VOID 0 12 | #define VTK_BIT 1 13 | #define VTK_CHAR 2 14 | #define VTK_SIGNED_CHAR 15 15 | #define VTK_UNSIGNED_CHAR 3 16 | #define VTK_SHORT 4 17 | #define VTK_UNSIGNED_SHORT 5 18 | #define VTK_INT 6 19 | #define VTK_UNSIGNED_INT 7 20 | #define VTK_LONG 8 21 | #define VTK_UNSIGNED_LONG 9 22 | #define VTK_FLOAT 10 23 | #define VTK_DOUBLE 11 24 | #define VTK_ID_TYPE 12 25 | 26 | 27 | 28 | 29 | ''' 30 | 31 | 32 | 33 | import vtk 34 | import os 35 | 36 | folder_path = "E:/test/david/" 37 | 38 | for i in os.listdir(folder_path): #(os.getcwd()): 39 | if (i.endswith(".nii") or i.endswith(".py")) and i.find("new") == -1: 40 | name = folder_path + i 41 | print "file ",i 42 | reader = vtk.vtkNIFTIImageReader() 43 | reader.SetFileName(name) 44 | reader.Update() 45 | print "type is: ",reader.GetDataScalarType() 46 | matrix = reader.GetQFormMatrix() 47 | print "Ori QForm Matrix is",matrix 48 | 49 | 50 | caster = vtk.vtkImageCast() 51 | caster.SetInputData(reader.GetOutput()) 52 | caster.SetOutputScalarTypeToInt() 53 | caster.Update() 54 | 55 | i2 = "new"+i 56 | print "writing to", i2 57 | writer = vtk.vtkNIFTIImageWriter() 58 | #writer.SetQFac(-1) 59 | writer.SetQFormMatrix(matrix) 60 | writer.SetFileName(folder_path+i2) 61 | writer.SetInputData(caster.GetOutput()) 62 | writer.Update() 63 | else: 64 | pass 65 | 66 | 67 | print "Done!!" 68 | 69 | 70 | 71 | 72 | 73 | -------------------------------------------------------------------------------- /itkWatershedDemo.py: -------------------------------------------------------------------------------- 1 | #Author: Qin Shuo 2 | #Date: 2015/11/2 3 | #Description: 4 | # This example how to detect edge with 5 | # Canny Edge Detection Filter 6 | #Reference: 7 | # 8 | #Fail to display: 9 | # unsupported type of itk data: unsigned long (watershed filters required) 10 | 11 | 12 | import itk #algorithm 13 | import vtk # for display 14 | import QuickView 15 | 16 | # typedef for pixel or image 17 | PixelType = itk.UC 18 | ImageType = itk.Image[itk.UC,2] 19 | ReaderType = itk.ImageFileReader[ImageType] 20 | 21 | # read or create a image 22 | reader = ReaderType.New() 23 | fileName = 'C:/Users/qinsh/Desktop/test.dcm' 24 | reader.SetFileName(fileName) 25 | reader.Update() 26 | 27 | # simple version from itk example 28 | gradientMagnitudeImageFilter = itk.GradientMagnitudeImageFilter[ImageType,ImageType].New() 29 | gradientMagnitudeImageFilter.SetInput(reader.GetOutput()) 30 | gradientMagnitudeImageFilter.Update() 31 | 32 | threshold = 0.005 33 | level = 0.5 34 | 35 | watershedFilterType = itk.WatershedImageFilter[ImageType] 36 | watershed = watershedFilterType.New() 37 | watershed.SetInput(gradientMagnitudeImageFilter.GetOutput()) 38 | watershed.SetThreshold(threshold) 39 | watershed.SetLevel(level) 40 | watershed.Update() 41 | 42 | 43 | image = watershed.GetOutput() 44 | 45 | # threshold first and convert to binary image 46 | 47 | 48 | 49 | # open to remove noise 50 | 51 | 52 | # dilate to get background area 53 | 54 | 55 | # distance transform to get foreground 56 | 57 | 58 | 59 | # maker labelling 60 | 61 | 62 | 63 | # run watershed algorithm 64 | 65 | 66 | 67 | 68 | # display 69 | viewer = QuickView.QuickView(itk.UL) 70 | viewer.AddImage(image) 71 | viewer.Visualize2() 72 | 73 | i2vConnector = itk.ImageToVTKImageFilter[ImageType] 74 | connector = i2vConnector.New() 75 | connector.SetInput(image) 76 | 77 | viewer2 = vtk.vtkImageViewer2() 78 | viewer2.SetInput(connector.GetOutput()) 79 | 80 | interactor = vtk.vtkRenderWindowInteractor() 81 | viewer2.SetupInteractor(interactor) 82 | viewer2.Render() 83 | viewer2.GetRenderer().ResetCamera() 84 | viewer2.Render() 85 | 86 | interactor.Start() 87 | -------------------------------------------------------------------------------- /itkBasicExample.py: -------------------------------------------------------------------------------- 1 | # Author: QIN Shuo 2 | # Date: 2015/10/26 3 | # This is a test file for itk 4 | # In this file I implement some basic function in itk 5 | # More function will be implemented further 6 | # Function: Read a png file and display with vtk 7 | 8 | import itk 9 | import vtk 10 | import sys 11 | 12 | # set image file name 13 | image_path = "C:/Users/qinsh/Desktop/test.png" 14 | 15 | ##### itk is a templated system and we should define a lot of types first #### 16 | 17 | #define a pixel data type. UC means unsigned char 18 | pixelType = itk.UC 19 | #define image type to unsigned char and 3 dims 20 | imageType = itk.Image[pixelType, 3] 21 | #define reader type, you must include imageType to it 22 | readerType = itk.ImageFileReader[imageType] 23 | 24 | # init a reader instance 25 | reader = readerType.New() 26 | # set file name 27 | reader.SetFileName( "C:/Users/qinsh/Desktop/test.png" ) 28 | # update and start reading process 29 | reader.Update() 30 | # get itk image 31 | image1 = reader.GetOutput() 32 | 33 | #define a itk image to vtk image connector type 34 | #in c++ version i2v connector should define input&output image type 35 | #in python version it seems to be one same image type 36 | I2VConnectorType = itk.ImageToVTKImageFilter[imageType] 37 | 38 | #new a I2V connector instance 39 | connector = I2VConnectorType.New() 40 | connector.SetInput(image1) 41 | #pipline based structure need update to start process 42 | connector.Update() 43 | 44 | 45 | #### below is vtk visulation process #### 46 | # python version itk and vtk is a little different in consturct a instance 47 | # the main difference is that: itk has a new() function 48 | 49 | #visualization pipeline 50 | #actor 51 | actor = vtk.vtkImageActor() 52 | actor.SetInput(connector.GetOutput()) 53 | #renderer 54 | renderer = vtk.vtkRenderer() 55 | renderer.AddActor(actor) 56 | #render window 57 | renWin = vtk.vtkRenderWindow() 58 | renWin.AddRenderer(renderer) 59 | #render window interactor 60 | interactor = vtk.vtkRenderWindowInteractor() 61 | interactor.SetRenderWindow(renWin) 62 | interactor.Initialize() 63 | interactor.Start() 64 | 65 | 66 | 67 | 68 | -------------------------------------------------------------------------------- /PointCloudReader/PointCloudReader.py: -------------------------------------------------------------------------------- 1 | #file name: PointCloudReader.py 2 | #Function: Read point cloud from plain text file. 3 | 4 | __author__ = 'Qin Shuo' 5 | 6 | import vtk 7 | import sys 8 | 9 | def ReadSimplePoint(filename): 10 | print 'Reading file: ', filename 11 | #read file 12 | reader = vtk.vtkSimplePointsReader() 13 | reader.SetFilename(filename) 14 | reader.Update() 15 | 16 | #visualize 17 | PolyVisualize(reader.GetOutputPort()) 18 | 19 | 20 | def ReadPointCloud(filename): 21 | print 'Reading file: ', filename 22 | #vtkPoints here: 23 | #method1: assign number of points, insert points by ID, ::SetPoint(ID, double[3]) 24 | #method2: assign no size, insert one after anther, ::InsertNextPoint(double[3]) 25 | points = vtk.vtkPoints() 26 | poly = vtk.vtkPolyData() 27 | glyphFilter = vtk.vtkVertexGlyphFilter() # I don't know what is the purpose 28 | 29 | fp = open(filename,"rb+") 30 | line = fp.readline() 31 | while line!='': 32 | line = line.strip() 33 | if line == '': 34 | continue 35 | elif line.find('\t') < 0: 36 | line = line.split(' ') 37 | else: 38 | line = line.split('\t') 39 | 40 | points.InsertNextPoint(float(line[0]),float(line[1]),float(line[2])) 41 | #read next line and return to loop 42 | line = fp.readline() 43 | 44 | #add point to poly data 45 | poly.SetPoints(points) 46 | glyphFilter.SetInputData(poly) 47 | glyphFilter.Update() 48 | 49 | #visualize 50 | PolyVisualize(glyphFilter.GetOutputPort()) 51 | 52 | 53 | def PolyVisualize(inputConnection): 54 | print('visualizing...') 55 | PolyMapper = vtk.vtkPolyDataMapper() 56 | PolyMapper.SetInputConnection(inputConnection) 57 | 58 | actor = vtk.vtkActor() 59 | actor.SetMapper(PolyMapper) 60 | 61 | renderer = vtk.vtkRenderer() 62 | renderWin = vtk.vtkRenderWindow() 63 | interactor = vtk.vtkRenderWindowInteractor() 64 | 65 | renderWin.AddRenderer(renderer) 66 | interactor.SetRenderWindow(renderWin) 67 | 68 | renderer.AddActor(actor) 69 | renderer.SetBackground(0,0,0) 70 | renderWin.Render() 71 | interactor.Start() 72 | 73 | 74 | if __name__ == "__main__": 75 | ReadPointCloud(sys.argv[1]) -------------------------------------------------------------------------------- /vtkUserDefinedEvent.py: -------------------------------------------------------------------------------- 1 | 2 | ''' 3 | Author: QIN Shuo 4 | Date: 2015/11/10 5 | This is a example file for vtk 6 | 7 | Description: 8 | This file demonstrate how to define a user event 9 | Different from the one that pre-defined in VTK 10 | like: MouseEvent, KeyPressEvent 11 | 12 | Details: 13 | implement a new filter, use InvokeEvent() to trigger 14 | InvokeEvent base class: vtkObject 15 | user-event ID recommend to be vtkCommand::UserEvent + 1xx 16 | 17 | 18 | Reference: vtk-example/Interaction/UserEvent 19 | ''' 20 | 21 | 22 | import vtk 23 | 24 | 25 | # inhert from vtkObject 26 | class MyClass(vtk.vtkObject): 27 | def __init__(self): 28 | # this line is important: define event ID 29 | print "inited" 30 | self.MyEvent = vtk.vtkCommand.UserEvent+1 31 | 32 | def trigger(self): 33 | print "triggered" 34 | self.InvokeEvent(self.MyEvent) 35 | print self.MyEvent 36 | 37 | 38 | def callbackFunc(caller,eventID,clientData,callData): 39 | print("call back called") 40 | 41 | def callbackFunc2(obj,event): 42 | print("call back 2 called") 43 | 44 | def KeyPressEvent(obj,event): 45 | print("key pressed") 46 | global test 47 | test.trigger() 48 | #obj.InvokeEvent(test.MyEvent) 49 | 50 | renderer = vtk.vtkRenderer() 51 | renderWin = vtk.vtkRenderWindow() 52 | interactor = vtk.vtkRenderWindowInteractor() 53 | 54 | renderWin.AddRenderer(renderer) 55 | interactor.SetRenderWindow(renderWin) 56 | 57 | test = MyClass() 58 | test.AddObserver(test.MyEvent,callbackFunc2) 59 | # this step is important: create a callback command instance 60 | #interactor.AddObserver(test.MyEvent,callbackFunc2) 61 | interactor.AddObserver("KeyPressEvent",KeyPressEvent) 62 | 63 | 64 | renderWin.Render() 65 | interactor.Start() 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 | -------------------------------------------------------------------------------- /vtkNumpy.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Author: QIN Shuo 3 | Date: 2017/1/16 4 | 5 | Description: 6 | Demo to connect vtk with numpy 7 | ''' 8 | 9 | 10 | 11 | import vtk 12 | from vtk.util import numpy_support 13 | import numpy as np 14 | 15 | 16 | 17 | def vtkimage2numpy(vtk_img): 18 | dim = vtk_img.GetDimensions() 19 | spacing = vtk_img.GetSpacing() 20 | origin = vtk_img.GetOrigin() 21 | 22 | ########## Key line ########## 23 | # 1. convert vtkImagedata to a vtkArray 24 | vtk_img = vtk_img.GetPointData().GetScalars() 25 | # 2. call vtk.util to convert to a numpy array 26 | npdata = numpy_support.vtk_to_numpy(vtk_img) 27 | # 3. reshape the array 28 | npdata = npdata.reshape(dim) 29 | ########## Key line ########## 30 | 31 | print 'shape is {}'.format(npdata.shape) 32 | print 'origin is {}'.format(origin) 33 | print 'spacing is {}'.format(spacing) 34 | 35 | return npdata 36 | 37 | 38 | def numpy2vtkimage(npdata,origin,spacing,dim): 39 | npdata_shape = npdata.shape 40 | #### flaten the data to 1 dim #### 41 | #VTK_data = numpy_support.numpy_to_vtk(num_array=npdata.ravel(), deep=True, array_type=vtk.VTK_FLOAT) 42 | VTK_data = numpy_support.numpy_to_vtk(num_array=np.reshape(npdata,(-1)), deep=True, array_type=vtk.VTK_FLOAT) 43 | 44 | out_img = vtk.vtkImageData() 45 | out_img.SetOrigin(origin) 46 | out_img.SetSpacing(spacing) 47 | out_img.SetDimensions(dim) 48 | out_img.GetPointData().SetScalars(VTK_data) 49 | 50 | print 'shape is {}'.format(out_img.GetDimensions()) 51 | print 'origin is {}'.format(out_img.GetOrigin()) 52 | print 'spacing is {}'.format(out_img.GetSpacing()) 53 | 54 | return out_img 55 | 56 | 57 | if __name__ == '__main__': 58 | 59 | nii_file = 'D:/data/test.nii' 60 | 61 | reader = vtk.vtkNIFTIImageReader() 62 | reader.SetFileName(nii_file) 63 | reader.Update() 64 | vtk_img = reader.GetOutput() 65 | 66 | dim = vtk_img.GetDimensions() 67 | spacing = vtk_img.GetSpacing() 68 | origin = vtk_img.GetOrigin() 69 | 70 | 71 | npdata = vtkimage2numpy(vtk_img) 72 | out_img = numpy2vtkimage(npdata,origin,spacing,dim) 73 | 74 | writer = vtk.vtkNIFTIImageWriter() 75 | writer.SetFileName('test2.nii') 76 | writer.SetInputData(out_img) 77 | writer.Update() 78 | print "Done" 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | -------------------------------------------------------------------------------- /vtkImagePlaneWidgetDemo.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Author: QIN Shuo 3 | Date: 2016/3/30 4 | 5 | Description: 6 | This demo demonstrate how to use vtkImagePlaneSource 7 | 8 | Implement 4 renderer in a window 9 | 10 | ''' 11 | 12 | 13 | import vtk 14 | import sys 15 | import string 16 | 17 | 18 | def ReadNii(filename): 19 | reader = vtk.vtkNIFTIImageReader() 20 | reader.SetFileName(filename) 21 | reader.Update() 22 | return reader.GetOutput() 23 | 24 | 25 | def ImagePlaneDemo(img): 26 | 27 | # create a window 28 | window = vtk.vtkRenderWindow() 29 | 30 | # create interactor 31 | interactor = vtk.vtkRenderWindowInteractor() 32 | window.SetInteractor(interactor) 33 | 34 | 35 | # create 4 renderers 36 | xmins = [0,.5,0,.5] 37 | xmaxs = [0.5,1,0.5,1] 38 | ymins = [0,0,0.5,0.5] 39 | ymaxs = [0.5,0.5,1,1] 40 | render_list = [] 41 | for i in range(4): 42 | renderer = vtk.vtkRenderer() 43 | render_list.append(renderer) 44 | 45 | window.AddRenderer(renderer) 46 | renderer.SetViewport(xmins[i],ymins[i],xmaxs[i],ymaxs[i]) 47 | 48 | # create plane source here 49 | plane_X = vtk.vtkImagePlaneWidget() 50 | plane_Y = vtk.vtkImagePlaneWidget() 51 | plane_Z = vtk.vtkImagePlaneWidget() 52 | 53 | plane_X.SetInteractor(interactor) 54 | plane_Y.SetInteractor(interactor) 55 | plane_Z.SetInteractor(interactor) 56 | plane_X.SetDefaultRenderer(render_list[0]) 57 | plane_Y.SetDefaultRenderer(render_list[1]) 58 | plane_Z.SetDefaultRenderer(render_list[2]) 59 | 60 | plane_X.SetCurrentRenderer(render_list[3]) 61 | plane_Y.SetCurrentRenderer(render_list[3]) 62 | plane_Z.SetCurrentRenderer(render_list[3]) 63 | 64 | plane_X.SetInputData(img) 65 | plane_Y.SetInputData(img) 66 | plane_Z.SetInputData(img) 67 | 68 | plane_X.SetPlaneOrientationToXAxes() 69 | plane_Y.SetPlaneOrientationToYAxes() 70 | plane_Z.SetPlaneOrientationToZAxes() 71 | 72 | plane_X.On() 73 | plane_Y.On() 74 | plane_Z.On() 75 | 76 | window.Render() 77 | interactor.Start() 78 | 79 | 80 | 81 | 82 | if __name__ == '__main__': 83 | #file_name = sys.argv[1] 84 | file_name = "E:/test/a1.nii" 85 | 86 | source = ReadNii(file_name) 87 | ImagePlaneDemo(source) 88 | 89 | 90 | -------------------------------------------------------------------------------- /vtkMousePick.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Author: QIN Shuo 3 | Date: 2015/11/10 4 | This is a example file for vtk 5 | Description: 6 | This file demostrate how to get the position of a 7 | picked point. 8 | 9 | 10 | Tips: 11 | 12 | 1. In class 13 | class MyStyle(vtk.vtkInteractorStyleImage): 14 | def __init__(self): 15 | pass 16 | def OnMouseWheelForward(self): 17 | pass 18 | 19 | the above method will not re-load the mouse wheel function 20 | the real functional method are applied by adding event observer 21 | Solution: 22 | Register this event: self.AddObserver(...) 23 | 24 | 2. AddObserver, Observer function conflict 25 | Solution: call RemoveObservers() first to unregister all event functions 26 | ''' 27 | 28 | 29 | import vtk 30 | 31 | 32 | drawing = vtk.vtkImageCanvasSource2D() 33 | drawing.SetScalarTypeToUnsignedChar() 34 | drawing.SetNumberOfScalarComponents(3) 35 | drawing.SetExtent(0,20,0,50,0,0) 36 | drawing.FillBox(0,20,0,50) 37 | 38 | 39 | drawing.SetDrawColor(255,0,0,0) 40 | drawing.DrawCircle(9,10,5) 41 | drawing.Update() 42 | 43 | actor = vtk.vtkImageActor() 44 | actor.GetMapper().SetInputData(drawing.GetOutput()) 45 | actor.InterpolateOff() 46 | 47 | renderer = vtk.vtkRenderer() 48 | renderWin = vtk.vtkRenderWindow() 49 | renderWin.AddRenderer(renderer) 50 | 51 | renderWinInteractor = vtk.vtkRenderWindowInteractor() 52 | renderWinInteractor.SetRenderWindow(renderWin) 53 | 54 | renderer.AddActor(actor) 55 | renderer.SetBackground(1,1,1) 56 | 57 | renderer.GradientBackgroundOn() 58 | renderer.SetBackground2(0,0,1) 59 | 60 | renderWin.Render() 61 | 62 | def LeftButtonPressEvent(obj,event): 63 | global renderWinInteractor 64 | global renderer 65 | picker = renderWinInteractor.GetPicker() 66 | print "indexs on window view is ", renderWinInteractor.GetEventPosition() 67 | picked = renderWinInteractor.GetPicker().GetSelectionPoint() 68 | print "coordinate on 2d plane view is", picked 69 | picker.Pick(renderWinInteractor.GetEventPosition()[0],renderWinInteractor.GetEventPosition()[1],0,renderer) 70 | picked = renderWinInteractor.GetPicker().GetPickPosition() 71 | print "3d position is ",picked 72 | 73 | 74 | renderWinInteractor.RemoveObservers(vtk.vtkCommand.LeftButtonPressEvent) # this line to solve event conflict 75 | renderWinInteractor.AddObserver(vtk.vtkCommand.LeftButtonPressEvent,LeftButtonPressEvent) 76 | renderWinInteractor.Initialize() 77 | 78 | vtk.vtkCommand.TDxButtonPressEvent 79 | 80 | renderWinInteractor.Start() 81 | 82 | 83 | -------------------------------------------------------------------------------- /vtkSmoothPolydata.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Author: QIN Shuo 3 | Date: 2017/6/15 4 | Organization: RC-MIC (CUHK) 5 | 6 | Description: 7 | Smooth vtkPolyData 8 | Reference: http://www.vtk.org/Wiki/VTK/Examples/Cxx/PolyData/SmoothPolyDataFilter 9 | ''' 10 | 11 | import vtk 12 | import random 13 | 14 | 15 | def create_poly(): 16 | points = vtk.vtkPoints() 17 | GridSize = 20 18 | z=0.0 19 | 20 | for x in range(-GridSize,GridSize): 21 | for y in range(-GridSize,GridSize): 22 | z = 0.05*x*x+0.05*y*y+ random.uniform(-1,1) 23 | points.InsertNextPoint(x,y,z) 24 | 25 | # add the grid points to a polydata object 26 | inputPoly = vtk.vtkPolyData() 27 | inputPoly.SetPoints(points) 28 | delaunay = vtk.vtkDelaunay2D() 29 | delaunay.SetInputData(inputPoly) 30 | delaunay.Update() 31 | return delaunay.GetOutput() 32 | 33 | # smooth fileter core 34 | def smoothPoly(poly,num_iter = 15,rlx_factor=0.1): 35 | ''' 36 | http://www.vtk.org/doc/nightly/html/classvtkSmoothPolyDataFilter.html 37 | ''' 38 | smoothFilter = vtk.vtkSmoothPolyDataFilter() 39 | smoothFilter.SetInputData(poly) 40 | smoothFilter.SetNumberOfIterations(num_iter) 41 | smoothFilter.SetRelaxationFactor(rlx_factor) 42 | smoothFilter.FeatureEdgeSmoothingOff() 43 | #smoothFilter.FeatureEdgeSmoothingOn() 44 | smoothFilter.BoundarySmoothingOff() 45 | #smoothFilter.BoundarySmoothingOff() 46 | smoothFilter.Update() 47 | return smoothFilter.GetOutput() 48 | 49 | 50 | def smoothPoly2(poly,iter = 15,feature_angle=120,pass_band=0.001): 51 | ''' 52 | http://www.vtk.org/doc/nightly/html/classvtkWindowedSincPolyDataFilter.html#details 53 | ''' 54 | smoother = vtk.vtkWindowedSincPolyDataFilter() 55 | smoother.SetInputData(poly) 56 | smoother.SetNumberOfIterations(iter) 57 | smoother.BoundarySmoothingOff() 58 | smoother.FeatureEdgeSmoothingOff() 59 | smoother.SetFeatureAngle(feature_angle) 60 | smoother.SetPassBand(pass_band) 61 | smoother.NonManifoldSmoothingOn() 62 | smoother.NormalizeCoordinatesOn() 63 | smoother.Update() 64 | return smoother.GetOutput() 65 | 66 | def vis_poly(poly): 67 | mapper = vtk.vtkPolyDataMapper() 68 | mapper.SetInputData(poly) 69 | actor = vtk.vtkActor() 70 | actor.SetMapper(mapper) 71 | renderer = vtk.vtkRenderer() 72 | renderer.AddActor(actor) 73 | win = vtk.vtkRenderWindow() 74 | win.AddRenderer(renderer) 75 | renderer.ResetCamera() 76 | interactor = vtk.vtkRenderWindowInteractor() 77 | win.SetInteractor(interactor) 78 | interactor.Start() 79 | 80 | if __name__ == "__main__": 81 | poly = create_poly() 82 | polys = smoothPoly(poly) 83 | vis_poly(polys) 84 | 85 | 86 | -------------------------------------------------------------------------------- /vtkLayeredRenderers.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Author: QIN Shuo 3 | Date: 2015/12/18 4 | Description: 5 | 6 | 7 | Function: 8 | Overlay display of 2 images using 2 layered renderers 9 | 10 | ''' 11 | 12 | import vtk 13 | 14 | 15 | #class my_style(vtk.vtkInteractorStyleImage): 16 | class my_style(vtk.vtkInteractorStyle): 17 | def __init__(self): 18 | # register interactor callback 19 | self.AddObserver('MouseWheelForwardEvent',self.xOnMouseWheelForward) 20 | self.AddObserver('MouseWheelBackwardEvent',self.xOnMouseWheelBackward) 21 | 22 | # index 23 | self.ori_index = [0,0,0] 24 | self.ori_direction = [1,1,1] #cosine 25 | self.cur_index = [0,0,0] 26 | self.cur_direction = [1,1,1] #cosine 27 | #define reslice fileter 28 | self.reslicer = vtk.vtkImageReslice() 29 | self.reslicer.SetOutputDimensionality(2) #output 2D resliced image 30 | self.reslicer.SetResliceAxesDirectionCosines([0,0,0,0,0,0,0,0,0])#(self.cur_direction[1],self.cur_direction[1],self.cur_direction[1]) 31 | self.reslicer.SetResliceAxesOrigin(0,0,0)#(self.cur_index) 32 | self.reslicer.SetInterpolationModeToLinear() 33 | 34 | def SetImage(self,img): 35 | self.reslicer.SetInputData(img) 36 | 37 | def SetSlice(self,x,y,z): 38 | self.cur_direction = [x,y,z] 39 | 40 | def xOnMouseWheelForward(self,bj,event): 41 | print("Mouse Wheel Forward") 42 | #self.reslicer.Update() 43 | def xOnMouseWheelBackward(self,obj,event): 44 | print("Mouse Wheel Backward") 45 | #self.reslicer.Update() 46 | 47 | sphere = vtk.vtkSphereSource() 48 | sphere.Update() 49 | 50 | sphereMpper = vtk.vtkPolyDataMapper() 51 | sphereMpper.SetInputData(sphere.GetOutput()) 52 | 53 | sphereActor = vtk.vtkActor() 54 | sphereActor.SetMapper(sphereMpper) 55 | 56 | textSource = vtk.vtkVectorText() 57 | textSource.SetText("TXT") 58 | textSource.Update() 59 | 60 | textMapper = vtk.vtkPolyDataMapper() 61 | textMapper.SetInputData(textSource.GetOutput()) 62 | 63 | textActor = vtk.vtkActor() 64 | textActor.SetMapper(textMapper) 65 | 66 | 67 | renderer1 = vtk.vtkRenderer() 68 | renderer2 = vtk.vtkRenderer() 69 | 70 | #layer index 71 | renderer1.SetLayer(0) 72 | renderer2.SetLayer(1) 73 | 74 | # apply identical camera to 2 renderers 75 | renderer2.SetActiveCamera(renderer1.GetActiveCamera()) 76 | 77 | renderWin = vtk.vtkRenderWindow() 78 | renderWin.AddRenderer(renderer1) 79 | renderWin.AddRenderer(renderer2) 80 | 81 | interactor = vtk.vtkRenderWindowInteractor() 82 | interactor.SetRenderWindow(renderWin) 83 | #style = vtk.vtkInteractorStyleTrackballActor() 84 | style = my_style() 85 | interactor.SetInteractorStyle(style) 86 | 87 | renderer1.AddActor(sphereActor) 88 | renderer2.AddActor(textActor) 89 | 90 | renderWin.SetNumberOfLayers(2) 91 | renderer1.ResetCamera() 92 | renderWin.Render() 93 | interactor.Start() 94 | 95 | 96 | -------------------------------------------------------------------------------- /MeshReader/MeshReader.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | __author__ = 'Qin Shuo' 4 | 5 | import vtk 6 | import string 7 | 8 | class PyMeshReader(object): 9 | def __init__(self): 10 | print('PyMeshReader constructed') 11 | self.polyData = vtk.vtkPolyData() 12 | self.Property = {} 13 | pass 14 | 15 | def ReadFile(self,filename): 16 | self.filename = filename 17 | if self.filename == '': 18 | print('file name is null') 19 | return 20 | print('reading file ', filename) 21 | self.Points = vtk.vtkPoints() 22 | self.Cells = vtk.vtkCellArray() 23 | 24 | #begin to read plain text file 25 | fp = open(self.filename,'r+') 26 | 27 | #iterate through lines in file 28 | line = fp.readline() 29 | while line != '': 30 | #split string 31 | line = line.strip('\n') 32 | lis = line.split('=') 33 | #condition1: points 34 | if lis[0].strip() == 'Points': 35 | #set number of points 36 | self.NPoints = int(self.Property['NPoints']) 37 | self.Points.SetNumberOfPoints(self.NPoints) 38 | #read points data 39 | for cnt in range(1,self.NPoints+1): 40 | #exclude space and new line 41 | point_list = fp.readline().strip() 42 | #split array 43 | point_list = point_list.split(' ') 44 | #add data to points 45 | self.Points.SetPoint(int(point_list[0]),float(point_list[1]),float(point_list[2]),float(point_list[3])) 46 | 47 | #condition2: cells 48 | elif lis[0].strip() == 'Cells': 49 | self.NCells = int(self.Property['NCells']) 50 | for cnt in range(1,self.NCells+1): 51 | #exclude space and new line 52 | cell_list = fp.readline().strip() 53 | #split list 54 | cell_list = cell_list.split(' ') 55 | #add data to cells 56 | self.Cells.InsertNextCell(3) 57 | self.Cells.InsertCellPoint(int(cell_list[1])) 58 | self.Cells.InsertCellPoint(int(cell_list[2])) 59 | self.Cells.InsertCellPoint(int(cell_list[3])) 60 | 61 | #condition3: properties 62 | else: 63 | self.Property[lis[0].strip()] = lis[1].strip() 64 | 65 | #read next line and back into the loolp 66 | line = fp.readline() 67 | 68 | 69 | fp.close() #close file 70 | print('reading done ...') 71 | #construct poly data 72 | self.polyData.SetPoints(self.Points) 73 | self.polyData.SetPolys(self.Cells) 74 | 75 | def GetObject(self): 76 | print('Get mesh object') 77 | return self.polyData 78 | 79 | -------------------------------------------------------------------------------- /vtkSlidebar.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Author: QIN Shuo 3 | Date: 2015/11/10 4 | This is a example file for vtk 5 | Function: Create a sphere and control its PhiResolution and ThetaResolution with vtk slide bar 6 | 7 | In C++ way, you can use call back function in 2 ways 8 | reference: http://www.vtk.org/Wiki/VTK/Tutorials/Callbacks 9 | 10 | When I tried creating a vtkCallbackCommand and reimplement it, python crushed. 11 | So the other way to add a callback function to interactor is used and work well 12 | ''' 13 | 14 | import vtk 15 | 16 | sphereSource = vtk.vtkSphereSource() 17 | sphereSource.SetCenter(0.0,0.0,0.0) 18 | sphereSource.SetRadius(4.0) 19 | sphereSource.Update() 20 | 21 | mapper = vtk.vtkPolyDataMapper() 22 | mapper.SetInputData(sphereSource.GetOutput()) 23 | 24 | 25 | actor = vtk.vtkActor() 26 | actor.SetMapper(mapper) 27 | actor.GetProperty().SetInterpolationToFlat() 28 | 29 | renderer = vtk.vtkRenderer() 30 | renderWin = vtk.vtkRenderWindow() 31 | renderWin.AddRenderer(renderer) 32 | 33 | renWinInteractor = vtk.vtkRenderWindowInteractor() 34 | renWinInteractor.SetRenderWindow(renderWin) 35 | 36 | renderer.AddActor(actor) 37 | renderWin.Render() 38 | 39 | #build a slide bar 40 | slideBar = vtk.vtkSliderRepresentation2D() 41 | 42 | slideBar.SetMinimumValue(3.0) 43 | slideBar.SetMaximumValue(20.0) 44 | slideBar.SetTitleText("sphere") 45 | 46 | slideBar.GetSliderProperty().SetColor(1,0,0) 47 | slideBar.GetTitleProperty().SetColor(1,0,0) 48 | slideBar.GetLabelProperty().SetColor(1,0,0) 49 | slideBar.GetSelectedProperty().SetColor(1,0,0) 50 | slideBar.GetTubeProperty().SetColor(0,1,0) 51 | slideBar.GetCapProperty().SetColor(1,1,0) 52 | 53 | slideBar.GetPoint1Coordinate().SetCoordinateSystemToDisplay() 54 | slideBar.GetPoint1Coordinate().SetValue(40,40) 55 | 56 | slideBar.GetPoint2Coordinate().SetCoordinateSystemToDisplay() 57 | slideBar.GetPoint2Coordinate().SetValue(100,40) 58 | 59 | sliderWidget = vtk.vtkSliderWidget() 60 | sliderWidget.SetInteractor(renWinInteractor) 61 | sliderWidget.SetRepresentation(slideBar) 62 | sliderWidget.EnabledOn() 63 | 64 | 65 | # callback function for slide bar 66 | # !!! this class is invalid and will cause crash 67 | class vtkSliderCallback(vtk.vtkCommand): 68 | def __init__(self): 69 | pass 70 | def Execute(self,obj,event): 71 | slider = obj 72 | value1 = slider.GetRepresentation().GetValue() 73 | self.Sphere.SetPhiResolution(value1) 74 | self.Sphere.SetThetaResolution(value1) 75 | 76 | #callback = vtkSliderCallback() 77 | #callback.Sphere = sphereSource 78 | 79 | def myCallback(obj,event): 80 | print "interaction called" 81 | value = int (obj.GetRepresentation().GetValue()) 82 | global sphereSource 83 | sphereSource.SetPhiResolution(value) 84 | sphereSource.SetThetaResolution(value) 85 | sphereSource.Update() 86 | 87 | # please pay attention here: interactionEvent type must be added. 88 | # and 2 ways to add it are listed below(by name or by vtk command) 89 | #sliderWidget.AddObserver(vtk.vtkCommand.InteractionEvent,myCallback) 90 | sliderWidget.AddObserver("InteractionEvent",myCallback) 91 | 92 | 93 | renderer.ResetCamera() 94 | renWinInteractor.Initialize() 95 | renderWin.Render() 96 | 97 | 98 | renWinInteractor.Start() 99 | 100 | 101 | 102 | -------------------------------------------------------------------------------- /vtkPolydataReaders.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Author: Qin Shuo 3 | Date: 2016/03/22 4 | Description: 5 | This file demo some vtk Readers 6 | 7 | Support format: 8 | 1. .msh 9 | 2. .stl 10 | 11 | Format of .msh file 12 | |==============================| 13 | ObjectType = Scene 14 | NDims = 3 15 | NObjects = 1 16 | ObjectType = Mesh 17 | NDims = 3 18 | BinaryData = False 19 | TransformMatrix = 1 0 0 0 1 0 0 0 1 20 | Offset = 0 0 0 21 | CenterOfRotation = 0 0 0 22 | ElementSpacing = 1 1 1 23 | PointType = MET_FLOAT 24 | PointDataType = MET_DOUBLE 25 | CellDataType = MET_DOUBLE 26 | NCellTypes = 1 27 | PointDim = ID x y ... 28 | NPoints = 1127 29 | Points = 30 | 0 234.284 -0.390708 5 31 | 1 232.807 -0.651181 5 32 | 2 234.386 -0.769545 5 33 | ... 34 | CellType = TRI 35 | NCells = 2334 36 | Cells = 37 | 0 0 1 2 38 | 1 2 1 3 39 | 2 2 3 4 40 | ... 41 | EOF 42 | |==============================| 43 | ''' 44 | 45 | 46 | import vtk 47 | from QuickView import visualize_poly 48 | 49 | def Read_mesh(file_name): 50 | # read mesh file 51 | # suffix: .msh 52 | # msh file format: 53 | # read file head 54 | 55 | points = vtk.vtkPoints() 56 | polys = vtk.vtkCellArray() 57 | 58 | with open(file_name,'r') as file: 59 | while True: 60 | line = file.readline() 61 | if not line: 62 | break 63 | if line.find('Points')>=0: 64 | num_Points = int(line.split()[2]) 65 | print 'Number of points is {}'.format(num_Points) 66 | # put in to vtkPoints 67 | print 'Writing Points' 68 | points.SetNumberOfPoints(num_Points) 69 | file.readline() 70 | for i in range(0,num_Points): 71 | line = file.readline() 72 | if not line: 73 | break 74 | idx = line.split( ) 75 | x = float(idx[1]) 76 | y = float(idx[2]) 77 | z = float(idx[3]) 78 | points.SetPoint(i,x,y,z) 79 | 80 | if line.find('NCells')>=0: 81 | num_Triangles = int(line.split()[2]) 82 | print 'Number of Triangles is {}'.format(num_Triangles) 83 | # create cells 84 | print 'Writing Cells' 85 | file.readline() 86 | for i in range(0,num_Triangles): 87 | line = file.readline() 88 | if not line: 89 | break 90 | idx = line.split( ) 91 | a = int(idx[1]) 92 | b = int(idx[2]) 93 | c = int(idx[3]) 94 | polys.InsertNextCell(3) 95 | polys.InsertCellPoint(a) 96 | polys.InsertCellPoint(b) 97 | polys.InsertCellPoint(c) 98 | 99 | 100 | polyData = vtk.vtkPolyData() 101 | polyData.SetPoints(points) 102 | polyData.SetPolys(polys) 103 | return polyData 104 | 105 | 106 | def read_stl(filename): 107 | #vtk STL data reader 108 | # suffix: .stl 109 | reader = vtk.vtkSTLReader() 110 | reader.SetFileName(filename) 111 | reader.Update() 112 | return reader.GetOutput() 113 | 114 | 115 | 116 | 117 | if __name__ == '__main__': 118 | 119 | poly = Read_mesh('C:/Users/qinsh/OneDrive/Project/Navigation/navigation_backup/DATA/TrackerToolRepresentationMeshes/sProbe.msh') 120 | visualize_poly(poly) 121 | 122 | -------------------------------------------------------------------------------- /vtkOverlayDisplay.py: -------------------------------------------------------------------------------- 1 | 2 | ''' 3 | Author: QIN Shuo 4 | Date: 2015/12/18 5 | Description: 6 | 7 | 8 | Function: 9 | Overlay display of 2 images using 2 layered renderers 10 | 11 | ''' 12 | 13 | 14 | 15 | import vtk 16 | 17 | 18 | 19 | 20 | 21 | dir1 = '/home/qinshuo/Data/Data1' 22 | dir2 = '/home/qinshuo/Data/Data2' 23 | 24 | 25 | reader1 = vtk.vtkDICOMImageReader() 26 | reader1.SetDirectoryName(dir1) 27 | reader1.Update() 28 | img1 = reader1.GetOutput() 29 | 30 | reader2 = vtk.vtkDICOMImageReader() 31 | reader2.SetDirectoryName(dir2) 32 | reader2.Update() 33 | img2 = reader2.GetOutput() 34 | 35 | # reslice direction 36 | dir_X = [0,0,0] 37 | dir_Y = [0,0,0] 38 | dir_Z = [0,0,0] 39 | 40 | # reslice center 41 | extent1 = img1.GetExtent() 42 | print extent1 43 | extent2 = img2.GetExtent() 44 | print extent2 45 | center_X = extent1[1] if extent2[1]>extent1[1] else extent2[1] 46 | center_X = center_X/2 47 | center_Y = extent1[3] if extent2[3]>extent1[3] else extent2[3] 48 | center_Y = center_Y/2 49 | center_Z = extent1[5] if extent2[5]>extent1[5] else extent2[5] 50 | center_Z = center_Z/2 51 | 52 | # reslicer instance 53 | slicer1 = vtk.vtkImageReslice() 54 | slicer1.SetInputData(img1) 55 | slicer1.SetOutputDimensionality(2) 56 | slicer1.SetResliceAxesOrigin(center_X,center_Y,center_Z) 57 | slicer1.SetResliceAxesDirectionCosines(dir_X,dir_Y,dir_Z) 58 | 59 | 60 | slicer2 = vtk.vtkImageReslice() 61 | slicer2.SetInputData(img2) 62 | slicer2.SetOutputDimensionality(2) 63 | slicer2.SetResliceAxesOrigin(center_X,center_Y,center_Z) 64 | slicer2.SetResliceAxesDirectionCosines(dir_X,dir_Y,dir_Z) 65 | 66 | # lookup table 67 | ''' 68 | table = vtk.vtkWindowLevelLookupTable() 69 | range_l = img1.GetOutput().GetScalarRange[0] 70 | range_h = img1.GetOutput().GetScalarRange[1] 71 | print range_h 72 | print range_l 73 | ''' 74 | colorSeries = vtk.vtkColorSeries() 75 | colorSeriesEnum = colorSeries.BREWER_QUALITATIVE_SET3 76 | colorSeries.SetColorScheme(colorSeriesEnum) 77 | lut = vtk.vtkLookupTable() 78 | colorSeries.BuildLookupTable(lut) 79 | lut.SetNanColor(1,0,0,1) 80 | # 81 | lut = vtk.vtkWindowLevelLookupTable() 82 | lut.SetWindow(1000) 83 | lut.SetLevel(500) 84 | 85 | 86 | mapper1 = vtk.vtkDataSetMapper() 87 | mapper1.SetInputData(slicer1.GetOutput()) 88 | mapper1.SetLookupTable(lut) 89 | 90 | mapper2 = vtk.vtkDataSetMapper() 91 | mapper2.SetInputData(slicer2.GetOutput()) 92 | mapper2.SetLookupTable(lut) 93 | 94 | actor1 = vtk.vtkActor() 95 | actor1.SetMapper(mapper1) 96 | 97 | actor2 = vtk.vtkActor() 98 | actor2.SetMapper(mapper2) 99 | 100 | 101 | renderer = vtk.vtkRenderer() 102 | renWin = vtk.vtkRenderWindow() 103 | interactor = vtk.vtkRenderWindowInteractor() 104 | 105 | style = vtk.vtkInteractorStyleImage() 106 | style.SetInteractionModeToImageSlicing() 107 | interactor.SetInteractorStyle(style) 108 | 109 | renderer.AddActor(actor1) 110 | renderer.AddActor(actor2) 111 | 112 | renWin.AddRenderer(renderer) 113 | interactor.SetRenderWindow(renWin) 114 | 115 | def MouseWheelForwardCallback(obj,event): 116 | global slicer1 117 | global slicer2 118 | global renWin 119 | global center_Z,center_Y,center_X 120 | 121 | center_Z = center_Z+1 122 | 123 | slicer1.SetResliceAxesOrigin(center_X,center_Y,center_Z) 124 | slicer2.SetResliceAxesOrigin(center_X,center_Y,center_Z) 125 | slicer1.Update() 126 | slicer2.Update() 127 | renWin.Render() 128 | 129 | def MouseWheelBackwardCallback(obj,event): 130 | global slicer1 131 | global slicer2 132 | global renWin 133 | global center_Z,center_Y,center_X 134 | center_Z = center_Z-1 135 | slicer1.SetResliceAxesOrigin(center_X,center_Y,center_Z) 136 | slicer2.SetResliceAxesOrigin(center_X,center_Y,center_Z) 137 | slicer1.Update() 138 | slicer2.Update() 139 | renWin.Render() 140 | 141 | 142 | #interactor.AddObserver('MouseWheelForwardEvent',MouseWheelForwardCallback) 143 | #interactor.AddObserver('MouseWheelBackwardEvent',MouseWheelBackwardCallback) 144 | renWin.Render() 145 | interactor.Start() 146 | 147 | 148 | -------------------------------------------------------------------------------- /vtkManipulatePolyData.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Author: Qin Shuo 3 | Date: 2016/03/22 4 | Description: 5 | Demo: how to manipulate the poly data 6 | 1. xml poly data, .vtp format 7 | 8 | Main: vtk.vtkTransformFilter() 9 | ''' 10 | 11 | import string 12 | import vtk 13 | import sys 14 | 15 | def ReadPolyFile(filename): 16 | list = filename.split(".") 17 | surfix = list.pop() 18 | if surfix=="vtp": 19 | print "vtp file" 20 | 21 | #read vtp file here 22 | reader = vtk.vtkXMLPolyDataWriter() 23 | reader.SetFileName(filename) 24 | reader.Update() 25 | return reader.GetOutput() 26 | 27 | elif surfix == "stl": 28 | print "stl file" 29 | 30 | #read stl file here 31 | reader = vtk.vtkSTLReader() 32 | reader.SetFileName(filename) 33 | reader.Update() 34 | return reader.GetOutput() 35 | else: 36 | return 0 37 | 38 | 39 | def WriteSTL(obj,filname): 40 | writer = vtk.vtkSTLWriter() 41 | writer.SetFileName(filename) 42 | writer.SetInputData(obj) 43 | writer.Update() 44 | 45 | 46 | 47 | 48 | 49 | 50 | def vtkManipulatePolyData(filename): 51 | 52 | poly = ReadPolyFile(filename) 53 | mapper = vtk.vtkPolyDataMapper() 54 | mapper.SetInputData(poly) 55 | actor = vtk.vtkActor() 56 | actor.SetMapper(mapper) 57 | 58 | 59 | # visualization 60 | print "visualizing..." 61 | 62 | renderer = vtk.vtkRenderer() 63 | renderer.AddActor(actor) 64 | window = vtk.vtkRenderWindow() 65 | window.AddRenderer(renderer) 66 | interactor = vtk.vtkRenderWindowInteractor() 67 | 68 | global pos_X 69 | global pos_Y 70 | global pos_Z 71 | global translate 72 | 73 | pos_X = 0 74 | pos_Y = 0 75 | pos_Z = 0 76 | translate = vtk.vtkTransform() 77 | 78 | # Main function to manipulate transform 79 | def KeyPressEvent(obj,event): 80 | global pos_X 81 | global pos_Y 82 | global pos_Z 83 | 84 | print("key pressed") 85 | key = obj.GetKeySym() 86 | if key == "Up": 87 | pos_Y = pos_Y+1 88 | print pos_Y 89 | pass 90 | elif key == "Down": 91 | pos_Y = pos_Y-1 92 | print pos_Y 93 | pass 94 | elif key == "Left": 95 | pos_X = pos_X+1 96 | print pos_X 97 | pass 98 | elif key == "Right": 99 | pos_X = pos_X-1 100 | print pos_X 101 | pass 102 | elif key == "1": 103 | pos_Z = pos_Z-1 104 | print pos_X 105 | pass 106 | elif key == "2": 107 | pos_Z = pos_Z-1 108 | print pos_Z 109 | pass 110 | elif key=="s": 111 | trans = vtk.vtkTransformFilter() 112 | trans.SetTransform(translate) 113 | trans.SetInputData(poly) 114 | trans.Update() 115 | # write 116 | writer = vtk.vtkSTLWriter() 117 | writer.SetInputData(trans.GetOutput()) 118 | pos = filename.rfind("/") 119 | new_name = filename[:pos+1]+"new_"+filename[pos+1:] 120 | print new_name 121 | writer.SetFileName(new_name) 122 | writer.Update() 123 | else: 124 | pass 125 | translate.Translate(pos_X,pos_Y,pos_Z) 126 | actor.SetUserTransform(translate) 127 | window.Render() 128 | 129 | 130 | interactor.AddObserver(vtk.vtkCommand.KeyPressEvent,KeyPressEvent) 131 | window.SetInteractor(interactor) 132 | 133 | window.Render() 134 | interactor.Start() 135 | 136 | 137 | 138 | 139 | 140 | 141 | if __name__ == '__main__': 142 | #file_name = sys.argv[1] 143 | #if len(sys.argv)<2: 144 | file_name = "E:/test/coil__2_s.stl" 145 | vtkManipulatePolyData(file_name) 146 | -------------------------------------------------------------------------------- /QuickView.py: -------------------------------------------------------------------------------- 1 | # Author: QIN Shuo 2 | # Date: 2015/10/27 3 | # This file implement a quick view class for ITK 4 | # The native quick view in ITK seems not to be exported to python 5 | # This script is transformed strictly depend on ITK C++ source file 6 | 7 | 8 | #import itk 9 | import vtk 10 | import sys 11 | 12 | class QuickView: 13 | def __init__(self,ImageType): 14 | self.m_ImageType = ImageType 15 | self.m_ShareCamera = True 16 | self.m_Interpolate = True 17 | self.m_Counter = 0 18 | self.m_Snapshot = False 19 | self.m_SnapshotPath = "" 20 | self.m_SnapshotPrefix = "snapshot_" 21 | self.m_SnapshotExtension = "png" 22 | self.i2vConnector = itk.ImageToVTKImageFilter[self.m_ImageType] 23 | 24 | def AddImage(self,image): 25 | #rescal image 26 | UC_Type = itk.Image[itk.UC,2] 27 | rescalType = itk.RescaleIntensityImageFilter[self.m_ImageType,UC_Type] 28 | rescaler = rescalType.New() 29 | rescaler.SetOutputMinimum(0) 30 | rescaler.SetOutputMaximum(255) 31 | rescaler.SetInput(image) 32 | #flip verticle 33 | flipper = itk.FlipImageFilter[self.m_ImageType].New() 34 | flipAxes = itk.FixedArray[itk.B,2]() 35 | flipAxes.SetElement(0,False) 36 | flipAxes.SetElement(1,True) 37 | #flipAxes.SetElement(2,False) 38 | flipper.SetFlipAxes(flipAxes) 39 | flipper.SetInput(image) 40 | flipper.Update() 41 | self.m_Image = flipper.GetOutput() 42 | 43 | 44 | def Visualize(self): 45 | renderSize = 300; 46 | numberOfImages = 1; #implement only one image visulization 47 | 48 | # Setup the render window and interactor 49 | renderWindow = vtk.vtkRenderWindow() 50 | renderWindow.SetSize(renderSize * numberOfImages, renderSize) 51 | 52 | interactor = vtk.vtkRenderWindowInteractor() 53 | interactor.SetRenderWindow(renderWindow) 54 | 55 | style = vtk.vtkInteractorStyleImage() 56 | interactor.SetInteractorStyle(style) 57 | 58 | # Render all of the images 59 | background = [0.4,0.5,0.6] 60 | 61 | sharedCamera = vtk.vtkCamera() 62 | actor = vtk.vtkImageActor() 63 | 64 | #connect itk image to vtk image 65 | connector = self.i2vConnector.New() 66 | connector.SetInput(self.m_Image) 67 | 68 | actor.SetInput(connector.GetOutput()) 69 | 70 | renderer = vtk.vtkRenderer() 71 | renderWindow.AddRenderer(renderer) 72 | #renderer.SetViewpint() 73 | renderer.SetBackground(background) 74 | 75 | 76 | # start visualization 77 | renderer.AddActor(actor) 78 | renderer.ResetCamera() 79 | 80 | renderWindow.Render() 81 | 82 | # start interactor 83 | interactor.Start() 84 | 85 | # implement with vtkImageViewer2 86 | # vtkImageViewer2 provide no slice change when scroll mouse 87 | # implement callback function or use vtkResliceImageViewer 88 | def Visualize2(self): 89 | #connect itk image to vtk image 90 | connector = self.i2vConnector.New() 91 | connector.SetInput(self.m_Image) 92 | 93 | viewer2 = vtk.vtkImageViewer2() 94 | viewer2.SetInput(connector.GetOutput()) 95 | 96 | interactor = vtk.vtkRenderWindowInteractor() 97 | viewer2.SetupInteractor(interactor) 98 | viewer2.Render() 99 | viewer2.GetRenderer().ResetCamera() 100 | viewer2.Render() 101 | 102 | interactor.Start() 103 | 104 | 105 | 106 | def visualize_poly(*poly): 107 | def create_actor(poly): 108 | mapper = vtk.vtkPolyDataMapper() 109 | mapper.SetInputData(poly) 110 | actor = vtk.vtkActor() 111 | actor.SetMapper(mapper) 112 | return actor 113 | 114 | actor_list = [] 115 | for pp in poly: 116 | actor_list.append(create_actor(pp)) 117 | 118 | 119 | renderer = vtk.vtkRenderer() 120 | for actor in actor_list: 121 | renderer.AddActor(actor) 122 | 123 | renWin = vtk.vtkRenderWindow() 124 | renWin.AddRenderer(renderer) 125 | interactor = vtk.vtkRenderWindowInteractor() 126 | renWin.SetInteractor(interactor) 127 | interactor.Start() 128 | -------------------------------------------------------------------------------- /vtkMousePickAddBall.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Author: QIN Shuo 3 | Date: 2016/6/24 4 | Organization: RC-MIC (CUHK) 5 | 6 | Description: 7 | Mouse pick a position 8 | Press a key to get the position information 9 | Add a ball in the selected position 10 | 11 | SubSystem: 12 | TMS Navigation 13 | 14 | ''' 15 | 16 | 17 | 18 | 19 | import vtk 20 | import sys 21 | 22 | 23 | # Input: a vtkSTL object 24 | class vtkMousePickAddBall(): 25 | def __init__(self,model): 26 | print "Put the mouse to desired position and press \"h\" to add a ball" 27 | print "Press \"s\" to save the scene as a picture" 28 | self.screen_name = "ttt.png" 29 | self.renderer = vtk.vtkRenderer() 30 | self.renWin = vtk.vtkRenderWindow() 31 | self.interactor = vtk.vtkRenderWindowInteractor() 32 | 33 | 34 | mapper = vtk.vtkPolyDataMapper() 35 | mapper.SetInputData(model) 36 | self.modelActor = vtk.vtkActor() 37 | self.modelActor.SetMapper(mapper) 38 | 39 | 40 | ball = vtk.vtkSphereSource() 41 | ball.SetCenter(0.0,0.0,0.0) 42 | ball.SetThetaResolution(50) 43 | ball.SetRadius(5.0) 44 | ball.Update() 45 | ballMapper = vtk.vtkPolyDataMapper() 46 | ballMapper.SetInputData(ball.GetOutput()) 47 | self.ballActor = vtk.vtkActor() 48 | self.ballActor.SetMapper(ballMapper) 49 | self.ballActor.GetProperty().SetColor(1,0,0) 50 | 51 | self.txtActor = vtk.vtkTextActor() 52 | self.renderer.AddActor(self.txtActor) 53 | 54 | self.renderer.AddActor(self.ballActor) 55 | self.renderer.AddActor(self.modelActor) 56 | 57 | self.registerCallbacks() 58 | self.renWin.AddRenderer(self.renderer) 59 | self.interactor.SetRenderWindow(self.renWin) 60 | self.interactor.Start() 61 | pass 62 | 63 | 64 | def registerCallbacks(self): 65 | def keyPressEvent(obj,event): 66 | key = obj.GetKeySym() 67 | print key 68 | # translation 69 | if key == "h": 70 | print "key is ",key 71 | coor = self.interactor.GetEventPosition() 72 | print "coordinate is ", coor # coordinate in 2d view 73 | self.interactor.GetPicker().Pick(self.interactor.GetEventPosition()[0],self.interactor.GetEventPosition()[1],0,self.renderer) 74 | picked = self.interactor.GetPicker().GetPickPosition() 75 | print "position is ",picked # this is the true 3d coordinate 76 | point = self.interactor.GetPicker().GetSelectionPoint() 77 | print "point is", point # coordinate in 2d view 78 | 79 | # translation 80 | transform = vtk.vtkTransform() 81 | transform.Translate(picked) 82 | self.ballActor.SetUserTransform(transform) 83 | 84 | # add text 85 | text = str(picked) 86 | self.vtkSetText(text) 87 | self.renWin.Render() 88 | elif key=="s": 89 | self.vtkSavePicture(self.screen_name) 90 | 91 | else: 92 | pass 93 | 94 | self.interactor.AddObserver(vtk.vtkCommand.KeyPressEvent,keyPressEvent) 95 | pass 96 | 97 | 98 | # Input: 99 | # text: a string to be add to view 100 | def vtkSetText(self, text): 101 | self.txtActor.SetInput(text) 102 | self.txtActor.SetPosition2(10,40); 103 | self.txtActor.GetTextProperty().SetFontSize ( 24 ); 104 | self.txtActor.GetTextProperty().SetColor ( 1.0, 0.0, 0.0 ); 105 | self.renWin.Render() 106 | pass 107 | 108 | 109 | def SetScreeShotName(self,name): 110 | self.screen_name = name 111 | 112 | # Input: 113 | # filename: a string, filename 114 | def vtkSavePicture(self,filename): 115 | renderWindow = self.renWin 116 | shot = vtk.vtkWindowToImageFilter() 117 | shot.SetInputData(renderWindow) 118 | shot.SetMagnification(3) 119 | shot.SetInputBufferTypeToRGBA() 120 | shot.ReadFrontBufferOff() 121 | shot.Update() 122 | 123 | # write 124 | writer = vtk.vtkPNGWriter() 125 | writer.SetFileName(filename) 126 | writer.SetInputData(shot.GetOutput()) 127 | writer.Update() 128 | pass 129 | 130 | pass 131 | 132 | 133 | 134 | 135 | 136 | 137 | if __name__ == '__main__': 138 | if len(sys.argv)<2: 139 | print "Please Specify input and output file" 140 | file_name = "E:/test/coil__2_s.stl" 141 | else: 142 | file_name = sys.argv[1] 143 | 144 | reader = vtk.vtkSTLReader() 145 | reader.SetFileName(file_name) 146 | reader.Update() 147 | 148 | vtkMousePickAddBall(reader.GetOutput()) 149 | -------------------------------------------------------------------------------- /vtkThreshold.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Author: QIN Shuo 3 | Date: 2016/01/28 4 | 5 | This is a example to threshold a CT image 6 | 7 | Add plane widget 8 | 9 | Key interact to adjust the threshold 10 | 11 | MarchingCube to visiualize 3D model 12 | ''' 13 | 14 | 15 | import os 16 | import vtk 17 | 18 | 19 | # load data block 20 | def LoadNifti( name ): 21 | reader = vtk.vtkNIFTIImageReader() 22 | reader.SetFileName(name); 23 | reader.Update() 24 | return reader.GetOutput() 25 | 26 | def CreateSlider(renWinInteractor,plane,y): 27 | #build a slide bar 28 | slideBar = vtk.vtkSliderRepresentation2D() 29 | 30 | slideBar.SetMinimumValue(3.0) 31 | slideBar.SetMaximumValue(20.0) 32 | slideBar.SetTitleText("sphere") 33 | 34 | slideBar.GetSliderProperty().SetColor(1,0,0) 35 | slideBar.GetTitleProperty().SetColor(1,0,0) 36 | slideBar.GetLabelProperty().SetColor(1,0,0) 37 | slideBar.GetSelectedProperty().SetColor(1,0,0) 38 | slideBar.GetTubeProperty().SetColor(0,1,0) 39 | slideBar.GetCapProperty().SetColor(1,1,0) 40 | 41 | slideBar.GetPoint1Coordinate().SetCoordinateSystemToDisplay() 42 | slideBar.GetPoint1Coordinate().SetValue(40 ,40+y) 43 | slideBar.GetPoint2Coordinate().SetCoordinateSystemToDisplay() 44 | slideBar.GetPoint2Coordinate().SetValue(200,40+y) 45 | 46 | sliderWidget = vtk.vtkSliderWidget() 47 | sliderWidget.SetInteractor(renWinInteractor) 48 | sliderWidget.SetRepresentation(slideBar) 49 | sliderWidget.EnabledOn() 50 | 51 | def myCallback(obj,event): 52 | print obj.__class__.__name__," called" 53 | value = int (obj.GetRepresentation().GetValue()) 54 | plane.SetSliceIndex(value) 55 | 56 | sliderWidget.AddObserver("InteractionEvent",myCallback) 57 | 58 | win = vtk.vtkRenderWindow() 59 | 60 | #create visulization component 61 | def DisplayPoly(source,callback): 62 | global win 63 | 64 | polyMapper = vtk.vtkPolyDataMapper() 65 | polyMapper.SetInputData(source) 66 | 67 | actor = vtk.vtkActor() 68 | actor.SetMapper(polyMapper) 69 | 70 | renderer = vtk.vtkRenderer() 71 | intact = vtk.vtkRenderWindowInteractor() 72 | style = vtk.vtkInteractorStyleTrackballCamera() 73 | 74 | intact.AddObserver(vtk.vtkCommand.KeyPressEvent,callback) 75 | 76 | win.AddRenderer(renderer) 77 | renderer.AddActor(actor) 78 | intact.SetInteractorStyle(style) 79 | intact.SetRenderWindow(win) 80 | win.Render() 81 | intact.Start() 82 | 83 | 84 | def DisplayComponent(source): 85 | renderer = vtk.vtkRenderer() 86 | win = vtk.vtkRenderWindow() 87 | win.AddRenderer(renderer) 88 | style = vtk.vtkInteractorStyleImage() 89 | intact = vtk.vtkRenderWindowInteractor() 90 | intact.SetInteractorStyle(style) 91 | intact.SetRenderWindow(win) 92 | planeX = vtk.vtkImagePlaneWidget() 93 | planeY = vtk.vtkImagePlaneWidget() 94 | planeZ = vtk.vtkImagePlaneWidget() 95 | 96 | planeX.SetInteractor(intact) 97 | planeY.SetInteractor(intact) 98 | planeZ.SetInteractor(intact) 99 | 100 | planeX.SetInputData(source) 101 | planeY.SetInputData(source) 102 | planeZ.SetInputData(source) 103 | 104 | planeX.SetPlaneOrientationToXAxes() 105 | planeY.SetPlaneOrientationToYAxes() 106 | planeZ.SetPlaneOrientationToZAxes() 107 | 108 | planeX.On() 109 | planeY.On() 110 | planeZ.On() 111 | 112 | global pos 113 | pos = 1 114 | 115 | def myCallback(obj,event): 116 | global pos 117 | #print obj.__class__.__name__," called" 118 | key = obj.GetKeySym() 119 | if key=="Up": 120 | pos = pos+1 121 | planeX.SetSliceIndex(pos) 122 | print pos 123 | win.Render() 124 | else: 125 | pass 126 | intact.AddObserver(vtk.vtkCommand.KeyPressEvent,myCallback) 127 | 128 | intact.Start() 129 | 130 | 131 | # start main function 132 | 133 | name = "E:/test/spine.nii" 134 | 135 | if os.path.isfile(name): 136 | img = LoadNifti(name) 137 | else: 138 | print name, "is not a file" 139 | 140 | DisplayComponent(img) 141 | 142 | #threshold imagedata 143 | 144 | #threshold = vtk.vtkImageThreshold() 145 | #threshold.SetInputData(img) 146 | #lower = 500 147 | #upper = 1000 148 | #threshold.ThresholdBetween(lower,upper) 149 | #threshold.ReplaceOutOn() 150 | #threshold.SetOutValue(0) 151 | #threshold.Update() 152 | 153 | march = vtk.vtkMarchingCubes() 154 | march.SetInputData(img) 155 | march.GenerateValues(1,1200,1500) 156 | march.Update() 157 | 158 | value_u = 1500 159 | value_l = 1200 160 | def callback(obj,event): 161 | global value_l 162 | global value_u 163 | global win 164 | key = obj.GetKeySym() 165 | if key == "Up": 166 | value_l = value_l+50 167 | march.GenerateValues(1,value_l,value_u) 168 | march.Update() 169 | print (value_l) 170 | elif key == "Down": 171 | value_u = value_u-50 172 | march.GenerateValues(1,value_l,value_u) 173 | march.Update() 174 | print (value_u) 175 | else: 176 | pass 177 | win.Render() 178 | 179 | print "threshold" 180 | 181 | img_dis = march.GetOutput() 182 | 183 | # convert vtkImageData to vtkPolyData 184 | geometryFilter = vtk.vtkImageDataGeometryFilter() 185 | #geometryFilter.SetInputData(img_dis) 186 | #geometryFilter.Update() 187 | 188 | print "converted" 189 | 190 | DisplayPoly(img_dis,callback) 191 | 192 | 193 | 194 | 195 | 196 | -------------------------------------------------------------------------------- /vtkCombineToolandNormal.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Author: QIN Shuo 3 | Date: 2016/3/31 4 | Organization: RC-MIC (CUHK) 5 | 6 | Description: 7 | Function: Combine a coil model with a line (focus, normal) 8 | 9 | Filters: Combine 2 poly data // vtkAppendPolyData vtkCleanPolyData 10 | Create a poly source 11 | Compute normal 12 | Mouse select a position (mouse click callback) 13 | Transform a polydata(the focus line) 14 | Function: 15 | Click on a position, the second tool move to that position and record transform matrix.abs 16 | When the render window is closed, new file will be saved 17 | SubSystem: 18 | TMS Navigation 19 | 20 | ''' 21 | 22 | 23 | import vtk 24 | import sys 25 | import string 26 | 27 | # read stl function 28 | def ReadSTL(filename): 29 | reader = vtk.vtkSTLReader() 30 | reader.SetFileName(filename) 31 | reader.Update() 32 | return reader.GetOutput() 33 | 34 | # write stl function 35 | def WriteSTL(filename,stl): 36 | writer = vtk.vtkSTLWriter() 37 | writer.SetFileName(filename) 38 | writer.SetInputData(stl) 39 | writer.Update() 40 | 41 | 42 | # create a line source, format: vtkPolyData 43 | def CreateLine(): 44 | cylinder = vtk.vtkCylinderSource() 45 | cylinder.SetCenter(0,0,0) 46 | cylinder.SetRadius(1.0) 47 | cylinder.SetHeight(200) 48 | cylinder.SetResolution(100) 49 | cylinder.Update() 50 | source = cylinder.GetOutput() 51 | return source 52 | 53 | 54 | def TransformSTL(src,transform): 55 | trans = vtk.vtkTransformFilter() 56 | trans.SetTransform(transform) 57 | trans.SetInputData(src) 58 | trans.Update() 59 | return trans.GetOutput() 60 | 61 | 62 | def ConbineSource(coil,line): 63 | # combine 2 source 64 | appendFilter = vtk.vtkAppendPolyData() 65 | appendFilter.AddInputData(coil) 66 | appendFilter.AddInputData(line) 67 | appendFilter.Update() 68 | # remove duplicate points 69 | poly_clean = vtk.vtkCleanPolyData() 70 | poly_clean.SetInputData(appendFilter.GetOutput()) 71 | poly_clean.Update() 72 | 73 | tri = vtk.vtkTriangleFilter() 74 | tri.SetInputData(poly_clean.GetOutput()) 75 | tri.Update() 76 | 77 | geometryFilter = vtk.vtkGeometryFilter() 78 | geometryFilter.SetInputData(tri.GetOutput()) 79 | geometryFilter.Update() 80 | 81 | return geometryFilter.GetOutput() 82 | 83 | def Visualize(coil): 84 | line = CreateLine() 85 | line_mapper = vtk.vtkPolyDataMapper() 86 | line_mapper.SetInputData(line) 87 | global line_actor 88 | line_actor = vtk.vtkActor() 89 | line_actor.SetMapper(line_mapper) 90 | 91 | 92 | mapper = vtk.vtkPolyDataMapper() 93 | mapper.SetInputData(coil) 94 | 95 | actor = vtk.vtkActor() 96 | actor.SetMapper(mapper) 97 | 98 | global renderer 99 | global interactor 100 | 101 | renderer = vtk.vtkRenderer() 102 | renderer.AddActor(actor) 103 | renderer.AddActor(line_actor) 104 | win = vtk.vtkRenderWindow() 105 | win.AddRenderer(renderer) 106 | interactor = vtk.vtkRenderWindowInteractor() 107 | win.SetInteractor(interactor) 108 | 109 | def LeftButtonPressEvent(obj,event): 110 | global line_actor 111 | global interactor 112 | global renderer 113 | coor = interactor.GetEventPosition() 114 | print "coordinate is ", coor 115 | interactor.GetPicker().Pick(interactor.GetEventPosition()[0],interactor.GetEventPosition()[1],0,renderer) 116 | picked = interactor.GetPicker().GetPickPosition() 117 | print "position is ",picked 118 | point = interactor.GetPicker().GetSelectionPoint() 119 | print "point is", point 120 | 121 | # translation 122 | global transform 123 | transform = vtk.vtkTransform() 124 | transform.Translate(picked) 125 | line_actor.SetUserTransform(transform) 126 | 127 | 128 | def keyPressEvent(obj,event): 129 | global line_actor 130 | global interactor 131 | global renderer 132 | #key = .GetInteractor().GetKeySym() 133 | key = obj.GetKeySym() 134 | print key 135 | # translation 136 | if key == "h": 137 | print "key is ",key 138 | coor = interactor.GetEventPosition() 139 | print "coordinate is ", coor 140 | interactor.GetPicker().Pick(interactor.GetEventPosition()[0],interactor.GetEventPosition()[1],0,renderer) 141 | picked = interactor.GetPicker().GetPickPosition() 142 | print "position is ",picked 143 | point = interactor.GetPicker().GetSelectionPoint() 144 | print "point is", point 145 | 146 | # translation 147 | global transform 148 | transform = vtk.vtkTransform() 149 | transform.Translate(picked) 150 | line_actor.SetUserTransform(transform) 151 | win.Render() 152 | else: 153 | pass 154 | 155 | #interactor.AddObserver(vtk.vtkCommand.LeftButtonPressEvent,LeftButtonPressEvent) 156 | interactor.AddObserver(vtk.vtkCommand.KeyPressEvent,keyPressEvent) 157 | 158 | win.Render() 159 | interactor.Start() 160 | pass 161 | 162 | 163 | 164 | if __name__ == '__main__': 165 | if len(sys.argv)<2: 166 | print "Input Error: you must input 2 parameters" 167 | print "Para1: Source model file name, a .stl file" 168 | print "Para2: Output model file name, a .stl file" 169 | in_file = "E:/test/QinShuoTShapeM.stl" 170 | out_file = "E:/test/newQinShuoTShapeM.stl" 171 | else: 172 | in_file = sys.argv[1] 173 | out_file = sys.argv[2] 174 | 175 | print "Press \"h\" to append the line" 176 | 177 | print "Reading STL" 178 | coil = ReadSTL(in_file) 179 | 180 | print "Visulizing" 181 | Visualize(coil) 182 | 183 | print "Create a line source" 184 | line = CreateLine() 185 | 186 | print "Transforming the line source" 187 | t_line = TransformSTL(line,transform) 188 | 189 | print "Combing the coil and line" 190 | res = ConbineSource(coil,t_line) 191 | 192 | print "Writing to file: "+ out_file 193 | WriteSTL(out_file,res) 194 | 195 | 196 | -------------------------------------------------------------------------------- /vtkCreateShadows.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Author: QIN Shuo 3 | Date: 2015/12/17 4 | 5 | Description: 6 | Create shadows of an object 7 | 8 | Problems: 9 | vtkRenderer(valid in vtk5) && vtkOpenglRender(only solution in vtk6) 10 | 11 | 12 | ''' 13 | 14 | 15 | 16 | import sys 17 | import os 18 | import vtk 19 | import time 20 | 21 | 22 | def AddLightActor (r): 23 | if (r!=0): 24 | print('pre: r_exits') 25 | 26 | lights = r.GetLIghts() 27 | 28 | lights.InitTraversal() 29 | 30 | l = lights.GetNextItem() 31 | 32 | while(l!=0): 33 | angle = l.GetConeAngle() 34 | if(l.LIghtTypeIsSceneLight() and l.GetPositional() and angle<180. ): 35 | la = vtk.vtkLightActor() 36 | la.SetLight(l) 37 | r.AddViewProp(la) 38 | la.Delete 39 | 40 | l = lights .GetNextItem() 41 | 42 | 43 | 44 | 45 | interactor = vtk.vtkRenderWindowInteractor() 46 | renderWindow = vtk.vtkRenderWindow() 47 | 48 | renderWindow.SetSize(400,400) 49 | renderWindow .SetMultiSamples(0) 50 | renderWindow.SetAlphaBitPlanes(1) 51 | interactor.SetRenderWindow(renderWindow) 52 | 53 | renderer = vtk.vtkRenderer() 54 | 55 | renderWindow.AddRenderer(renderer) 56 | 57 | supported = vtk.vtkFrameBufferObject.IsSupported(renderWindow) 58 | 59 | if (not supported): 60 | print "returning" 61 | time.sleep(5) 62 | 63 | 64 | cameraP = vtk.vtkCameraPass() 65 | opaque = vtk.vtkOpaquePass() 66 | 67 | peeling = vtk.vtkDepthPeelingPass() 68 | peeling.SetMaximumNumberOfPeels(200) 69 | peeling.SetOcclusionRatio(0.1) 70 | 71 | 72 | translucent = vtk.vtkTranslucentPass() 73 | peeling.SetTranslucentPass(translucent) 74 | 75 | 76 | volume = vtk.vtkVolumetricPass() 77 | overlay = vtk.vtkOverlayPass() 78 | lights = vtk.vtkLightsPass() 79 | opaqueSequence = vtk.vtkSequencePass() 80 | pass2 = vtk.vtkRenderPassCollection() 81 | 82 | pass2.AddItem(lights) 83 | pass2.AddItem(opaque) 84 | opaqueSequence.SetPasses(pass2) 85 | 86 | opaqueCameraPass = vtk.vtkCameraPass() 87 | opaqueCameraPass.SetDelegatePass(opaqueSequence) 88 | 89 | shadowBaker = vtk.vtkShadowMapBakerPass() 90 | shadowBaker.SetOpaquePass(opaqueCameraPass) 91 | shadowBaker.SetResolution(1024) 92 | # to cancel self->shadowing 93 | shadowBaker.SetPolygonOffsetFactor(3.1) 94 | shadowBaker.SetPolygonOffsetUnits(10.0) 95 | 96 | shadows = vtk.vtkShadowMapPass() 97 | shadows.SetShadowMapBakerPass(shadowBaker) 98 | shadows.SetOpaquePass(opaqueSequence) 99 | 100 | seq = vtk.vtkSequencePass() 101 | passes = vtk.vtkRenderPassCollection() 102 | passes.AddItem(shadowBaker) 103 | passes.AddItem(shadows) 104 | passes.AddItem(lights) 105 | passes.AddItem(peeling) 106 | passes.AddItem(volume) 107 | passes.AddItem(overlay) 108 | seq.SetPasses(passes) 109 | cameraP.SetDelegatePass(seq) 110 | 111 | renderer.SetPass(cameraP) 112 | 113 | rectangleSource = vtk.vtkPlaneSource() 114 | rectangleSource.SetOrigin(-5.0,0.0,5.0) 115 | rectangleSource.SetPoint1(5.0,0.0,5.0) 116 | rectangleSource.SetPoint2(-5.0,0.0,-5.0) 117 | rectangleSource.SetResolution(100,100) 118 | 119 | rectMapper = vtk.vtkPolyDataMapper() 120 | rectMapper.SetInputData(rectangleSource.GetOutput()) 121 | rectMapper.SetScalarVisibility(0) 122 | 123 | rectActor = vtk.vtkActor() 124 | rectKeyProperty = vtk.vtkInformation() 125 | rectKeyProperty.Set(vtk.vtkShadowMapBakerPass.OCCLUDER(),0) 126 | rectKeyProperty.Set(vtk.vtkShadowMapBakerPass.RECEIVER(),0) 127 | rectActor.SetPropertyKeys(rectKeyProperty) 128 | 129 | rectActor.SetMapper(rectMapper) 130 | rectActor.SetVisibility(1); 131 | rectActor.GetProperty().SetColor(1,1,1); 132 | 133 | boxSource = vtk.vtkCubeSource() 134 | boxSource.SetXLength(2) 135 | 136 | boxNormals = vtk.vtkPolyDataNormals() 137 | boxNormals.SetInputData(boxSource.GetOutput()) 138 | boxNormals.SetComputePointNormals(0) 139 | boxNormals.SetComputeCellNormals(0) 140 | boxNormals.Update(); 141 | boxNormals.GetOutput().GetPointData().SetNormals(boxNormals) 142 | 143 | boxMapper = vtk.vtkPolyDataMapper() 144 | boxMapper.SetInputData(boxNormals.GetOutput()) 145 | boxMapper.SetScalarVisibility(0) 146 | 147 | boxActor = vtk.vtkActor() 148 | boxKeyProperty = vtk.vtkInformation() 149 | boxKeyProperty.Set(vtk.vtkShadowMapBakerPass.OCCLUDER(),0) 150 | boxKeyProperty.Set(vtk.vtkShadowMapBakerPass.RECEIVER(),0) 151 | boxActor.SetPropertyKeys(boxKeyProperty) 152 | 153 | boxActor.SetMapper(boxMapper) 154 | boxActor.SetVisibility(1) 155 | boxActor.SetPosition(-2.0,2.0,0.0) 156 | boxActor.GetProperty().SetColor(1.0,0.0,0.0) 157 | 158 | coneSource = vtk.vtkConeSource() 159 | coneSource.SetResolution(24) 160 | coneSource.SetDirection(1.0,1.0,1.0) 161 | coneMapper = vtk.vtkMapper() 162 | coneMapper.SetInputData(coneSource.GetOutput()) 163 | coneMapper.SetScalarVisibility(0) 164 | 165 | coneActor = vtk.vtkActor() 166 | coneKeyProperty = vtk.vtkInformation() 167 | coneKeyProperty.Set(vtk.vtkShadowMapBakerPass.OCCLUDER(),0) 168 | coneKeyProperty.Set(vtk.vtkShadowMapBakerPass.RECEIVER(),0) 169 | coneActor.SetPropertyKeys(coneKeyProperty) 170 | 171 | coneActor.SetMapper(coneMapper) 172 | coneActor.SetVisibility(1) 173 | coneActor.SetPosition(0.0,1.0,1.0) 174 | coneActor.GetProperty().SetColor(0,0,1); 175 | 176 | sphereSource = vtk.vtkSphereSource() 177 | sphereSource.SetThetaResolution(32) 178 | sphereSource.SetPhiResolution(32) 179 | sphereMapper = vtk.vtkMapper() 180 | sphereMapper.SetInputData(sphereSource.GetOutput()) 181 | sphereMapper.SetScalarVisibility(0) 182 | 183 | sphereActor = vtk.vtkActor() 184 | sphereKeyProperty = vtk.vtkInformation() 185 | sphereKeyProperty.Set(vtk.vtkShadowMapBakerPass.OCCLUDER(),0) 186 | sphereKeyProperty.Set(vtk.vtkShadowMapBakerPass.RECEIVER(),0) 187 | sphereActor.SetPropertyKeys(sphereKeyProperty) 188 | sphereActor.SetMapper(sphereMapper) 189 | 190 | sphereActor.SetVisibility(1) 191 | sphereActor.SetPosition(2,2,-1) 192 | sphereActor.GetProperty().SetColor(1,1,0) 193 | 194 | renderer.AddViewPro(rectActor) 195 | renderer.AddViewPro(boxActor) 196 | renderer.AddViewPro(coneActor) 197 | renderer.AddViewPro(sphereActor) 198 | 199 | l1 = vtk.vtkLight() 200 | l1.SetPosition(-4,4,-1) 201 | l1.SetFocalPOint(boxActor.GetPosition()) 202 | l1.SetColor(1,1,1) 203 | l1.SetPositional(1) 204 | renderer.AddLight(l1) 205 | l1.SetSwitch(1) 206 | 207 | l2 = vtk.vtkLight() 208 | l2.SetPosition(-4,5,1) 209 | l2.SetFocalPOint(sphereActor.GetPosition()) 210 | l2.SetColor(1,0,1) 211 | l2.SetPositional(1) 212 | renderer.AddLight(l2) 213 | l2.SetSwitch(1) 214 | 215 | 216 | AddLightActor(renderer) 217 | 218 | renderer.SetBackground(0.66,0.66,0.66) 219 | renderer.SetBackground2(157.0/255.0*0.66,186/255.0*0.66,192.0/255.0*0.66) 220 | renderer.SetGradientBackground(True) 221 | renderer.Render() 222 | 223 | if peeling.GetLastRenderingUsedDepthPeeling(): 224 | print "depth peeling was used" 225 | else: 226 | print "depth peeling was not used" 227 | 228 | renderer.ResetCamera() 229 | camera = vtk.vtkCamera() 230 | camera = renderer.GetActiveCamera() 231 | camera.Azimuth(40) 232 | camera.Elevation(10) 233 | 234 | renderWindow.Render() 235 | interactor.Start() 236 | 237 | 238 | 239 | 240 | 241 | -------------------------------------------------------------------------------- /vtkModifySTLOrientation.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Author: QIN Shuo 3 | Date: 2016/4/15 4 | Organization: RC-MIC (CUHK) 5 | 6 | Description: 7 | Function: Visualize the orientation of the model, 8 | Save the oriented model to file 9 | 10 | Filters: Combine 2 poly data // vtkAppendPolyData vtkCleanPolyData 11 | Create a poly source 12 | Compute normal 13 | Mouse select a position (mouse click callback) 14 | Transform a polydata(the focus line) 15 | 16 | SubSystem: 17 | TMS Navigation 18 | 19 | ''' 20 | 21 | 22 | import vtk 23 | import sys 24 | 25 | # read stl function 26 | def ReadSTL(filename): 27 | reader = vtk.vtkSTLReader() 28 | reader.SetFileName(filename) 29 | reader.Update() 30 | return reader.GetOutput() 31 | 32 | # write stl function 33 | def WriteSTL(filename,stl): 34 | writer = vtk.vtkSTLWriter() 35 | writer.SetFileName(filename) 36 | writer.SetInputData(stl) 37 | writer.Update() 38 | 39 | 40 | 41 | 42 | class QIN_Style(vtk.vtkInteractorStyleTrackballCamera ): 43 | def __init__(self,parent = None): 44 | #self.RemoveObserver("KeyPressEvent") 45 | self.RemoveObserver(vtk.vtkCommand.KeyPressEvent) 46 | #self.AddObserver("KeyPressEvent",self.keyPressEvent) 47 | self.AddObserver(vtk.vtkCommand.KeyPressEvent,self.keyPressEvent) 48 | self.pos_X = 0.0 49 | self.pos_Y = 0.0 50 | self.pos_Z = 0.0 51 | self.rot_X = 0.0 # rotation 52 | self.rot_Y = 0.0 # rotation 53 | self.rot_Z = 0.0 # rotation 54 | self.transform = vtk.vtkTransform() 55 | 56 | 57 | def SetActor(self,actor): 58 | self.Actor = actor 59 | 60 | def SetRenderer(self,renderer): 61 | self.Renderer = renderer 62 | 63 | def SetPolyData(self,poly): 64 | self.PolyData = poly 65 | 66 | def SetOutName(self,name): 67 | self.out_name = name 68 | 69 | def keyPressEvent(self,obj,event): 70 | key = self.GetInteractor().GetKeySym() 71 | # translation 72 | if key == "i": 73 | self.pos_Y = self.pos_Y+5 74 | print ("Y: ",self.pos_Y) 75 | elif key == "k": 76 | self.pos_Y = self.pos_Y-5 77 | print ("Y: ",self.pos_Y) 78 | elif key == "j": 79 | self.pos_X = self.pos_X+5 80 | print ("X: ",self.pos_X) 81 | elif key == "l": 82 | self.pos_X = self.pos_X-5 83 | print ("X: ",self.pos_X) 84 | elif key == "u": 85 | self.pos_Z = self.pos_Z+5 86 | print ("Z: ",self.pos_Z) 87 | elif key == "o": 88 | self.pos_Z = self.pos_Z-5 89 | print ("Z: ",self.pos_Z) 90 | ### rotation 91 | elif key == "z": 92 | self.rot_X = self.rot_X+5 93 | print ("rotation X: ",self.rot_X) 94 | elif key == "s": 95 | self.rot_X = self.rot_X-5 96 | print ("rotation X: ",self.rot_X) 97 | elif key == "a": 98 | self.rot_Y = self.rot_Y+5 99 | print ("rotation Y: ",self.rot_Y) 100 | elif key == "d": 101 | self.rot_Y = self.rot_Y-5 102 | print ("rotation Y: ",self.rot_Y) 103 | elif key == "c": 104 | self.rot_Z = self.rot_Z+5 105 | print ("rotation Z: ",self.rot_Z) 106 | elif key == "x": 107 | self.rot_Z = self.rot_Z-5 108 | print ("rotation Z: ",self.rot_Z) 109 | elif key == "Return": 110 | transformFilter = vtk.vtkTransformPolyDataFilter() 111 | transformFilter.SetInputData(self.PolyData) 112 | transformFilter.SetTransform(self.transform) 113 | transformFilter.Update() 114 | 115 | WriteSTL(self.out_name,transformFilter.GetOutput()) 116 | 117 | else: 118 | pass 119 | 120 | if self.rot_X > 360.0: 121 | self.rot_X = 0.0 122 | if self.rot_Z > 360.0: 123 | self.rot_Z = 0.0 124 | if self.rot_Y > 360.0: 125 | self.rot_Y = 0.0 126 | 127 | self.transform = vtk.vtkTransform() 128 | self.transform.Translate(self.pos_X,self.pos_Y,self.pos_Z) 129 | self.transform.RotateX(self.rot_X) 130 | self.transform.RotateY(self.rot_Y) 131 | self.transform.RotateZ(self.rot_Z) 132 | self.transform.Update() 133 | self.Actor.SetUserTransform(self.transform) 134 | 135 | self.GetInteractor().GetRenderWindow().Render() 136 | 137 | self.OnKeyPress() 138 | return 139 | 140 | pass 141 | 142 | 143 | 144 | # modify orientation 145 | def vtkModifySTLOrientation( poly, ori_X,ori_Y,ori_Z, pos_X,pos_Y,pos_Z): 146 | transform = vtk.vtkTransform() 147 | transform.RotateX(ori_X) 148 | transform.RotateY(ori_Y) 149 | transform.RotateZ(ori_Z) 150 | transform.Translate(pos_X,pos_Y,pos_Z) 151 | transform.Update() 152 | 153 | transformFilter = vtk.vtkTransformPolyDataFilter() 154 | transformFilter.SetInputData(poly) 155 | transformFilter.SetTransform(transform) 156 | transformFilter.Update() 157 | 158 | return transformFilter.GetOutput() 159 | 160 | 161 | # view orientation 162 | def Visualize_Orientation(model,out_file): 163 | # create coordinate actor 164 | axes_actor = vtk.vtkAxesActor() 165 | axes_actor.SetTotalLength(500.0,500.0,500.0) 166 | 167 | # create model actor 168 | model_mapper = vtk.vtkPolyDataMapper() 169 | model_mapper.SetInputData(model) 170 | model_actor = vtk.vtkActor() 171 | model_actor.SetMapper(model_mapper) 172 | 173 | 174 | global renderer 175 | global interactor 176 | 177 | renderer = vtk.vtkRenderer() 178 | renderer.AddActor(model_actor) 179 | renderer.AddActor(axes_actor) 180 | win = vtk.vtkRenderWindow() 181 | win.AddRenderer(renderer) 182 | interactor = vtk.vtkRenderWindowInteractor() 183 | 184 | interactor_style = QIN_Style() 185 | interactor_style.SetRenderer(renderer) 186 | interactor_style.SetActor(model_actor) 187 | interactor_style.SetPolyData(model) 188 | interactor_style.SetOutName(out_file) 189 | interactor.SetInteractorStyle(interactor_style) 190 | 191 | win.SetInteractor(interactor) 192 | win.Render() 193 | interactor.Start() 194 | pass 195 | 196 | 197 | 198 | if __name__ == '__main__': 199 | if len(sys.argv)<3: 200 | print "Input Error: you must input 2 parameters" 201 | print "Para1: Source model file name, a .stl file" 202 | print "Para2: Output model file name, a .stl file" 203 | if len(sys.argv)<2: 204 | in_file = "D:/data/transed.stl" 205 | out_file = "E:/test/newQinShuoTShapeM.stl" 206 | else: 207 | in_file = sys.argv[1] 208 | out_file = "" 209 | else: 210 | in_file = sys.argv[1] 211 | out_file = sys.argv[2] 212 | pass 213 | 214 | print "Fucntion:" 215 | print "Rotation: X axis: z + s " 216 | print " Y axis: a + d " 217 | print " Z axis: c + x \n" 218 | print "Moving: X axis: i + k " 219 | print " Y axis: j + l" 220 | print " Z axis: c + x" 221 | 222 | model = ReadSTL(in_file) 223 | 224 | Visualize_Orientation(model,out_file) 225 | 226 | -------------------------------------------------------------------------------- /vtkInteractors.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Author: 3 | pass QIN Shuo 4 | Date: 5 | pass 2015/12/18 6 | Description: 7 | pass 8 | This file demonstrate how to interact in vtk 9 | 10 | This file will employ 2 method (actually 2 similar 11 | mthod to achieve the goal): 12 | pass 13 | 1. Re-load vtkInteractorStyleImage, add observer 14 | to this class. 15 | 2. Define callback function and add observer to 16 | vtk window interactor. 17 | 18 | EventID are defined in vtkCommand class 19 | 20 | 21 | 22 | Tips: 23 | pass 24 | 25 | class MyStyle(vtk.vtkInteractorStyleImage): 26 | pass 27 | def __init__(self): 28 | pass 29 | pass 30 | def OnMouseWheelForward(self): 31 | pass 32 | pass 33 | 34 | the above method will not re-load the mouse wheel function 35 | the real functional method are applied by adding event observer 36 | 37 | 38 | Note: 39 | There is no vtkCallbackCommand in python 40 | ''' 41 | 42 | 43 | 44 | 45 | 46 | import vtk 47 | 48 | 49 | # define a interactor style that re-implement all event callback 50 | 51 | 52 | ''' 53 | inhert class format 54 | 55 | class new_style(vtk.vtkInteractorStyleImage): 56 | def __init__(self): 57 | self.AddObserver("NoEvent",self.e_new_NoEvent) # "OnEvent" is the name of vtkCommand ;"new_NoEvent" is user defined name, and should be implemented in the class 58 | # function name must different from that defined in vtkInteractorStyle 59 | # vtkCommand class, command ID defined by vtk default 60 | def new_NoEvent(self,obj,event): 61 | obj.GetSomething # get objects function 62 | 63 | self.e_GetInteractor().GetXXX() # functions found in vtkInteractorStyleUser class (refer to GetKeySym example) 64 | 65 | self.e_OnNoEvent() # this line is important, and the function is listed in vtkInteractorStyle class 66 | return # "return " is also badly needed 67 | ''' 68 | 69 | 70 | 71 | ############### Method 1 ################ 72 | # Re-implement vtkInteractorStyle 73 | class QIN_Style(vtk.vtkInteractorStyle): 74 | def __init__(self): 75 | self.AddObserver("NoEvent",self.e_NoEvent) 76 | self.AddObserver("AnyEvent",self.e_AnyEvent) 77 | self.AddObserver("DeleteEvent",self.e_DeleteEvent) 78 | self.AddObserver("StartEvent",self.e_StartEvent) 79 | self.AddObserver("EndEvent",self.e_EndEvent) 80 | self.AddObserver("RenderEvent",self.e_RenderEvent) 81 | self.AddObserver("ProgressEvent",self.e_ProgressEvent) 82 | self.AddObserver("PickEvent",self.e_PickEvent) 83 | self.AddObserver("StartPickEvent",self.e_StartPickEvent) 84 | self.AddObserver("EndPickEvent",self.e_EndPickEvent) 85 | self.AddObserver("AbortCheckEvent",self.e_AbortCheckEvent) 86 | self.AddObserver("ExitEvent",self.e_ExitEvent) 87 | self.AddObserver("LeftButtonPressEvent",self.e_LeftButtonPressEvent) 88 | self.AddObserver("LeftButtonReleaseEvent",self.e_LeftButtonReleaseEvent) 89 | self.AddObserver("MiddleButtonPressEvent",self.e_MiddleButtonPressEvent) 90 | self.AddObserver("MiddleButtonReleaseEvent",self.e_MiddleButtonReleaseEvent) 91 | self.AddObserver("RightButtonPressEvent",self.e_RightButtonPressEvent) 92 | self.AddObserver("RightButtonReleaseEvent",self.e_RightButtonReleaseEvent) 93 | self.AddObserver("EnterEvent",self.e_EnterEvent) 94 | self.AddObserver("LeaveEvent",self.e_LeaveEvent) 95 | self.AddObserver("KeyPressEvent",self.e_KeyPressEvent) 96 | self.AddObserver("KeyReleaseEvent",self.e_KeyReleaseEvent) 97 | self.AddObserver("CharEvent",self.e_CharEvent) 98 | self.AddObserver("ExposeEvent",self.e_ExposeEvent) 99 | self.AddObserver("ConfigureEvent",self.e_ConfigureEvent) 100 | self.AddObserver("TimerEvent",self.e_TimerEvent) 101 | self.AddObserver("MouseMoveEvent",self.e_MouseMoveEvent) 102 | self.AddObserver("MouseWheelForwardEvent",self.e_MouseWheelForwardEvent) 103 | self.AddObserver("MouseWheelBackwardEvent",self.e_MouseWheelBackwardEvent) 104 | self.AddObserver("ResetCameraEvent",self.e_ResetCameraEvent) 105 | self.AddObserver("ResetCameraClippingRangeEvent",self.e_ResetCameraClippingRangeEvent) 106 | self.AddObserver("ModifiedEvent",self.e_ModifiedEvent) 107 | self.AddObserver("WindowLevelEvent",self.e_WindowLevelEvent) 108 | self.AddObserver("StartWindowLevelEvent",self.e_StartWindowLevelEvent) 109 | self.AddObserver("EndWindowLevelEvent",self.e_EndWindowLevelEvent) 110 | self.AddObserver("ResetWindowLevelEvent",self.e_ResetWindowLevelEvent) 111 | self.AddObserver("SetOutputEvent",self.e_SetOutputEvent) 112 | self.AddObserver("ErrorEvent",self.e_ErrorEvent) 113 | self.AddObserver("WarningEvent",self.e_WarningEvent) 114 | self.AddObserver("StartInteractionEvent",self.e_StartInteractionEvent) 115 | self.AddObserver("InteractionEvent",self.e_InteractionEvent) 116 | self.AddObserver("EndInteractionEvent",self.e_EndInteractionEvent) 117 | self.AddObserver("EnableEvent",self.e_EnableEvent) 118 | self.AddObserver("DisableEvent",self.e_DisableEvent) 119 | self.AddObserver("CreateTimerEvent",self.e_CreateTimerEvent) 120 | self.AddObserver("DestroyTimerEvent",self.e_DestroyTimerEvent) 121 | self.AddObserver("PlacePointEvent",self.e_PlacePointEvent) 122 | self.AddObserver("PlaceWidgetEvent",self.e_PlaceWidgetEvent) 123 | self.AddObserver("CursorChangedEvent",self.e_CursorChangedEvent) 124 | self.AddObserver("ExecuteInformationEvent",self.e_ExecuteInformationEvent) 125 | self.AddObserver("RenderWindowMessageEvent",self.e_RenderWindowMessageEvent) 126 | self.AddObserver("WrongTagEvent",self.e_WrongTagEvent) 127 | self.AddObserver("StartAnimationCueEvent",self.e_StartAnimationCueEvent) 128 | self.AddObserver("AnimationCueTickEvent",self.e_AnimationCueTickEvent) 129 | self.AddObserver("EndAnimationCueEvent",self.e_EndAnimationCueEvent) 130 | self.AddObserver("VolumeMapperRenderProgressEvent",self.e_VolumeMapperRenderProgressEvent) 131 | self.AddObserver("VolumeMapperComputeGradientsEndEvent",self.e_VolumeMapperComputeGradientsEndEvent) 132 | self.AddObserver("VolumeMapperComputeGradientsProgressEvent",self.e_VolumeMapperComputeGradientsProgressEvent) 133 | self.AddObserver("VolumeMapperComputeGradientsStartEvent",self.e_VolumeMapperComputeGradientsStartEvent) 134 | self.AddObserver("WidgetModifiedEvent",self.e_WidgetModifiedEvent) 135 | self.AddObserver("WidgetValueChangedEvent",self.e_WidgetValueChangedEvent) 136 | self.AddObserver("WidgetActivateEvent",self.e_WidgetActivateEvent) 137 | self.AddObserver("UserEvent",self.e_UserEvent) 138 | 139 | def e_NoEvent(self,obj,event): 140 | pass 141 | def e_AnyEvent(self,obj,event): 142 | pass 143 | def e_DeleteEvent(self,obj,event): 144 | pass 145 | def e_StartEvent(self,obj,event): 146 | pass 147 | def e_EndEvent(self,obj,event): 148 | pass 149 | def e_RenderEvent(self,obj,event): 150 | pass 151 | def e_ProgressEvent(self,obj,event): 152 | pass 153 | def e_PickEvent(self,obj,event): 154 | pass 155 | def e_StartPickEvent(self,obj,event): 156 | pass 157 | def e_EndPickEvent(self,obj,event): 158 | pass 159 | def e_AbortCheckEvent(self,obj,event): 160 | pass 161 | def e_ExitEvent(self,obj,event): 162 | pass 163 | def e_LeftButtonPressEvent(self,obj,event): 164 | pass 165 | def e_LeftButtonReleaseEvent(self,obj,event): 166 | pass 167 | def e_MiddleButtonPressEvent(self,obj,event): 168 | pass 169 | def e_MiddleButtonReleaseEvent(self,obj,event): 170 | pass 171 | def e_RightButtonPressEvent(self,obj,event): 172 | pass 173 | def e_RightButtonReleaseEvent(self,obj,event): 174 | pass 175 | def e_EnterEvent(self,obj,event): 176 | pass 177 | def e_LeaveEvent(self,obj,event): 178 | pass 179 | def e_KeyPressEvent(self,obj,event): 180 | key = self.e_GetInteractor().GetKeySym() 181 | self.e_OnkeyRelease() # reload function 182 | #self.e_OnKeyDown() 183 | #self.e_OnKeyUp() 184 | #self.e_OnKeyPress() 185 | return 186 | def e_KeyReleaseEvent(self,obj,event): 187 | pass 188 | def e_CharEvent(self,obj,event): 189 | pass 190 | def e_ExposeEvent(self,obj,event): 191 | pass 192 | def e_ConfigureEvent(self,obj,event): 193 | pass 194 | def e_TimerEvent(self,obj,event): 195 | pass 196 | def e_MouseMoveEvent(self,obj,event): 197 | pass 198 | def e_MouseWheelForwardEvent(self,obj,event): 199 | pass 200 | def e_MouseWheelBackwardEvent(self,obj,event): 201 | pass 202 | def e_ResetCameraEvent(self,obj,event): 203 | pass 204 | def e_ResetCameraClippingRangeEvent (self,obj,event): 205 | pass 206 | def e_ModifiedEvent(self,obj,event): 207 | pass 208 | def e_WindowLevelEvent(self,obj,event): 209 | pass 210 | def e_StartWindowLevelEvent(self,obj,event): 211 | pass 212 | def e_EndWindowLevelEvent(self,obj,event): 213 | pass 214 | def e_ResetWindowLevelEvent(self,obj,event): 215 | pass 216 | def e_SetOutputEvent(self,obj,event): 217 | pass 218 | def e_ErrorEvent(self,obj,event): 219 | pass 220 | def e_WarningEvent(self,obj,event): 221 | pass 222 | def e_StartInteractionEvent(self,obj,event): 223 | pass 224 | def e_InteractionEvent(self,obj,event): 225 | pass 226 | def e_EndInteractionEvent(self,obj,event): 227 | pass 228 | def e_EnableEvent(self,obj,event): 229 | pass 230 | def e_DisableEvent(self,obj,event): 231 | pass 232 | def e_CreateTimerEvent(self,obj,event): 233 | pass 234 | def e_DestroyTimerEvent(self,obj,event): 235 | pass 236 | def e_PlacePointEvent(self,obj,event): 237 | pass 238 | def e_PlaceWidgetEvent(self,obj,event): 239 | pass 240 | def e_CursorChangedEvent(self,obj,event): 241 | pass 242 | def e_ExecuteInformationEvent(self,obj,event): 243 | pass 244 | def e_RenderWindowMessageEvent(self,obj,event): 245 | pass 246 | def e_WrongTagEvent(self,obj,event): 247 | pass 248 | def e_StartAnimationCueEvent(self,obj,event): 249 | pass 250 | def e_AnimationCueTickEvent(self,obj,event): 251 | pass 252 | def e_EndAnimationCueEvent(self,obj,event): 253 | pass 254 | def e_VolumeMapperRenderProgressEvent(self,obj,event): 255 | pass 256 | def e_VolumeMapperComputeGradientsEndEvent(self,obj,event): 257 | pass 258 | def e_VolumeMapperComputeGradientsProgressEvent(self,obj,event): 259 | pass 260 | def e_VolumeMapperComputeGradientsStartEvent(self,obj,event): 261 | pass 262 | def e_WidgetModifiedEvent(self,obj,event): 263 | pass 264 | def e_WidgetValueChangedEvent(self,obj,event): 265 | pass 266 | def e_WidgetActivateEvent(self,obj,event): 267 | pass 268 | def e_UserEvent(self,obj,event): 269 | pass 270 | 271 | # way1: create a interactorstyle and add it to interactor 272 | interactor1 = vtk.vtkRenderWindowInteractor() 273 | new_style = QIN_Style() 274 | interactor1.SetInteractorStyle(new_style) 275 | 276 | 277 | 278 | ################### Method 2 #################### 279 | # define global event call back function 280 | def NoEvent(obj,event): 281 | pass 282 | def AnyEvent(obj,event): 283 | pass 284 | def DeleteEvent(obj,event): 285 | pass 286 | def StartEvent(obj,event): 287 | pass 288 | def EndEvent(obj,event): 289 | pass 290 | def RenderEvent(obj,event): 291 | pass 292 | def ProgressEvent(obj,event): 293 | pass 294 | def PickEvent(obj,event): 295 | pass 296 | def StartPickEvent(obj,event): 297 | pass 298 | def EndPickEvent(obj,event): 299 | pass 300 | def AbortCheckEvent(obj,event): 301 | pass 302 | def ExitEvent(obj,event): 303 | pass 304 | def LeftButtonPressEvent(obj,event): 305 | pass 306 | def LeftButtonReleaseEvent(obj,event): 307 | pass 308 | def MiddleButtonPressEvent(obj,event): 309 | pass 310 | def MiddleButtonReleaseEvent(obj,event): 311 | pass 312 | def RightButtonPressEvent(obj,event): 313 | pass 314 | def RightButtonReleaseEvent(obj,event): 315 | pass 316 | def EnterEvent(obj,event): 317 | pass 318 | def LeaveEvent(obj,event): 319 | pass 320 | def KeyPressEvent(obj,event): 321 | key = obj.GetKeySym() 322 | pass 323 | def KeyReleaseEvent(obj,event): 324 | pass 325 | def CharEvent(obj,event): 326 | pass 327 | def ExposeEvent(obj,event): 328 | pass 329 | def ConfigureEvent(obj,event): 330 | pass 331 | def TimerEvent(obj,event): 332 | pass 333 | def MouseMoveEvent(obj,event): 334 | pass 335 | def MouseWheelForwardEvent(obj,event): 336 | pass 337 | def MouseWheelBackwardEvent(obj,event): 338 | pass 339 | def ResetCameraEvent(obj,event): 340 | pass 341 | def ResetCameraClippingRangeEvent (obj,event): 342 | pass 343 | def ModifiedEvent(obj,event): 344 | pass 345 | def WindowLevelEvent(obj,event): 346 | pass 347 | def StartWindowLevelEvent(obj,event): 348 | pass 349 | def EndWindowLevelEvent(obj,event): 350 | pass 351 | def ResetWindowLevelEvent(obj,event): 352 | pass 353 | def SetOutputEvent(obj,event): 354 | pass 355 | def ErrorEvent(obj,event): 356 | pass 357 | def WarningEvent(obj,event): 358 | pass 359 | def StartInteractionEvent(obj,event): 360 | pass 361 | def InteractionEvent(obj,event): 362 | pass 363 | def EndInteractionEvent(obj,event): 364 | pass 365 | def EnableEvent(obj,event): 366 | pass 367 | def DisableEvent(obj,event): 368 | pass 369 | def CreateTimerEvent(obj,event): 370 | pass 371 | def DestroyTimerEvent(obj,event): 372 | pass 373 | def PlacePointEvent(obj,event): 374 | pass 375 | def PlaceWidgetEvent(obj,event): 376 | pass 377 | def CursorChangedEvent(obj,event): 378 | pass 379 | def ExecuteInformationEvent(obj,event): 380 | pass 381 | def RenderWindowMessageEvent(obj,event): 382 | pass 383 | def WrongTagEvent(obj,event): 384 | pass 385 | def StartAnimationCueEvent(obj,event): 386 | pass 387 | def AnimationCueTickEvent(obj,event): 388 | pass 389 | def EndAnimationCueEvent(obj,event): 390 | pass 391 | def VolumeMapperRenderProgressEvent(obj,event): 392 | pass 393 | def VolumeMapperComputeGradientsEndEvent(obj,event): 394 | pass 395 | def VolumeMapperComputeGradientsProgressEvent(obj,event): 396 | pass 397 | def VolumeMapperComputeGradientsStartEvent(obj,event): 398 | pass 399 | def WidgetModifiedEvent(obj,event): 400 | pass 401 | def WidgetValueChangedEvent(obj,event): 402 | pass 403 | def WidgetActivateEvent(obj,event): 404 | pass 405 | def UserEvent(obj,event): 406 | pass 407 | 408 | # way2: add observer to interactor directly 409 | interactor2 = vtk.vtkRenderWindowInteractor() 410 | interactor2.AddObserver(vtk.vtkCommand.LeftButtonPressEvent,LeftButtonPressEvent) 411 | ''' 412 | vtkCommand contains many kinds of EndEvent (to name but a few) 413 | 1. LeftButtonPressEvent 414 | 2. RightButtonPressEvent 415 | 3. vtk.vtkCommand.MiddleButtonPressEvent 416 | 4. vtk.vtkCommand.KeyPressEvent 417 | 5. vtk.vtkCommand.KeyReleaseEvent 418 | ... 419 | ''' --------------------------------------------------------------------------------