def __init__(self, Mgr): self.Mgr = Mgr self.m_volumeInfo = None self.m_selectedIdx = None self.m_selectedImage = None # self.m_reverseSagittal = False # self.m_reverseAxial = False self.m_shoulderSide = 'L' self.m_orientation = None ##AXL:1, COR:0, SAG:2 #Selected Volume CFGS self.m_colorFunction = vtk.vtkColorTransferFunction() self.m_opacityFunction = vtk.vtkPiecewiseFunction() self.m_scalarRange = [0.0, 1.0] self.m_volumeProperty = vtk.vtkVolumeProperty() self.m_imageProperty = vtk.vtkImageProperty() self.m_imageProperty.SetInterpolationTypeToLinear() #Volume self.volume_data = vtk.vtkImageData() self.volume_cropper = vtk.vtkImageData() self.m_volumeMapper = vtk.vtkSmartVolumeMapper() self.m_volume = vtk.vtkVolume() self.m_resliceMapper = [0, 0, 0] self.m_resliceActor = [0, 0, 0] #Color MAp Volume self.m_bShowCAM = False self.m_bShowVolume = False self.m_colorMapMapper = vtk.vtkSmartVolumeMapper() self.m_colorMapVolume = vtk.vtkVolume() self.m_colorMapResliceMapper = [None, None, None] self.m_colorMapResliceActor = [None, None, None] self.resolution = 64 #Crop View self.croppingMapper = vtk.vtkImageSliceMapper() self.croppingActor = vtk.vtkImageSlice() for i in range(3): self.m_resliceMapper[i] = vtk.vtkImageSliceMapper() self.m_resliceActor[i] = vtk.vtkImageSlice() self.m_colorMapResliceMapper[i] = vtk.vtkImageSliceMapper() self.m_colorMapResliceActor[i] = vtk.vtkImageSlice() self.m_resliceActor[0].RotateY(90) self.m_resliceActor[1].RotateX(-90) self.m_colorMapResliceActor[0].RotateY(90) self.m_colorMapResliceActor[1].RotateX(-90) #Initialize self.SetPresetFunctions( self.Mgr.mainFrm.volumeWidget.GetCurrentColorIndex()) self.InitializeVolumeFunctions() self.InitializeClassActivationMap()
def __init__(self): super(DualFlouroSceneVisualizer, self).__init__() # Remove origin information self.xray_changer_1 = vtk.vtkImageChangeInformation() self.xray_changer_1.SetOutputOrigin(0, 0, 0) self.xray_changer_2 = vtk.vtkImageChangeInformation() self.xray_changer_2.SetOutputOrigin(0, 0, 0) self.ct_changer = vtk.vtkImageChangeInformation() self.ct_changer.SetOutputOrigin(0, 0, 0) # Setup mapper and actor for x-ray images self.xray_mapper_1 = vtk.vtkImageSliceMapper() self.xray_mapper_1.SetInputConnection( self.xray_changer_1.GetOutputPort()) self.xray_mapper_2 = vtk.vtkImageSliceMapper() self.xray_mapper_2.SetInputConnection( self.xray_changer_2.GetOutputPort()) self.xray_property = vtk.vtkImageProperty() self.xray_property.SetInterpolationTypeToNearest() self.xray_slice_1 = vtk.vtkImageSlice() self.xray_slice_1.SetMapper(self.xray_mapper_1) self.xray_slice_1.SetProperty(self.xray_property) self.xray_slice_2 = vtk.vtkImageSlice() self.xray_slice_2.SetMapper(self.xray_mapper_2) self.xray_slice_2.SetProperty(self.xray_property) self.marchingCubes = vtk.vtkImageMarchingCubes() self.marchingCubes.SetInputConnection(self.ct_changer.GetOutputPort()) self.marchingCubes.ComputeGradientsOn() self.marchingCubes.ComputeNormalsOn() self.marchingCubes.ComputeScalarsOn() self.marchingCubes.SetNumberOfContours(1) self.marchingCubes.SetValue(0, 0) self.ct_mapper = vtk.vtkPolyDataMapper() self.ct_mapper.SetInputConnection(self.marchingCubes.GetOutputPort()) self.ct_mapper.ScalarVisibilityOff() self.ct_actor = vtk.vtkActor() self.ct_actor.SetMapper(self.ct_mapper) self.ct_actor.GetProperty().SetInterpolationToGouraud() self.ct_actor.GetProperty().SetColor(GetRGBColor('antique_white')) self.renderer = vtk.vtkRenderer() self.renderer.AddViewProp(self.ct_actor) self.renderer.AddViewProp(self.xray_slice_1) self.renderer.AddViewProp(self.xray_slice_2) self.renderer.SetBackground(0.1, 0.2, 0.3) self.interactor = vtk.vtkRenderWindowInteractor() self.interactor_style = vtk.vtkInteractorStyleTrackballCamera() self.interactor.SetInteractorStyle(self.interactor_style)
def __init__(self): super(ImageSliceVisualizer, self).__init__() # Setup pipeline self.image_mapper = vtk.vtkImageSliceMapper() self.image_mapper.SliceAtFocalPointOn() self.image_mapper.SliceFacesCameraOn() self.image_property = vtk.vtkImageProperty() self.image_property.SetInterpolationTypeToNearest() self.image_slice = vtk.vtkImageSlice() self.image_slice.SetMapper(self.image_mapper) self.image_slice.SetProperty(self.image_property) self.renderer = vtk.vtkRenderer() self.renderer.AddActor2D(self.image_slice) self.interactor = vtk.vtkRenderWindowInteractor() self.interactor_style = vtk.vtkInteractorStyleImage() self.interactor_style.SetInteractionModeToImageSlicing() self.interactor_style.KeyPressActivationOn() self.interactor.SetInteractorStyle(self.interactor_style) # Add ability to switch between active layers self.interactor.AddObserver('KeyPressEvent', self._interactor_call_back, -1.0)
def addSliceZ(self): if not (self.toggleThreeSlicesFlag): return if not (self.Slices[2] == None): self.renderer.RemoveActor(self.Slices[2]) self.Slices[2] = None self.map3 = vtk.vtkImageSliceMapper() self.map3.BorderOn() self.map3.SliceAtFocalPointOff() self.map3.SliceFacesCameraOff() self.map3.SetOrientationToZ() if vtk.VTK_MAJOR_VERSION <= 5: self.map3.SetInput(self.TemplateReader.GetOutput()) else: self.map3.SetInputConnection(self.TemplateReader.GetOutputPort()) self.map3.SetSliceNumber(0) slice1 = vtk.vtkImageSlice() slice1.SetMapper(self.map3) slice1.GetProperty().SetColorWindow(self.vrange[1] - self.vrange[0]) slice1.GetProperty().SetColorLevel(0.5 * (self.vrange[0] + self.vrange[1])) self.Slices[2] = slice1 self.renderer.AddViewProp(slice1) self.renderWin.GetInteractor().Render()
def __init__(self, parent=None): QtWidgets.QMainWindow.__init__(self, parent) self.frame = QtWidgets.QFrame() self.vl = QtWidgets.QVBoxLayout() self.vtkWidget = QVTKRenderWindowInteractor(self.frame) self.vl.addWidget(self.vtkWidget) self.dicom_image_path = './IM-0008-0034.dcm' # '----------set up dicom reader---------------' self.dcmReader = vtk.vtkDICOMImageReader() self.dcmReader.SetDataByteOrderToLittleEndian() self.dcmReader.SetDirectoryName( r"D:\Users\user\Desktop\NTUCT\1323\Ct_Without_ContrastBrain - 1323\InnerEar_C_06_U70u_4" ) self.dcmReader.Update() # '----------init render---------------' self.ren = vtk.vtkRenderer() # '---------set up mapper----------' self.slice_mapper = vtk.vtkImageSliceMapper() self.slice_mapper.SetInputConnection(self.dcmReader.GetOutputPort()) # set random slice number # self.slice_mapper.SetSliceNumber(50) # set up image_slice self.image_slice = vtk.vtkImageSlice() self.image_slice.SetMapper(self.slice_mapper) # '-----set up window and level of image_slice----' # self.MinMax = self.dcmReader.GetOutput().GetScalarRange() # self.image_slice_property = self.image_slice.GetProperty() # self.image_slice_property.SetColorWindow(self.MinMax[1]) # self.image_slice_property.SetColorLevel((self.MinMax[1] - self.MinMax[0]) / 2) # self.image_slice.Update() # '---------set image_slice as input for renderer------' self.ren.AddViewProp(self.image_slice) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(self.dcmReader.GetOutputPort()) # # Create an actor # actor = vtk.vtkActor() # actor.SetMapper(mapper) # self.ren.AddActor(actor) self.vtkWidget.GetRenderWindow().AddRenderer(self.ren) self.iren = self.vtkWidget.GetRenderWindow().GetInteractor() self.ren.ResetCamera() self.frame.setLayout(self.vl) self.setCentralWidget(self.frame) self.show() self.iren.Initialize()
def extract_slice_gut(self, origin, tangent, normal, binormal): ''' This works but can't clip slice. ''' print(" ") print("---------- Image Extract Slice ----------") print("origin: " + str(origin)) print("tangent: " + str(tangent)) print("normal: " + str(normal)) print("binormal: " + str(binormal)) # Define the slice plane. slice_plane = vtk.vtkPlane() slice_plane.SetOrigin(origin[0], origin[1], origin[2]) slice_plane.SetNormal(tangent[0], tangent[1], tangent[2]) ## Create a mapper that slice a 3D image with an abitrary slice plane # and draw the results on the screen. # reslice_mapper = vtk.vtkImageResliceMapper() reslice_mapper.SetInputData(self.volume) reslice_mapper.SliceFacesCameraOff() reslice_mapper.SliceAtFocalPointOff() reslice_mapper.SetSlicePlane(slice_plane) reslice_mapper.Update() ## vtkImageSlice is used to represent an image in a 3D scene. # image_slice = vtk.vtkImageSlice() image_slice.SetMapper(reslice_mapper) image_slice.Update() self.graphics.add_actor(image_slice) print("Image slice: ") bounds = 6 * [0] image_slice.GetBounds(bounds) print(" Bounds: " + str(bounds)) #print(str(image_slice)) ## Show slice bounds. # imageBoundsCube = vtk.vtkCubeSource() imageBoundsCube.SetBounds(self.bounds) imageBoundsCube.Update() # cutter = vtk.vtkCutter() cutter.SetCutFunction(slice_plane) cutter.SetInputData(imageBoundsCube.GetOutput()) cutter.Update() cutterMapper = vtk.vtkPolyDataMapper() cutterMapper.SetInputData(cutter.GetOutput()) # planeBorder = vtk.vtkActor() planeBorder.GetProperty().SetColor(1.0, 1.0, 0) planeBorder.GetProperty().SetOpacity(1.0) planeBorder.GetProperty().SetLighting(0) planeBorder.GetProperty().SetLineWidth(4) planeBorder.SetMapper(cutterMapper) self.graphics.add_actor(planeBorder)
def Slicer2d(volume, size=(900, 900), bg=(0.6, 0.6, 0.7), zoom=1.3): """Create a 2D window with a single balck a nd white slice of a Volume, wich can be oriented arbitrarily in space. """ img = volume.imagedata() ren1 = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) im = vtk.vtkImageResliceMapper() im.SetInputData(img) im.SliceFacesCameraOn() im.SliceAtFocalPointOn() im.BorderOn() ip = vtk.vtkImageProperty() ip.SetInterpolationTypeToLinear() ia = vtk.vtkImageSlice() ia.SetMapper(im) ia.SetProperty(ip) ren1.AddViewProp(ia) ren1.SetBackground(bg) renWin.SetSize(size) iren = vtk.vtkRenderWindowInteractor() style = vtk.vtkInteractorStyleImage() style.SetInteractionModeToImage3D() iren.SetInteractorStyle(style) renWin.SetInteractor(iren) renWin.Render() cam1 = ren1.GetActiveCamera() cam1.ParallelProjectionOn() ren1.ResetCameraClippingRange() cam1.Zoom(zoom) renWin.Render() printc("Slicer2D tool", invert=1, c="m") printc( """Press SHIFT+Left mouse to rotate the camera for oblique slicing SHIFT+Middle mouse to slice perpendicularly through the image Left mouse and Drag to modify luminosity and contrast X to Reset to sagittal view Y to Reset to coronal view Z to Reset to axial view R to Reset the Window/Levels Q to Quit.""", c="m", ) iren.Start() return iren
def build(self): actor = vtk.vtkImageSlice() actor.SetMapper(self._mapper) actor.SetProperty(self._property) if self._transform is not None: actor.SetUserTransform(self._transform) actor.Update() return actor
def setWidgetView(self, widget): self.initView(self.parent.getData('fix'), widget) data = self.parent.getData() image_type = data.getITKImageType() self.image2 = data.getITKImage() self.space2 = data.getResolution().tolist() if len(self.space2) == 3: self.space2 = [float(x) / self.space2[-1] for x in self.space2] self.image2.SetSpacing(self.space2) shapeList = data.getData().shape y, x = shapeList[-2], shapeList[-1] itk_vtk_converter = itk.ImageToVTKImageFilter[image_type].New() itk_vtk_converter.SetInput(self.image2) image_resample = vtk.vtkImageResample() image_resample.SetInput(itk_vtk_converter.GetOutput()) self.renderer2 = vtk.vtkRenderer() self.render_window.AddRenderer(self.renderer2) self.reslice_mapper2 = vtk.vtkImageResliceMapper() self.reslice_mapper2.SetInput(image_resample.GetOutput()) self.reslice_mapper2.SliceFacesCameraOn() self.reslice_mapper2.SliceAtFocalPointOn() self.reslice_mapper2.JumpToNearestSliceOn() self.reslice_mapper2.BorderOff() self.reslice_mapper2.BackgroundOn() array = data.getData() self.minI2 = array.min() self.maxI2 = array.max() self.image_slice2 = vtk.vtkImageSlice() self.image_slice2.SetMapper(self.reslice_mapper2) image_property2 = vtk.vtkImageProperty() image_property2.SetColorWindow(self.maxI2 - self.minI2) image_property2.SetColorLevel((self.maxI2 + self.minI2) / 2.0) image_property2.SetAmbient(0.0) image_property2.SetDiffuse(1.0) image_property2.SetOpacity(1.0) image_property2.SetInterpolationTypeToLinear() self.image_slice2.SetProperty(image_property2) self.renderer2.AddViewProp(self.image_slice2) self.renderer.SetViewport(0, 0, 0.5, 1) self.renderer2.SetViewport(0.5, 0, 1, 1) self.renderer2.SetActiveCamera(self.camera) self.render_window.Render()
def image(file): reader = vtk.vtkNIFTIImageReader() reader.SetFileName(file) reader.Update() middle = 115 min = 0 max = 255 t = threshold(reader, 10, min, max) mapper = vtk.vtkImageSliceMapper() mapper.SliceAtFocalPointOn() mapper.SetInputConnection(t.GetOutputPort()) actor = vtk.vtkImageSlice() actor.SetMapper(mapper) return actor
def setup_projection(brain, renderer): slice_mapper = vtk.vtkImageResliceMapper() slice_mapper.SetInputConnection(brain.reader.GetOutputPort()) slice_mapper.SliceFacesCameraOn() slice_mapper.SliceAtFocalPointOn() slice_mapper.BorderOff() brain_image_prop = vtk.vtkImageProperty() brain_image_prop.SetOpacity(0.0) brain_image_prop.SetInterpolationTypeToLinear() image_slice = vtk.vtkImageSlice() image_slice.SetMapper(slice_mapper) image_slice.SetProperty(brain_image_prop) image_slice.GetMapper().SetInputConnection( brain.image_mapper.GetOutputPort()) renderer.AddViewProp(image_slice) return brain_image_prop
def __init__(self): self.colour = (0.0, 0.0, 1.0) self.opacity = 1 self.size = 15.0 self.orientation = "AXIAL" self.spacing = (1, 1, 1) if vtk.vtkVersion().GetVTKVersion() > '5.8.0': self.mapper = vtk.vtkImageSliceMapper() cursor_property = vtk.vtkImageProperty() cursor_property.SetInterpolationTypeToNearest() self.actor = vtk.vtkImageSlice() self.actor.SetMapper(self.mapper) self.actor.SetProperty(cursor_property) else: self.actor = vtk.vtkImageActor() self.mapper = None self._build_actor() self._calculate_area_pixels()
def AddViewProp(self, prop): rotateProp = vtk.vtkImageSlice() rotateProp.SetMapper(prop.GetMapper()) rotateProp.SetProperty(prop.GetProperty()) if self.viewType == 'AXL': rotateProp.RotateX(-90) elif self.viewType == 'SAG': rotateProp.RotateY(90) bounds = [ rotateProp.GetMaxXBound(), rotateProp.GetMaxYBound(), rotateProp.GetMaxZBound() ] super(E_SliceRenderer, self).AddViewProp(rotateProp) self.AddGuide(bounds)
def __init__(self): self.colour = (0.0, 0.0, 1.0) self.opacity = 1 self.size = 15.0 self.orientation = "AXIAL" self.spacing = (1, 1, 1) self.position = (0, 0, 0) if vtk.vtkVersion().GetVTKVersion() > '5.8.0': self.mapper = vtk.vtkImageSliceMapper() cursor_property = vtk.vtkImageProperty() cursor_property.SetInterpolationTypeToNearest() self.actor = vtk.vtkImageSlice() self.actor.SetMapper(self.mapper) self.actor.SetProperty(cursor_property) else: self.actor = vtk.vtkImageActor() self.mapper = None self._build_actor() self._calculate_area_pixels()
def open_File(self): self.reader = vtk.vtkNIFTIImageReader() self.reader.SetFileName('brain1.nii') self.reader.Update() #Data Processing self.size = self.reader.GetOutput().GetDimensions() center = self.reader.GetOutput().GetCenter() spacing = self.reader.GetOutput().GetSpacing() print('size:' + str(self.size)) print('center:' + str(center)) self.center_cam = (center[0], center[1], center[2]) #Get graysacle Range vrange = self.reader.GetOutput().GetScalarRange() #Set Image Slicer Mappers for each view self.map = vtk.vtkImageSliceMapper() self.map.BorderOn() self.map.SliceAtFocalPointOn() self.map.SliceFacesCameraOn() self.map.SetInputConnection(self.reader.GetOutputPort()) self.slice = vtk.vtkImageSlice() self.slice.SetMapper(self.map) self.slice.GetProperty().SetColorWindow(vrange[1] - vrange[0]) self.slice.GetProperty().SetColorLevel(0.5 * (vrange[0] + vrange[1])) self.ren.AddActor(self.slice) self.cam = self.ren.GetActiveCamera() self.cam.ParallelProjectionOn() self.cam.SetParallelScale(0.5 * spacing[1] * self.size[1]) self.cam.SetFocalPoint(self.center_cam[0], self.center_cam[1], self.center_cam[2]) print(self.center_cam) self.changeView() self.spinBox.setEnabled(True)
def updateSliceZ(self): if not (self.toggleThreeSlicesFlag): return if not (self.Slices[2] == None): self.renderer.RemoveActor(self.Slices[2]) self.Slices[2] = None self.map3.SetSliceNumber(self.SetZAxisValues) slice1 = vtk.vtkImageSlice() slice1.SetMapper(self.map3) slice1.GetProperty().SetColorWindow(self.vrange[1] - self.vrange[0]) slice1.GetProperty().SetColorLevel(0.5 * (self.vrange[0] + self.vrange[1])) self.Slices[2] = slice1 self.renderer.AddViewProp(slice1) self.renderWin.GetInteractor().Render()
def load_slice(image): im = vtk.vtkImageResliceMapper() im.SetInputConnection(image) im.BorderOff() plane = im.GetSlicePlane() plane.SetNormal(1.0, 0.0, 0.0) plane.SetOrigin(114, 114, 50) ip = vtk.vtkImageProperty() ip.SetColorWindow(2000) ip.SetColorLevel(500) ip.SetAmbient(0.0) ip.SetDiffuse(1.0) ip.SetOpacity(1.0) ip.SetInterpolationTypeToLinear() ia = vtk.vtkImageSlice() ia.SetMapper(im) ia.SetProperty(ip) return im, ia
def __init__(self, parent=None): Qt.QMainWindow.__init__(self, parent) self.frame = Qt.QFrame() self.vl = Qt.QVBoxLayout() self.vtkWidget = QVTKRenderWindowInteractor(self.frame) self.vl.addWidget(self.vtkWidget) self.sl = Qt.QSlider() self.sl.setMinimum(1.0) self.sl.setMaximum(200.0) self.sl.setValue(50.0) self.vl.addWidget(self.sl) self.sl.valueChanged.connect(self.valuechange) self.ren = vtk.vtkRenderer() self.vtkWidget.GetRenderWindow().AddRenderer(self.ren) self.iren = self.vtkWidget.GetRenderWindow().GetInteractor() style = vtk.vtkInteractorStyleImage() style.SetInteractionModeToImageSlicing() self.iren.SetInteractorStyle(style) # Read the image self.reader = vtk.vtkNIFTIImageReader() self.reader.SetFileName('brain1.nii') self.reader.Update() # SLICE Mapper :-) self.map = vtk.vtkImageSliceMapper() self.map.SetSliceNumber(50) self.map.SetInputConnection(self.reader.GetOutputPort()) # Put mapper into actor and actor into renderer slice = vtk.vtkImageSlice() slice.SetMapper(self.map) self.ren.AddActor(slice) self.frame.setLayout(self.vl) self.setCentralWidget(self.frame) self.show() self.iren.Initialize()
image2.SetDrawColor(0,255,255) image2.FillBox(0,size,0,size) pad2 = vtk.vtkImageWrapPad() pad2.SetInputConnection(image2.GetOutputPort()) pad2.SetOutputWholeExtent(0,size,0,size,0,10) pad2.Update() checkers = vtk.vtkImageCheckerboard() checkers.SetInput1Data(pad1.GetOutput()) checkers.SetInput2Data(pad2.GetOutput()) checkers.SetNumberOfDivisions(11,6,0) mapper=vtk.vtkImageSliceMapper() mapper.SetInputConnection(checkers.GetOutputPort()) mapper.SliceAtFocalPointOn() mapper.SliceFacesCameraOn() imageSlice = vtk.vtkImageSlice() imageSlice.SetMapper(mapper) imageSlice.GetProperty().SetColorLevel(127.5) imageSlice.GetProperty().SetColorWindow(255) renderer=vtk.vtkRenderer() renderer.AddViewProp(imageSlice) window=vtk.vtkRenderWindow() window.SetSize(size,size) window.AddRenderer(renderer) window.Render() pp = vtk.vtkPointPicker() cp = vtk.vtkCellPicker() p = vtk.vtkPicker() errors = 0
ip.SetOpacity(1.0) ip.SetInterpolationTypeToLinear() bounds = im.GetBounds() print bounds point = [0.5 * (bounds[0] + bounds[1]), 0.5 * (bounds[2] + bounds[3]), 0.5 * (bounds[4] + bounds[5])] print point camera = ren1.GetActiveCamera() camera.SetFocalPoint(point) point[2] += 50.0 camera.SetPosition(point) camera.ParallelProjectionOn() camera.SetParallelScale(5.0) ia = vtk.vtkImageSlice() ia.SetMapper(im) ia.SetProperty(ip) ren1.AddViewProp(ia) ren1.SetBackground(0.1, 0.2, 0.4) renWin.SetSize(300, 300) def CharCallback(obj, event): iren = renWin.GetInteractor() keycode = iren.GetKeyCode() if keycode == "s": # style.StartSpin(); style.StartWindowLevel() return
input1Mapper.SliceAtFocalPointOn() input1Mapper.SliceFacesCameraOn() input1Mapper.BorderOff() input1Mapper.SetNumberOfThreads(args.nThreads) input1Mapper.ResampleToScreenPixelsOn() input1Mapper.StreamingOn() image1Property = vtk.vtkImageProperty() image1Property.SetColorLevel(level[0]) image1Property.SetColorWindow(window[0]) image1Property.SetInterpolationTypeToCubic() image1Property.CheckerboardOn() image1Property.SetCheckerboardSpacing(args.divisions) image1Property.SetLayerNumber(1) input1Slice = vtk.vtkImageSlice() input1Slice.SetMapper(input1Mapper) input1Slice.SetProperty(image1Property) # Setup input2 Mapper + Property -> Slice input2Mapper = vtk.vtkImageResliceMapper() input2Mapper.SetInputConnection(reader2.GetOutputPort()) input2Mapper.SliceAtFocalPointOn() input2Mapper.SliceFacesCameraOn() input2Mapper.BorderOff() input2Mapper.SetNumberOfThreads(args.nThreads) input2Mapper.ResampleToScreenPixelsOn() input2Mapper.StreamingOn() image2Property = vtk.vtkImageProperty() image2Property.SetColorLevel(level[1])
inputMapper = vtk.vtkImageResliceMapper() inputMapper.SetInputConnection(inputReader.GetOutputPort()) inputMapper.SliceAtFocalPointOn() inputMapper.SliceFacesCameraOn() inputMapper.BorderOn() inputMapper.SetNumberOfThreads(args.nThreads) inputMapper.ResampleToScreenPixelsOn() inputMapper.StreamingOn() imageProperty = vtk.vtkImageProperty() imageProperty.SetColorLevel(args.level) imageProperty.SetColorWindow(args.window) imageProperty.SetLayerNumber(1) imageProperty.SetInterpolationTypeToNearest() inputSlice = vtk.vtkImageSlice() inputSlice.SetMapper(inputMapper) inputSlice.SetProperty(imageProperty) # Setup seg Mapper + Property -> Slice segImageProperty = vtk.vtkImageProperty() segImageProperty.SetLookupTable(segLUT) segImageProperty.UseLookupTableScalarRangeOn() segImageProperty.SetInterpolationTypeToLinear() segImageProperty.SetOpacity(args.opacity) segImageProperty.SetLayerNumber(2) segImageProperty.SetInterpolationTypeToNearest() segMapper = vtk.vtkImageResliceMapper() segMapper.SetInputConnection(segReader.GetOutputPort()) segMapper.SliceAtFocalPointOn()
def slice_view(image, index, width, height, zdir=2, polydata=[], colors=default_colors, transform=None, line_width=3, level_window=None, image_lut=None, interpolation="nearest"): """Return vtkRenderer for orthogonal image slice.""" # determine orientation of medical volume flip = [False, False, False] if transform: transform.Update() matrix = deep_copy(transform.GetMatrix()) try: from nibabel import aff2axcodes codes = aff2axcodes(matrix_to_affine(matrix)) except Exception: codes = ('L', 'A', 'S') if matrix.GetElement(0, 0) < 0: codes = 'R' if matrix.GetElement(1, 1) < 0: codes = 'P' if matrix.GetElement(2, 2) < 0: codes = 'I' if codes[0] == 'R': flip[0] = True if codes[1] == 'P': flip[1] = True if codes[2] == 'I': flip[2] = True dims = image.GetDimensions() axes = slice_axes(zdir) if width < 1: width = dims[axes[0]] if height < 1: height = dims[axes[1]] size = [1, 1, 1] size[axes[0]] = width size[axes[1]] = height if zdir == 2: up = (0, 1, 0) else: up = (0, 0, 1) spacing = image.GetSpacing() distance = 10. * spacing[zdir] focal_point = index_to_point(index, image.GetOrigin(), spacing) position = list(focal_point) if flip[zdir]: position[zdir] = position[zdir] - distance else: position[zdir] = position[zdir] + distance margin = 2 extent = cropping_region(index, axes, size[axes[0]] + margin, size[axes[1]] + margin) if flip[0] or flip[1] or flip[2]: flip_transform = vtk.vtkTransform() flip_transform.Translate(+focal_point[0], +focal_point[1], +focal_point[2]) flip_transform.Scale(-1. if flip[0] else 1., -1. if flip[1] else 1., -1. if flip[2] else 1.) flip_transform.Translate(-focal_point[0], -focal_point[1], -focal_point[2]) points_transform = vtk.vtkTransform() points_transform.SetMatrix(matrix) points_transform.PostMultiply() points_transform.Concatenate(flip_transform) else: flip_transform = None points_transform = None mapper = vtk.vtkImageSliceMapper() mapper.SetInputData(image) mapper.SetOrientation(zdir) mapper.SetSliceNumber(extent[2 * zdir]) mapper.SetCroppingRegion(extent) mapper.CroppingOn() mapper.Update() actor = vtk.vtkImageSlice() actor.SetMapper(mapper) if flip_transform: actor.SetUserTransform(flip_transform) prop = actor.GetProperty() interpolation = interpolation.lower() if interpolation in ("nn", "nearest"): prop.SetInterpolationTypeToNearest() elif interpolation == "linear": prop.SetInterpolationTypeToLinear() elif interpolation == "cubic": prop.SetInterpolationTypeToCubic() else: raise ValueError( "Invalid interpolation mode: {}".format(interpolation)) if not level_window: level_window = auto_level_window(image) prop.SetColorLevel(level_window[0]) prop.SetColorWindow(level_window[1]) if image_lut: prop.SetLookupTable(image_lut) prop.UseLookupTableScalarRangeOn() renderer = vtk.vtkRenderer() renderer.AddActor(actor) camera = renderer.GetActiveCamera() camera.SetViewUp(up) camera.SetPosition(position) camera.SetFocalPoint(focal_point) camera.SetParallelScale(.5 * max((size[axes[0]] - 1) * spacing[axes[0]], (size[axes[1]] - 1) * spacing[axes[1]])) camera.SetClippingRange(distance - .5 * spacing[zdir], distance + .5 * spacing[zdir]) camera.ParallelProjectionOn() # add contours of polygonal data intersected by slice plane if isinstance(polydata, vtk.vtkPolyData): polydata = [polydata] if isinstance(line_width, int): line_width = [line_width] if isinstance(colors[0], float): colors = [colors] for i in xrange(len(polydata)): if i < len(colors): color = colors[i] else: color = colors[-1] if i < len(line_width): width = line_width[i] else: width = line_width[-1] add_contour(renderer, plane=mapper.GetSlicePlane(), polydata=polydata[i], transform=points_transform, line_width=width, color=color) return renderer
volume_prop.SetColor(color_func) volume_prop.SetScalarOpacity(opac_func) volume_actor.SetMapper(volume_mapper) volume_actor.SetProperty(volume_prop) volume_actor.SetPosition([0, 0, 0]) volume_prop.ShadeOff() volume_prop.SetInterpolationTypeToLinear() volume_mapper.SetBlendModeToMaximumIntensity() image_prop = vtk.vtkImageProperty() slice_mapper = [] slice_actor = [] for i in range(3): slice_mapper.append(vtk.vtkImageSliceMapper()) slice_mapper[i].BorderOn() slice_actor.append(vtk.vtkImageSlice()) slice_mapper[i].SetOrientation(i) slice_actor[i].SetMapper(slice_mapper[i]) slice_actor[i].SetProperty(image_prop) def get_tmp_data(): return tmp_data def save_tmp_data(): np.savez_compressed(tmp_path, data=tmp_data, time=elapsed_time) def get_volume(idx=None):
im = vtk.vtkImageResliceMapper() im.SetInputConnection(reader.GetOutputPort()) im.SliceFacesCameraOn() im.SliceAtFocalPointOn() im.BorderOff() ip = vtk.vtkImageProperty() ip.SetColorWindow(2000) ip.SetColorLevel(1000) ip.SetAmbient(0.0) ip.SetDiffuse(1.0) ip.SetOpacity(1.0) ip.SetInterpolationTypeToLinear() ia = vtk.vtkImageSlice() ia.SetMapper(im) ia.SetProperty(ip) ren1.AddViewProp(ia) ren1.SetBackground(0.1, 0.2, 0.4) renWin.SetSize(300, 300) iren = vtk.vtkRenderWindowInteractor() style = vtk.vtkInteractorStyleImage() style.SetInteractionModeToImage3D() iren.SetInteractorStyle(style) renWin.SetInteractor(iren) # render the image renWin.Render()
gridReader.Update() # Setup input Mapper + Property -> Slice inputMapper = vtk.vtkImageSliceMapper() inputMapper.SetInputConnection(inputReader.GetOutputPort()) inputMapper.SliceAtFocalPointOn() inputMapper.SliceFacesCameraOn() inputMapper.BorderOff() imageProperty = vtk.vtkImageProperty() imageProperty.SetColorLevel(args.level) imageProperty.SetColorWindow(args.window) imageProperty.SetInterpolationTypeToLinear() imageProperty.SetLayerNumber(1) inputSlice = vtk.vtkImageSlice() inputSlice.SetMapper(inputMapper) inputSlice.SetProperty(imageProperty) # Determine an appropriate window/level for the grid scalarRange = [int(x) for x in gridReader.GetOutput().GetScalarRange()] window = scalarRange[1] - scalarRange[0]+1 level = (scalarRange[1] + scalarRange[0])/2 # Setup grid Mapper + Property -> Slice gridImageProperty = vtk.vtkImageProperty() gridImageProperty.SetOpacity(args.opacity) gridImageProperty.SetColorLevel(level) gridImageProperty.SetColorWindow(window) gridImageProperty.SetLayerNumber(2) gridImageProperty.SetInterpolationTypeToNearest()
def initView(self, data, widget): image_type = data.getITKImageType() self.image = data.getITKImage() self.space = data.getResolution().tolist() if len(self.space) == 3: self.space = [float(x) / self.space[-1] for x in self.space] self.image.SetSpacing(self.space) self.rescale_filter = itk.RescaleIntensityImageFilter[image_type, image_type].New() self.rescale_filter.SetOutputMinimum(0) self.rescale_filter.SetOutputMaximum(255) self.rescale_filter.SetInput(self.image) self.itk_vtk_converter = itk.ImageToVTKImageFilter[image_type].New() self.itk_vtk_converter.SetInput(self.rescale_filter.GetOutput()) self.image_resample = vtk.vtkImageResample() self.image_resample.SetInput(self.itk_vtk_converter.GetOutput()) data = self.parent.getData() image_type = data.getITKImageType() self.image2 = data.getITKImage() self.space2 = data.getResolution().tolist() if len(self.space2) == 3: self.space2 = [float(x) / self.space2[-1] for x in self.space2] self.image2.SetSpacing(self.space2) shapeList = data.getData().shape y, x = shapeList[-2], shapeList[-1] self.dimension = len(shapeList) == 2 self.rescale_filter2 = itk.RescaleIntensityImageFilter[image_type, image_type].New() self.rescale_filter2.SetOutputMinimum(0) self.rescale_filter2.SetOutputMaximum(255) self.rescale_filter2.SetInput(self.image2) self.itk_vtk_converter2 = itk.ImageToVTKImageFilter[image_type].New() self.itk_vtk_converter2.SetInput(self.rescale_filter2.GetOutput()) self.image_resample2 = vtk.vtkImageResample() self.image_resample2.SetInput(self.itk_vtk_converter2.GetOutput()) self.checkers = vtk.vtkImageCheckerboard() self.checkers.SetInput1(self.image_resample.GetOutput()) self.checkers.SetInput2(self.image_resample2.GetOutput()) self.division = 3 self.checkers.SetNumberOfDivisions(self.division, self.division, 0) self.renderer = vtk.vtkRenderer() self.render_window = widget.GetRenderWindow() self.render_window.AddRenderer(self.renderer) self.reslice_mapper = vtk.vtkImageResliceMapper() self.reslice_mapper.SetInput(self.checkers.GetOutput()) self.reslice_mapper.SliceFacesCameraOn() self.reslice_mapper.SliceAtFocalPointOn() self.reslice_mapper.JumpToNearestSliceOn() self.reslice_mapper.BorderOff() self.reslice_mapper.BackgroundOn() array = data.getData() self.minI = 0 self.maxI = 255 image_property = vtk.vtkImageProperty() image_property.SetColorWindow(self.maxI - self.minI) image_property.SetColorLevel((self.maxI + self.minI) / 2.0) image_property.SetAmbient(0.0) image_property.SetDiffuse(1.0) image_property.SetOpacity(1.0) image_property.SetInterpolationTypeToLinear() self.image_slice = vtk.vtkImageSlice() self.image_slice.SetMapper(self.reslice_mapper) self.image_slice.SetProperty(image_property) self.renderer.AddViewProp(self.image_slice) self.window_interactor = vtk.vtkRenderWindowInteractor() self.interactor_style = vtk.vtkInteractorStyleImage() self.interactor_style.SetInteractionModeToImage3D() self.window_interactor.SetInteractorStyle(self.interactor_style) self.render_window.SetInteractor(self.window_interactor) point_picker = vtk.vtkPointPicker() self.window_interactor.SetPicker(point_picker) self.render_window.GlobalWarningDisplayOff() self.render_window.Render() self.camera = self.renderer.GetActiveCamera() self.camera.ParallelProjectionOn() w, h = self.window_interactor.GetSize() if h * x * self.space[0] < w * y * self.space[1]: scale = y / 2.0 * self.space[1] else: scale = h * x * self.space[0] / 2.0 / w self.camera.SetParallelScale(scale) point = self.camera.GetFocalPoint() dis = self.camera.GetDistance() self.camera.SetViewUp(0, -1, 0) self.camera.SetPosition(point[0], point[1], point[2] - dis) self.renderer.ResetCameraClippingRange() # View of image self.view = 2 self.interactor_style.AddObserver("MouseMoveEvent", self.MouseMoveCallback) self.interactor_style.AddObserver("LeftButtonReleaseEvent", self.LeftButtonReleaseCallback) self.interactor_style.AddObserver("LeftButtonPressEvent", self.LeftButtonPressCallback) self.interactor_style.AddObserver("MiddleButtonPressEvent", self.MiddleButtonPressCallback) self.interactor_style.AddObserver("RightButtonPressEvent", self.RightButtonPressCallback) self.interactor_style.AddObserver("RightButtonReleaseEvent", self.RightButtonReleaseCallback) self.interactor_style.AddObserver("KeyPressEvent", self.KeyPressCallback) self.interactor_style.AddObserver("CharEvent", self.CharCallback) self.updateAfter() self.render_window.Render()
def TestDisplay(file1): """Display the output""" inpath = os.path.join(str(VTK_DATA_ROOT), "Data", file1) reader = vtk.vtkNIFTIImageReader() reader.SetFileName(inpath) reader.Update() size = reader.GetOutput().GetDimensions() center = reader.GetOutput().GetCenter() spacing = reader.GetOutput().GetSpacing() center1 = (center[0], center[1], center[2]) center2 = (center[0], center[1], center[2]) if size[2] % 2 == 1: center1 = (center[0], center[1], center[2] + 0.5*spacing[2]) if size[0] % 2 == 1: center2 = (center[0] + 0.5*spacing[0], center[1], center[2]) vrange = reader.GetOutput().GetScalarRange() map1 = vtk.vtkImageSliceMapper() map1.BorderOn() map1.SliceAtFocalPointOn() map1.SliceFacesCameraOn() map1.SetInputConnection(reader.GetOutputPort()) map2 = vtk.vtkImageSliceMapper() map2.BorderOn() map2.SliceAtFocalPointOn() map2.SliceFacesCameraOn() map2.SetInputConnection(reader.GetOutputPort()) slice1 = vtk.vtkImageSlice() slice1.SetMapper(map1) slice1.GetProperty().SetColorWindow(vrange[1]-vrange[0]) slice1.GetProperty().SetColorLevel(0.5*(vrange[0]+vrange[1])) slice2 = vtk.vtkImageSlice() slice2.SetMapper(map2) slice2.GetProperty().SetColorWindow(vrange[1]-vrange[0]) slice2.GetProperty().SetColorLevel(0.5*(vrange[0]+vrange[1])) ratio = size[0]*1.0/(size[0]+size[2]) ren1 = vtk.vtkRenderer() ren1.SetViewport(0,0,ratio,1.0) ren2 = vtk.vtkRenderer() ren2.SetViewport(ratio,0.0,1.0,1.0) ren1.AddViewProp(slice1) ren2.AddViewProp(slice2) cam1 = ren1.GetActiveCamera() cam1.ParallelProjectionOn() cam1.SetParallelScale(0.5*spacing[1]*size[1]) cam1.SetFocalPoint(center1[0], center1[1], center1[2]) cam1.SetPosition(center1[0], center1[1], center1[2] - 100.0) cam2 = ren2.GetActiveCamera() cam2.ParallelProjectionOn() cam2.SetParallelScale(0.5*spacing[1]*size[1]) cam2.SetFocalPoint(center2[0], center2[1], center2[2]) cam2.SetPosition(center2[0] + 100.0, center2[1], center2[2]) if "-I" in sys.argv: style = vtk.vtkInteractorStyleImage() style.SetInteractionModeToImageSlicing() iren = vtk.vtkRenderWindowInteractor() iren.SetInteractorStyle(style) renwin = vtk.vtkRenderWindow() renwin.SetSize(size[0] + size[2], size[1]) renwin.AddRenderer(ren1) renwin.AddRenderer(ren2) renwin.Render() if "-I" in sys.argv: renwin.SetInteractor(iren) iren.Initialize() iren.Start() return renwin
def VisualizeSegmentation(input_filename, segmentation_filename, window, level, nThreads, opacity): # Python 2/3 compatible input from six.moves import input # Read input for filename in [input_filename, segmentation_filename]: if not os.path.isfile(filename): os.sys.exit('[ERROR] Cannot find file \"{}\"'.format(filename)) # Set a minimum thread count nThreads = max(1, nThreads) # Max/min opacity opacity = max(0, opacity) opacity = min(1, opacity) # Read the input image_reader = get_vtk_reader(input_filename) if image_reader is None: os.sys.exit('[ERROR] Cannot find reader for file \"{}\"'.format( input_filename)) print('Reading input image ' + input_filename) image_reader.SetFileName(input_filename) image_reader.Update() # Read the segmentation seg_reader = get_vtk_reader(segmentation_filename) if seg_reader is None: os.sys.exit('[ERROR] Cannot find reader for file \"{}\"'.format( segmentation_filename)) print('Reading input image ' + segmentation_filename) seg_reader.SetFileName(segmentation_filename) seg_reader.Update() # Get scalar range for W/L and padding image_scalar_range = image_reader.GetOutput().GetScalarRange() # Determine if we need to autocompute the window/level if window <= 0: window = image_scalar_range[1] - image_scalar_range[0] level = (image_scalar_range[1] + image_scalar_range[0]) / 2 # Get data range seg_scalar_range = [ int(x) for x in seg_reader.GetOutput().GetScalarRange() ] if seg_scalar_range[0] < 0: os.sys.exit( "Segmentation image \"{}\" has values less than zero which cannot currently be handled. Exiting..." .format(segmentation_filename)) nLabels = seg_scalar_range[1] print("Segmented image has {} labels".format(nLabels)) # Setup LUT segLUT = vtk.vtkLookupTable() segLUT.SetRange(0, nLabels) segLUT.SetRampToLinear() segLUT.SetAlphaRange(1, 1) # Make it slightly transparent segLUT.Build() segLUT.SetTableValue(0, 0.0, 0.0, 0.0, 0.0) # Set zero to black, transparent # Setup input Mapper + Property -> Slice inputMapper = vtk.vtkImageResliceMapper() inputMapper.SetInputConnection(image_reader.GetOutputPort()) inputMapper.SliceAtFocalPointOn() inputMapper.SliceFacesCameraOn() inputMapper.BorderOn() inputMapper.SetNumberOfThreads(nThreads) inputMapper.ResampleToScreenPixelsOn() inputMapper.StreamingOn() imageProperty = vtk.vtkImageProperty() imageProperty.SetColorLevel(level) imageProperty.SetColorWindow(window) imageProperty.SetLayerNumber(1) imageProperty.SetInterpolationTypeToNearest() inputSlice = vtk.vtkImageSlice() inputSlice.SetMapper(inputMapper) inputSlice.SetProperty(imageProperty) # Setup seg Mapper + Property -> Slice segImageProperty = vtk.vtkImageProperty() segImageProperty.SetLookupTable(segLUT) segImageProperty.UseLookupTableScalarRangeOn() segImageProperty.SetInterpolationTypeToLinear() segImageProperty.SetOpacity(opacity) segImageProperty.SetLayerNumber(2) segImageProperty.SetInterpolationTypeToNearest() segMapper = vtk.vtkImageResliceMapper() segMapper.SetInputConnection(seg_reader.GetOutputPort()) segMapper.SliceAtFocalPointOn() segMapper.SliceFacesCameraOn() segMapper.BorderOn() segMapper.SetNumberOfThreads(nThreads) segMapper.ResampleToScreenPixelsOn() segMapper.StreamingOn() segSlice = vtk.vtkImageSlice() segSlice.SetProperty(segImageProperty) segSlice.SetMapper(segMapper) # Add everything to a vtkImageStack imageStack = vtk.vtkImageStack() imageStack.AddImage(inputSlice) imageStack.AddImage(segSlice) imageStack.SetActiveLayer(1) # Create Renderer -> RenderWindow -> RenderWindowInteractor -> InteractorStyle renderer = vtk.vtkRenderer() renderer.AddViewProp(imageStack) renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) interactor = vtk.vtkRenderWindowInteractor() interactorStyle = vtk.vtkInteractorStyleImage() interactorStyle.SetInteractionModeToImageSlicing() interactorStyle.KeyPressActivationOn() interactor.SetInteractorStyle(interactorStyle) interactor.SetRenderWindow(renderWindow) # Add some functionality to switch layers for window/level def layerSwitcher(obj, event): if str(interactor.GetKeyCode()) == 'w': # Print the w/l for the image print("Image W/L: {w}/{l}".format(w=imageProperty.GetColorWindow(), l=imageProperty.GetColorLevel())) elif str(interactor.GetKeyCode()) == 'n': # Set interpolation to nearest neighbour (good for voxel visualization) imageProperty.SetInterpolationTypeToNearest() interactor.Render() elif str(interactor.GetKeyCode()) == 'c': # Set interpolation to cubic (makes a better visualization) imageProperty.SetInterpolationTypeToCubic() interactor.Render() elif str(interactor.GetKeyCode()) == 'r': window = image_scalar_range[1] - image_scalar_range[0] level = (image_scalar_range[1] + image_scalar_range[0]) / 2 imageProperty.SetColorLevel(level) imageProperty.SetColorWindow(window) interactor.Render() # Add ability to switch between active layers interactor.AddObserver('KeyPressEvent', layerSwitcher, -1.0) # Call layerSwitcher as last observer # Initialize and go interactor.Initialize() interactor.Start()
dens0.ComputeGradientOn() dens0.Update() vrange = dens0.GetOutput().GetPointData().GetArray("Gradient Magnitude").GetRange() # Show the gradient magnitude assign0 = vtk.vtkAssignAttribute() assign0.SetInputConnection(dens0.GetOutputPort()) assign0.Assign("Gradient Magnitude", "SCALARS", "POINT_DATA") map0 = vtk.vtkImageSliceMapper() map0.BorderOn() map0.SliceAtFocalPointOn() map0.SliceFacesCameraOn() map0.SetInputConnection(assign0.GetOutputPort()) slice0 = vtk.vtkImageSlice() slice0.SetMapper(map0) slice0.GetProperty().SetColorWindow(vrange[1]-vrange[0]) slice0.GetProperty().SetColorLevel(0.5*(vrange[0]+vrange[1])) # Show the region labels assign1 = vtk.vtkAssignAttribute() assign1.SetInputConnection(dens0.GetOutputPort()) assign1.Assign("Classification", "SCALARS", "POINT_DATA") map1 = vtk.vtkImageSliceMapper() map1.BorderOn() map1.SliceAtFocalPointOn() map1.SliceFacesCameraOn() map1.SetInputConnection(assign1.GetOutputPort()) map1.Update()
def initView(self, data, widget): super(SingleDataView, self).initView(data, widget) shapeList = data.getData().shape y, x = shapeList[-2], shapeList[-1] self.dimension = len(shapeList) == 2 self.reslice_mapper = vtk.vtkImageResliceMapper() self.reslice_mapper.SetInput(self.image_resample.GetOutput()) self.reslice_mapper.SliceFacesCameraOn() self.reslice_mapper.SliceAtFocalPointOn() self.reslice_mapper.JumpToNearestSliceOn() self.reslice_mapper.BorderOff() self.reslice_mapper.BackgroundOn() array = data.getData() self.minI = array.min() self.maxI = array.max() # self.minI = 0 # self.maxI = 255 image_property = vtk.vtkImageProperty() image_property.SetColorWindow(self.maxI - self.minI) image_property.SetColorLevel((self.maxI + self.minI) / 2.0) image_property.SetAmbient(0.0) image_property.SetDiffuse(1.0) image_property.SetOpacity(1.0) image_property.SetInterpolationTypeToLinear() self.image_slice = vtk.vtkImageSlice() self.image_slice.SetMapper(self.reslice_mapper) self.image_slice.SetProperty(image_property) self.renderer.AddViewProp(self.image_slice) self.window_interactor = vtk.vtkRenderWindowInteractor() self.interactor_style = vtk.vtkInteractorStyleImage() self.interactor_style.SetInteractionModeToImage3D() self.window_interactor.SetInteractorStyle(self.interactor_style) self.render_window.SetInteractor(self.window_interactor) point_picker = vtk.vtkPointPicker() self.window_interactor.SetPicker(point_picker) self.render_window.GlobalWarningDisplayOff() self.render_window.Render() self.camera = self.renderer.GetActiveCamera() self.camera.ParallelProjectionOn() w, h = self.window_interactor.GetSize() if h * x * self.space[0] < w * y * self.space[1]: scale = y / 2.0 * self.space[1] else: scale = h * x * self.space[0] / 2.0 / w self.camera.SetParallelScale(scale) point = self.camera.GetFocalPoint() dis = self.camera.GetDistance() self.camera.SetViewUp(0, -1, 0) self.camera.SetPosition(point[0], point[1], point[2] - dis) self.renderer.ResetCameraClippingRange() # View of image self.view = 2 self.interactor_style.AddObserver("MouseMoveEvent", self.MouseMoveCallback) self.interactor_style.AddObserver("LeftButtonReleaseEvent", self.LeftButtonReleaseCallback) self.interactor_style.AddObserver("LeftButtonPressEvent", self.LeftButtonPressCallback) self.interactor_style.AddObserver("MiddleButtonPressEvent", self.MiddleButtonPressCallback) self.interactor_style.AddObserver("RightButtonPressEvent", self.RightButtonPressCallback) self.interactor_style.AddObserver("RightButtonReleaseEvent", self.RightButtonReleaseCallback) self.interactor_style.AddObserver("KeyPressEvent", self.KeyPressCallback) self.interactor_style.AddObserver("CharEvent", self.CharCallback) #self.plugin[0].enable(self) self.updateAfter() self.render_window.Render()
def ToggleDRR(self, value): if self.DRRInitialized == True: if value == True: self.image.VisibilityOn() self.toggleDRR = True self.slicerRenderer.Render() return self.image.VisibilityOff() self.toggleDRR = False self.slicerRenderer.Render() return self.DRRInitialized = True self.toggleDRR = True # Initialize Window To Input Pipeline self.cameraTransform = vtk.vtkTransform() self.xRotationValue = 0.0 self.zRotationValue = 0.0 self.winToImage = vtk.vtkWindowToImageFilter() self.pixelData = vtk.vtkImageData() self.winToImage.SetInput(self.renderWindow) self.imageMapper = vtk.vtkImageSliceMapper() self.image = vtk.vtkImageSlice() self.imageMapper.SetInputData(self.winToImage.GetOutput()) self.image.SetMapper(self.imageMapper) # Render DRR (replace with udpate DRR) self.cameraTransform.Identity() self.cameraTransform.PostMultiply() self.cameraTransform.Translate(0, 705.81, 0) self.cameraTransform.RotateZ(self.zRotationValue) self.cameraTransform.RotateX(-self.xRotationValue) self.renderer.GetActiveCamera().SetPosition( self.cameraTransform.GetPosition()) self.renderer.GetActiveCamera().SetFocalPoint(0, 0, 0) self.renderer.GetActiveCamera().SetViewUp(0, 0, 1) self.renderer.SetBackground(1, 1, 1) self.renderWindow.Render() self.winToImage = vtk.vtkWindowToImageFilter() self.winToImage.SetInput(self.renderWindow) self.winToImage.Update() # Add DRR Image to Scene using vtkPlaneSource self.plane = vtk.vtkPlaneSource() #self.texture = vtk.vtkTexture() #self.texture.SetInputConnection(self.winToImage.GetOutputPort()) #self.texture.Update() #self.plane.SetPoint1(0, 530, 0) self.plane.SetPoint1(0, 1060, 0) #self.plane.SetPoint2(335, 0, 0) self.plane.SetPoint2(675, 0, 0) self.plane.SetOrigin(0, 0, 0) self.plane.Update() # Create DRR Model Node self.planeModelNode = slicer.mrmlScene.AddNewNodeByClass( 'vtkMRMLModelNode') self.planeModelNode.CreateDefaultDisplayNodes() #self.planeModelNode.CreateDefaultStorageNode() self.planeModelNode.SetAndObservePolyData(self.plane.GetOutput()) self.planeModelNode.SetAndObserveTransformNodeID( self.scene.dRRToMonitorTransform.GetID()) self.planeModelDisplay = self.planeModelNode.GetDisplayNode() self.planeModelDisplay.SetTextureImageDataConnection( self.winToImage.GetOutputPort()) self.planeModelDisplay.VisibilityOn() self.planeModelDisplay.SetFrontfaceCulling(False) self.planeModelDisplay.SetBackfaceCulling(False) self.renderWindow.Render() self.slicerRenderer.Render()
dens0.ComputeGradientOn() dens0.Update() vrange = dens0.GetOutput().GetPointData().GetArray("Gradient Magnitude").GetRange() # Show the gradient magnitude assign0 = vtk.vtkAssignAttribute() assign0.SetInputConnection(dens0.GetOutputPort()) assign0.Assign("Gradient Magnitude", "SCALARS", "POINT_DATA") map0 = vtk.vtkImageSliceMapper() map0.BorderOn() map0.SliceAtFocalPointOn() map0.SliceFacesCameraOn() map0.SetInputConnection(assign0.GetOutputPort()) slice0 = vtk.vtkImageSlice() slice0.SetMapper(map0) slice0.GetProperty().SetColorWindow(vrange[1] - vrange[0]) slice0.GetProperty().SetColorLevel(0.5 * (vrange[0] + vrange[1])) # Show the region labels assign1 = vtk.vtkAssignAttribute() assign1.SetInputConnection(dens0.GetOutputPort()) assign1.Assign("Classification", "SCALARS", "POINT_DATA") map1 = vtk.vtkImageSliceMapper() map1.BorderOn() map1.SliceAtFocalPointOn() map1.SliceFacesCameraOn() map1.SetInputConnection(assign1.GetOutputPort()) map1.Update()
def render(input_file, output_file, histogram_bin_count): path, output_name = split(output_file) output_root, ext = splitext(output_name) reader = vtk.vtkNIFTIImageReader() reader.SetFileName(input_file) reader.Update() output = reader.GetOutput() size = output.GetDimensions() center = output.GetCenter() spacing = output.GetSpacing() center1 = (center[0], center[1], center[2]) center2 = (center[0], center[1], center[2]) if size[2] % 2 == 1: center1 = (center[0], center[1], center[2] + 0.5*spacing[2]) if size[0] % 2 == 1: center2 = (center[0] + 0.5*spacing[0], center[1], center[2]) vrange = output.GetScalarRange() avg_scale = 0.25 * (vrange[1]-vrange[0]) avg_map_top = vtk.vtkImageResliceMapper() avg_map_top.BorderOn() avg_map_top.SliceAtFocalPointOn() avg_map_top.SliceFacesCameraOn() avg_map_top.SetSlabThickness(max(size)) avg_map_top.SetInputConnection(reader.GetOutputPort()) avg_map_side = vtk.vtkImageResliceMapper() avg_map_side.BorderOn() avg_map_side.SliceAtFocalPointOn() avg_map_side.SliceFacesCameraOn() avg_map_side.SetSlabThickness(max(size)) avg_map_side.SetInputConnection(reader.GetOutputPort()) avg_top = vtk.vtkImageSlice() avg_top.SetMapper(avg_map_top) avg_top.GetProperty().SetColorWindow(avg_scale) avg_top.GetProperty().SetColorLevel(0.5*avg_scale) avg_side = vtk.vtkImageSlice() avg_side.SetMapper(avg_map_side) avg_side.GetProperty().SetColorWindow(avg_scale) avg_side.GetProperty().SetColorLevel(0.5*avg_scale) slice_scale = vrange[1]-vrange[0] slice_map_top = vtk.vtkImageSliceMapper() slice_map_top.BorderOn() slice_map_top.SliceAtFocalPointOn() slice_map_top.SliceFacesCameraOn() slice_map_top.SetInputConnection(reader.GetOutputPort()) slice_map_side = vtk.vtkImageSliceMapper() slice_map_side.BorderOn() slice_map_side.SliceAtFocalPointOn() slice_map_side.SliceFacesCameraOn() slice_map_side.SetInputConnection(reader.GetOutputPort()) slice_top = vtk.vtkImageSlice() slice_top.SetMapper(slice_map_top) slice_top.GetProperty().SetColorWindow(slice_scale) slice_top.GetProperty().SetColorLevel(0.5*slice_scale) slice_side = vtk.vtkImageSlice() slice_side.SetMapper(slice_map_side) slice_side.GetProperty().SetColorWindow(slice_scale) slice_side.GetProperty().SetColorLevel(0.5*slice_scale) text1_actor = vtk.vtkTextActor() text1_actor.SetInput("min {:.5g}, max {:.5g}".format(vrange[0], vrange[1])) text1_actor.SetPosition(0.1 * center1[0], 0.1 * center1[1]) text1_actor.GetTextProperty().SetFontSize(18) text1_actor.GetTextProperty().SetColor(1,1,1) text2_actor = vtk.vtkTextActor() text2_actor.SetInput("Scaled Average") text2_actor.SetPosition(0.1 * center1[0], 1.8 * size[1]) text2_actor.GetTextProperty().SetFontSize(24) text2_actor.GetTextProperty().SetColor(1,1,1) text3_actor = vtk.vtkTextActor() text3_actor.SetInput("Slice") text3_actor.SetPosition(0.1 * center1[0], 1.8 * size[1]) text3_actor.GetTextProperty().SetFontSize(24) text3_actor.GetTextProperty().SetColor(1,1,1) ren1 = vtk.vtkRenderer() ren2 = vtk.vtkRenderer() ren3 = vtk.vtkRenderer() ren4 = vtk.vtkRenderer() ren1.SetViewport(0, 0, 0.5,0.5) ren2.SetViewport(0.5,0, 1.0,0.5) ren3.SetViewport(0, 0.5,0.5,1.0) ren4.SetViewport(0.5,0.5,1.0,1.0) ren1.AddViewProp(slice_top) ren2.AddViewProp(slice_side) ren3.AddViewProp(avg_top) ren4.AddViewProp(avg_side) ren1.AddActor(text1_actor) ren3.AddActor(text2_actor) ren1.AddActor(text3_actor) cam1 = ren1.GetActiveCamera() cam1.ParallelProjectionOn() cam1.SetParallelScale(0.5*spacing[1]*size[1]) cam1.SetFocalPoint(center1[0], center1[1], center1[2]) cam1.SetPosition(center1[0], center1[1], center1[2] - 100.0) cam2 = ren2.GetActiveCamera() cam2.ParallelProjectionOn() cam2.SetParallelScale(0.5*spacing[1]*size[1]) cam2.SetFocalPoint(center2[0], center2[1], center2[2]) cam2.SetPosition(center2[0] + 100.0, center2[1], center2[2]) cam3 = ren3.GetActiveCamera() cam3.ParallelProjectionOn() cam3.SetParallelScale(0.5*spacing[1]*size[1]) cam3.SetFocalPoint(center1[0], center1[1], center1[2]) cam3.SetPosition(center1[0], center1[1], center1[2] - 100.0) cam4 = ren4.GetActiveCamera() cam4.ParallelProjectionOn() cam4.SetParallelScale(0.5*spacing[1]*size[1]) cam4.SetFocalPoint(center2[0], center2[1], center2[2]) cam4.SetPosition(center2[0] + 100.0, center2[1], center2[2]) ren_win = vtk.vtkRenderWindow() ren_win.SetSize(2 * (size[0] + size[2]) // 2 * 2, 4 * size[1] // 2 * 2) # keep size even ren_win.AddRenderer(ren1) ren_win.AddRenderer(ren2) ren_win.AddRenderer(ren3) ren_win.AddRenderer(ren4) ren_win.Render() # screenshot code: w2if = vtk.vtkWindowToImageFilter() w2if.SetInput(ren_win) w2if.Update() writer = vtk.vtkPNGWriter() writer.SetFileName(output_file) writer.SetInputConnection(w2if.GetOutputPort()) writer.Write() marching_cubes = vtk.vtkMarchingCubes() marching_cubes.SetInputConnection(reader.GetOutputPort()) marching_cubes.ComputeNormalsOn() marching_cubes.ComputeGradientsOn() marching_cubes.SetValue(0, 0.1 * vrange[1]) stl_output = join(path, output_root + '_isosurface.stl') stl_writer = vtk.vtkSTLWriter() stl_writer.SetFileName(stl_output) stl_writer.SetInputConnection(marching_cubes.GetOutputPort()) stl_writer.Write() # histogram code: num_bins = int(histogram_bin_count) histogram = vtk.vtkImageHistogram() histogram.SetInputConnection(reader.GetOutputPort()) histogram.AutomaticBinningOn() histogram.SetMaximumNumberOfBins(num_bins) histogram.Update() origin = histogram.GetBinOrigin() spacing = histogram.GetBinSpacing() bin_values = np.linspace(0, num_bins * spacing, num=num_bins, endpoint=False) hist_output = join(path, output_root + '_hist.txt') hist_values = numpy_support.vtk_to_numpy(histogram.GetHistogram()) if len(hist_values) != len(bin_values): raise Exception('Histogram values and bins do not match') hist_mat = np.column_stack((bin_values, hist_values)) np.savetxt(hist_output, hist_mat, fmt='%.9g')