def volumeRender(reader,ren,renWin): #Create transfer mapping scalar value to opacity opacityTransferFunction = vtk.vtkPiecewiseFunction() opacityTransferFunction.AddPoint(1, 0.0) opacityTransferFunction.AddPoint(100, 0.1) opacityTransferFunction.AddPoint(255,1.0) colorTransferFunction = vtk.vtkColorTransferFunction() colorTransferFunction.AddRGBPoint(0.0,0.0,0.0,0.0) colorTransferFunction.AddRGBPoint(64.0,1.0,0.0,0.0) colorTransferFunction.AddRGBPoint(128.0,0.0,0.0,1.0) colorTransferFunction.AddRGBPoint(192.0,0.0,1.0,0.0) colorTransferFunction.AddRGBPoint(255.0,0.0,0.2,0.0) volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(colorTransferFunction) volumeProperty.SetScalarOpacity(opacityTransferFunction) volumeProperty.ShadeOn() volumeProperty.SetInterpolationTypeToLinear() compositeFunction = vtk.vtkVolumeRayCastCompositeFunction() volumeMapper = vtk.vtkFixedPointVolumeRayCastMapper() volumeMapper.SetInputConnection(reader.GetOutputPort()) volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) ren.RemoveAllViewProps() ren.AddVolume(volume) ren.SetBackground(1,1,1) renWin.Render()
def set_data_reader(self, reader): volumeMapper = vtk.vtkFixedPointVolumeRayCastMapper() # volumeMapper.SetBlendModeToMaximumIntensity() volumeMapper.SetInputData(reader.GetOutput()) volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) self.ren.AddVolume(volume)
def init_all_VolumeRendering_component(self, flagMesh): self.flagMesh = flagMesh self.ren= vtk.vtkRenderer() self.renWin.AddRenderer(self.ren) self.iren = vtk.vtkXRenderWindowInteractor() self.iren.SetRenderWindow(self.renWin) self.ren.GetVolumes() self.alpha_channel_function = vtk.vtkPiecewiseFunction() self.alpha_channel_function.AddPoint(0, 0.0, 0.5, 0.0) self.alpha_channel_function.AddPoint(255, 1, 0.5, 0.0) self.color_function = vtk.vtkColorTransferFunction() self.color_function.AddRGBPoint(0, 0, 0.0, 0.0, 0.5, 0.0) self.color_function.AddRGBPoint(255, 1, 1, 1, 0.5, 0.0) self.volume_property = vtk.vtkVolumeProperty() self.volume_property.SetColor(self.color_function) self.volume_property.SetScalarOpacity(self.alpha_channel_function) self.data_importer = vtk.vtkImageImport() if self.flagMesh : self.volume_mapper = vtk.vtkPolyDataMapper() else: self.volume_mapper = vtk.vtkFixedPointVolumeRayCastMapper() self.volume = vtk.vtkVolume()
def vismain(squash,rows,cols,channels,length): #alphaChannelFunc = vtk.vtkPiecewiseFunction() #alphaChannelFunc.AddPoint(0, 0.0) #volumeProperty = vtk.vtkVolumeProperty() #volumeProperty.SetScalarOpacity(alphaChannelFunc) volumeMapper = vtk.vtkFixedPointVolumeRayCastMapper() volumeMapper.SetInputConnection(fromMat2Vtk(squash,rows,cols,channels,length)) volumeMapper.SetBlendModeToComposite() volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) #volume.SetProperty(volumeProperty) volume.Update() renderer = vtk.vtkRenderer() renderWin = vtk.vtkRenderWindow() renderWin.AddRenderer(renderer) renderInteractor = vtk.vtkRenderWindowInteractor() renderInteractor.SetRenderWindow(renderWin) renderer.AddVolume(volume) # ... set background color to white ... renderer.SetBackground(1, 1, 1) # ... and set window size. renderWin.SetSize(1000, 1000) renderWin.AddObserver("AbortCheckEvent", exitCheck) renderInteractor.Initialize() # Because nothing will be rendered without any input, we order the first render manually before control is handed over to the main-loop. renderWin.Render() renderInteractor.Start()
def volumeRender(): # Create the standard renderer, render window and interactor. ren1 = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Create the reader for the data. reader = vtk.vtkStructuredPointsReader() reader.SetFileName('./image/ironProt.vtk') # Create transfer mapping scalar value to opacity. volumeOpacity = vtk.vtkPiecewiseFunction() volumeOpacity.AddPoint(50, 0) volumeOpacity.AddPoint(150, 0.4) volumeOpacity.AddPoint(200, 0.7) volumeOpacity.AddPoint(255, 1) # Create transfer mapping scalar value to color. volumeColor = vtk.vtkColorTransferFunction() volumeColor.AddRGBPoint(0.0, 25.0, 25.0, 25.0) volumeColor.AddRGBPoint(64.0, 100.0, 100.0, 100.0) volumeColor.AddRGBPoint(128.0, 150.0, 150.0, 150.0) volumeColor.AddRGBPoint(192.0, 200.0, 200.0, 200.0) # The property describes how the data will look. volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(volumeColor) volumeProperty.SetScalarOpacity(volumeOpacity) volumeProperty.ShadeOn() volumeProperty.SetInterpolationTypeToLinear() # The mapper / ray cast function know how to render the data. volumeMapper = vtk.vtkFixedPointVolumeRayCastMapper() volumeMapper.SetInputConnection(reader.GetOutputPort()) # The volume holds the mapper and the property and # can be used to position/orient the volume. volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) colors = vtk.vtkNamedColors() ren1.AddVolume(volume) ren1.SetBackground(colors.GetColor3d("White")) ren1.GetActiveCamera().Azimuth(0) ren1.GetActiveCamera().Elevation(15) ren1.ResetCameraClippingRange() ren1.ResetCamera() renWin.SetSize(600, 600) renWin.Render() iren.Start()
def defaultEnvironment(environment, attribute): """ Default 3d environment renderer. White is the highest value in the frame and black is the lowest value. """ xbounds = environment.mesh.boundsX ybounds = environment.mesh.boundsY zbounds = environment.mesh.boundsZ attributeIndex = environment.current.variables[attribute] positions = environment.mesh.voxels data = environment.current.data[attributeIndex] xCount = np.unique(environment.mesh.voxels[environment.mesh.variables['x']]).shape[0] yCount = np.unique(environment.mesh.voxels[environment.mesh.variables['y']]).shape[0] zCount = np.unique(environment.mesh.voxels[environment.mesh.variables['z']]).shape[0] minimum = np.min(data) maximum = np.max(data) if not maximum == 0: data = data / maximum data = np.reshape(data, (xCount, yCount, zCount)) imdata = vtk.vtkImageData() depthArray = numpy_support.numpy_to_vtk(data.ravel(), deep=True, array_type=vtk.VTK_DOUBLE) imdata.SetDimensions(data.shape) imdata.SetSpacing([(xbounds[1] - xbounds[0]) / xCount, (ybounds[1] - ybounds[0]) / yCount, (zbounds[1] - zbounds[0]) / zCount]) imdata.SetOrigin([xbounds[0], ybounds[0], zbounds[0]]) imdata.GetPointData().SetScalars(depthArray) colorFunc = vtk.vtkColorTransferFunction() colorFunc.AddRGBPoint(0.0, 0.0, 0.0, 0.0) colorFunc.AddRGBPoint(1.0, 1.0, 1.0, 1.0) opacity = vtk.vtkPiecewiseFunction() opacity.AddPoint(0.0, 0.0) opacity.AddPoint(1, 0.8) volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(colorFunc) volumeProperty.SetScalarOpacity(opacity) volumeProperty.SetInterpolationTypeToLinear() volumeProperty.SetIndependentComponents(2) volumeMapper = vtk.vtkFixedPointVolumeRayCastMapper() volumeMapper.SetInputData(imdata) volumeMapper.SetBlendModeToMaximumIntensity() volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) return volume
def vtkGetVolumeRayCastMapper(): if vtk.VTK_MAJOR_VERSION < 7: compositeFunction = vtk.vtkVolumeRayCastCompositeFunction() vol_map = vtk.vtkVolumeRayCastMapper() vol_map.SetVolumeRayCastFunction(compositeFunction) else: vol_map = vtk.vtkFixedPointVolumeRayCastMapper() vol_map.SetBlendModeToComposite() # return vol_map
def __init__(self, name, reader, res, spacing, mat): self.name = name mapper = vtk.vtkFixedPointVolumeRayCastMapper() mapper.SetInputConnection(reader.GetOutputPort()) mapper.SetBlendModeToComposite() self.SetMapper(mapper) self.SetProperty(mat) self.reader = reader self.res = res self.spacing = spacing
def update_mapper(self): if self._gpu: mapper = vtk.vtkGPUVolumeRayCastMapper() else: mapper = vtk.vtkFixedPointVolumeRayCastMapper() mapper.SetInputData(self._volume) mapper.SetBlendModeToComposite() self._mapper = mapper
def _setup_for_fixed_point(self): """This doesn't seem to work. After processing is complete, it stalls on actually rendering the volume. No idea. """ self._volume_mapper = vtk.vtkFixedPointVolumeRayCastMapper() self._volume_mapper.SetBlendModeToComposite() #self._volume_mapper.SetBlendModeToMaximumIntensity() module_utils.setup_vtk_object_progress(self, self._volume_mapper, 'Preparing render.')
def volume_renderer(img): #Create the renderers, render window, and interactor renWin=vtk.vtkRenderWindow() iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) ren=vtk.vtkRenderer() ren.SetBackground(0.0, 0.0, 0.0) renWin.AddRenderer(ren) #Create a transfer function mapping scalar value to opacity oTFun=vtk.vtkPiecewiseFunction() # oTFun.AddSegment(0,1.0,256,0.1) oTFun.AddPoint(0, 0.0) oTFun.AddPoint(low, 0.1) oTFun.AddPoint(high, 0.8) oTFun.AddPoint(100, 0.05) cTFun=vtk.vtkColorTransferFunction() cTFun.AddRGBPoint(0, 0.0, 0.0, 0.0) # background cTFun.AddRGBPoint(low, 0.7, 0.0, 0.3) cTFun.AddRGBPoint(high, 0.0, 0.0, 0.5) cTFun.AddRGBPoint(200, 1.0, 0.8, 0.5) gradient = vtk.vtkPiecewiseFunction() gradient.AddPoint(0, 0.0) gradient.AddPoint(high, 0.5) gradient.AddPoint(150, 1.0) property =vtk.vtkVolumeProperty() property.SetScalarOpacity(oTFun) property.SetColor(cTFun) property.SetInterpolationTypeToLinear() mapper =vtk.vtkFixedPointVolumeRayCastMapper() #mapper.SetBlendModeToMinimumIntensity() mapper.SetInputData(img ) volume =vtk.vtkVolume() volume.SetMapper(mapper) volume.SetProperty(property) volume.Update() ren.AddViewProp(volume) iren.Initialize() iren.Start()
def BuildView(self): if not self.vmtkRenderer: self.vmtkRenderer = vmtkrenderer.vmtkRenderer() self.vmtkRenderer.Initialize() self.OwnRenderer = 1 self.vmtkRenderer.RegisterScript(self) if self.Volume: self.vmtkRenderer.Renderer.RemoveVolume(self.Volume) if (self.ArrayName != ''): self.Image.GetPointData().SetActiveScalars(self.ArrayName) scalarRange = [0.0, 0.0] if self.WindowLevel[0] > 0.0: scalarRange = [ self.WindowLevel[1] - self.WindowLevel[0] / 2.0, self.WindowLevel[1] + self.WindowLevel[0] / 2.0 ] else: scalarRange = self.Image.GetScalarRange() colorTransferFunction = vtk.vtkColorTransferFunction() colorTransferFunction.AddRGBPoint(scalarRange[0], 0.0, 0.0, 0.0) colorTransferFunction.AddRGBPoint(scalarRange[1], 1.0, 1.0, 1.0) volumeMapper = vtk.vtkFixedPointVolumeRayCastMapper() volumeMapper.SetInputData(self.Image) volumeMapper.SetBlendModeToMaximumIntensity() if self.AutoSampleDistance: volumeMapper.AutoAdjustSampleDistancesOn() else: volumeMapper.SetSampleDistance(self.SampleDistance) volumeProperty = vtk.vtkVolumeProperty() volumeProperty.ShadeOn() volumeProperty.SetInterpolationTypeToLinear() volumeProperty.SetColor(colorTransferFunction) self.Volume = vtk.vtkVolume() self.Volume.SetMapper(volumeMapper) self.Volume.SetProperty(volumeProperty) self.vmtkRenderer.Renderer.AddVolume(self.Volume) if (self.Display == 1): self.vmtkRenderer.Render() if self.OwnRenderer: self.vmtkRenderer.Deallocate()
def run_source(): """https://www.creatis.insa-lyon.fr/~davila/bbtk/Software/new/doc/VTK_Documentation/report-about-vtk-2007-02.pdf""" pointSource = get_point_source() popSplatter = vtk.vtkGaussianSplatter() # Splatter : popSplatter.SetSampleDimensions(300, 300, 300) # points -> gauss sphere popSplatter.SetInputConnection(pointSource.GetOutputPort()) # f(x) = scale * exp ( expF *(( r/ Radius )^2) ) popSplatter.SetRadius(0.1) popSplatter.SetExponentFactor(1.0) popSplatter.SetScaleFactor(1.0) cast = vtk.vtkImageCast() # uchar conversion cast.SetInputConnection( popSplatter.GetOutputPort()) # ( required by VRayCast ) cast.SetOutputScalarTypeToUnsignedChar() alphaTF = vtk.vtkPiecewiseFunction() # Opacity (A-TF) alphaTF.AddPoint(0, 0) alphaTF.AddPoint(1, 0.01) alphaTF.AddPoint(255, 0.5) colorTF = vtk.vtkColorTransferFunction() # Color (RGB -TF) colorTF.AddRGBPoint(0, 1, 0.4, 0) colorTF.AddRGBPoint(255, 1, 0.0, 0) volumeProperty = vtk.vtkVolumeProperty() # Property volumeProperty.SetColor(colorTF) volumeProperty.SetScalarOpacity(alphaTF) volumeProperty.SetInterpolationTypeToLinear() #compositeFunction = vtkVolumeRayCastCompositeFunction()# Mapper volumeMapper = vtk.vtkFixedPointVolumeRayCastMapper() # ( Software ) #volumeMapper.SetVolumeRayCastFunction(compositeFunction) volumeMapper.SetBlendModeToComposite() volumeMapper.SetInputConnection(cast.GetOutputPort()) volume = vtk.vtkVolume() # Volume = Mapper + Property volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) ren = vtk.vtkRenderer() # Renderer ren.AddVolume(volume) ren.ResetCamera() ren.GetActiveCamera().ParallelProjectionOn() renwin = vtk.vtkRenderWindow() # Window renwin.AddRenderer(ren) renwin.SetSize(300, 300) renwin.SetDesiredUpdateRate(1.0) iren = vtk.vtkRenderWindowInteractor() # Interactor iren.SetRenderWindow(renwin) iren.Start()
def load_volume(filename): reader = vtk.vtkMetaImageReader() reader.SetFileName(filename) reader.Update() (xMin, xMax, yMin, yMax, zMin, zMax) = reader.GetExecutive().GetWholeExtent( reader.GetOutputInformation(0)) (xSpacing, ySpacing, zSpacing) = reader.GetOutput().GetSpacing() (x0, y0, z0) = reader.GetOutput().GetOrigin() print(f'Origin: {(x0, y0, z0)}') print(f'Extents: min: {(xMin, yMin, zMin)}') print(f' max: {(xMax, yMax, zMax)}') center = [ x0 + xSpacing * 0.5 * (xMin + xMax), y0 + ySpacing * 0.5 * (yMin + yMax), z0 + zSpacing * 0.5 * (zMin + zMax) ] alphaChannelFunc = vtk.vtkPiecewiseFunction() alphaChannelFunc.AddPoint(0, 0.0) alphaChannelFunc.AddPoint(130, 0.01) alphaChannelFunc.AddPoint(400, 0.27) alphaChannelFunc.AddPoint(650, 0.9) alphaChannelFunc.AddPoint(1106, 1.0) colorFunc = vtk.vtkColorTransferFunction() colorFunc.AddRGBPoint(0, 0.0, 0.0, 0.0) colorFunc.AddRGBPoint(400, 1.0, 0.0, 0.0) colorFunc.AddRGBPoint(650, 1.0, 0.0, 0.0) colorFunc.AddRGBPoint(230, 1.0, 0.0, 0.0) colorFunc.AddRGBPoint(1106, 0.0, 0.0, 1.0) # The previous two classes stored properties. # Because we want to apply these properties to the volume we want to render, # we have to store them in a class that stores volume properties. volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(colorFunc) volumeProperty.SetScalarOpacity(alphaChannelFunc) volumeMapper = vtk.vtkFixedPointVolumeRayCastMapper() volumeMapper.CroppingOn() volumeMapper.SetInputConnection(reader.GetOutputPort()) # The class vtkVolume is used to pair the previously declared volume as well as the properties # to be used when rendering that volume. volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) volume.SetPickable(False) return volume, reader.GetOutputPort()
def BuildView(self): if not self.vmtkRenderer: self.vmtkRenderer = vmtkrenderer.vmtkRenderer() self.vmtkRenderer.Initialize() self.OwnRenderer = 1 self.vmtkRenderer.RegisterScript(self) if self.Volume: self.vmtkRenderer.Renderer.RemoveVolume(self.Volume) if (self.ArrayName != ''): self.Image.GetPointData().SetActiveScalars(self.ArrayName) scalarRange = [0.0, 0.0] if self.WindowLevel[0] > 0.0: scalarRange = [self.WindowLevel[1] - self.WindowLevel[0]/2.0, self.WindowLevel[1] + self.WindowLevel[0]/2.0] else: scalarRange = self.Image.GetScalarRange() colorTransferFunction = vtk.vtkColorTransferFunction() colorTransferFunction.AddRGBPoint(scalarRange[0], 0.0, 0.0, 0.0) colorTransferFunction.AddRGBPoint(scalarRange[1], 1.0, 1.0, 1.0) volumeMapper = vtk.vtkFixedPointVolumeRayCastMapper() volumeMapper.SetInput(self.Image) volumeMapper.SetBlendModeToMaximumIntensity() if self.AutoSampleDistance: volumeMapper.AutoAdjustSampleDistancesOn() else: volumeMapper.SetSampleDistance(self.SampleDistance) volumeProperty = vtk.vtkVolumeProperty() volumeProperty.ShadeOn() volumeProperty.SetInterpolationTypeToLinear() volumeProperty.SetColor(colorTransferFunction) self.Volume = vtk.vtkVolume() self.Volume.SetMapper(volumeMapper) self.Volume.SetProperty(volumeProperty) self.vmtkRenderer.Renderer.AddVolume(self.Volume) if (self.Display == 1): self.vmtkRenderer.Render() if self.OwnRenderer: self.vmtkRenderer.Deallocate()
def draw_voxels(self): self.show_axes = False u = self.data['voxels'] u /= (2 * max([abs(min(u)), abs(max(u))])) u += 0.5 u *= 255 nx, ny, nz = u.shape U = asarray(u, dtype=uint8) dstr = U.tostring() img = vtkImageImport() img.CopyImportVoidPointer(dstr, len(dstr)) img.SetDataScalarTypeToUnsignedChar() img.SetNumberOfScalarComponents(1) img.SetDataExtent(0, nz - 1, 0, ny - 1, 0, nx - 1) img.SetWholeExtent(0, nz - 1, 0, ny - 1, 0, nx - 1) self.gradient = gradient = vtkPiecewiseFunction() gradient.AddPoint(1, 0.0) gradient.AddPoint(255, 0.2) self.cbar = cbar = vtkColorTransferFunction() cbar.AddRGBPoint(0.0, 0.0, 0.0, 1.0) cbar.AddRGBPoint(42.0, 0.0, 0.5, 1.0) cbar.AddRGBPoint(84.0, 0.0, 1.0, 0.5) cbar.AddRGBPoint(128.0, 0.0, 1.0, 0.0) cbar.AddRGBPoint(168.0, 0.5, 1.0, 0.0) cbar.AddRGBPoint(212.0, 1.0, 0.5, 0.0) cbar.AddRGBPoint(255.0, 1.0, 0.0, 0.0) self.volprop = volprop = vtkVolumeProperty() volprop.SetColor(cbar) volprop.SetScalarOpacity(gradient) volprop.ShadeOff() volprop.SetInterpolationTypeToLinear() mapper = vtkFixedPointVolumeRayCastMapper() mapper.SetInputConnection(img.GetOutputPort()) volume = vtkVolume() volume.SetMapper(mapper) volume.SetProperty(volprop) self.main.renderer.AddVolume(volume) self.main.camera.SetPosition(0, -2 * max([nx, ny, nz]), nz) self.main.camera.SetFocalPoint(0.5 * nx, 0.5 * ny, 0.5 * nz)
def volumeRendering(image, image2, lowerThreshold, upperThreshold): color = vtk.vtkColorTransferFunction() color.AddRGBPoint(0, 0.0, 0.0, 0.0) # background color.AddRGBPoint(lowerThreshold, 1.0, 0.0, 0.0) color.AddRGBPoint(upperThreshold, 0.0, 1.0, 0.0) opacity = vtk.vtkPiecewiseFunction() opacity.AddPoint(0, 0.0) opacity.AddPoint(lowerThreshold, 0.15) opacity.AddPoint(upperThreshold, 0.85) gradient = vtk.vtkPiecewiseFunction() gradient.AddPoint(0, 0.0) gradient.AddPoint(90, 0.5) gradient.AddPoint(100, 1.0) volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(color) volumeProperty.SetScalarOpacity(opacity) volumeProperty.SetGradientOpacity(gradient) volumeProperty.SetInterpolationTypeToLinear() volumeProperty.ShadeOn() volumeProperty.SetAmbient(0.2) volumeProperty.SetDiffuse(0.7) volumeProperty.SetSpecular(0.3) volumeMapper = vtk.vtkFixedPointVolumeRayCastMapper() volumeMapper.SetInputData(image) volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) volume.Update() ren = vtk.vtkRenderer() ren.AddViewProp(volume) ren.SetBackground(0, 0, 0) renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) renWin.SetSize(400, 400) # create a renderwindowinteractor iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) iren.Initialize() renWin.Render() iren.Start()
def __init__(self): ''' Constructor ''' vtkPythonViewImage.__init__(self) # texture mapper in 3D: vtkVolumeMapper self.__VolumeMapper = None # texture mapper in 3D: vtkVolumeTextureMapper3D self.__VolumeTextureMapper = vtk.vtkVolumeTextureMapper3D() # volume ray cast mapper vtkFixedPointVolumeRayCastMapper self.__VolumeRayCastMapper = vtk.vtkFixedPointVolumeRayCastMapper() # volume property: vtkVolumeProperty self.__VolumeProperty = vtk.vtkVolumeProperty() # volume actor: vtkVolume self.__VolumeActor = vtk.vtkVolume() # opacity transfer function: vtkPiecewiseFunction self.__OpacityFunction = vtk.vtkPiecewiseFunction() # color transfer function: vtkColorTransferFunction self.__ColorFunction = vtk.vtkColorTransferFunction() # vtkProp3DCollection self.__PhantomCollection = vtk.vtkProp3DCollection() # blender: vtkImageBlend self.__Blender = None # image 3D cropping box callback: vtkImage3DCroppingBoxCallback self.__Callback = vtkPythonImage3DCroppingBoxCallback() # box widget: vtkOrientedBoxWidget # self.__BoxWidget = vtkOrientedBoxWidget() # Now I could not wrap vtkOrientedBoxWidget self.__BoxWidget = vtk.vtkBoxWidget() # vtkPlane widget: vtkPlaneWidget self.__PlaneWidget = vtk.vtkPlaneWidget() # annotated cube actor: vtkAnnotatedCubeActor, vtkOrientationMarkerWidget self.__Cube = vtk.vtkAnnotatedCubeActor() self.__Marker = vtk.vtkOrientationMarkerWidget() self.SetupVolumeRendering() self.SetupWidgets() self.ShowAnnotationsOn() self.getTextProperty().SetColor(0, 0, 0) self.SetBackground(0.9, 0.9, 0.9) # white self.__FirstRender = 1 self.__RenderingMode = self.PLANAR_RENDERING self.__VRQuality = 1 self.__InteractorStyleSwitcher = None
def main(): #alphaChannelFunc = vtk.vtkPiecewiseFunction() #alphaChannelFunc.AddPoint(0, 0.0) #volumeProperty = vtk.vtkVolumeProperty() #volumeProperty.SetScalarOpacity(alphaChannelFunc) volumeMapper = vtk.vtkFixedPointVolumeRayCastMapper() volumeMapper.SetInputConnection(fromVid2Vtk(args)) volumeMapper.SetBlendModeToComposite() opacityTransferFunction = vtk.vtkPiecewiseFunction() opacityTransferFunction.AddPoint(20, 0.0) opacityTransferFunction.AddPoint(255, 0.2) # Create transfer mapping scalar value to color. colorTransferFunction = vtk.vtkColorTransferFunction() colorTransferFunction.AddRGBPoint(0.0, 0.0, 0.0, 0.0) colorTransferFunction.AddRGBPoint(64.0, 1.0, 0.0, 0.0) colorTransferFunction.AddRGBPoint(128.0, 0.0, 0.0, 1.0) colorTransferFunction.AddRGBPoint(192.0, 0.0, 1.0, 0.0) colorTransferFunction.AddRGBPoint(255.0, 0.0, 0.2, 0.0) # The property describes how the data will look. volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(colorTransferFunction) volumeProperty.SetScalarOpacity(opacityTransferFunction) #volumeProperty.ShadeOn() volumeProperty.SetInterpolationTypeToLinear() volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) volume.Update() renderer = vtk.vtkRenderer() renderWin = vtk.vtkRenderWindow() renderWin.AddRenderer(renderer) renderInteractor = vtk.vtkRenderWindowInteractor() renderInteractor.SetRenderWindow(renderWin) renderer.AddVolume(volume) renderer.SetBackground(1, 1, 1) renderWin.SetSize(400, 400) renderInteractor.Initialize() renderWin.Render() renderInteractor.Start()
def volume_render(self, scalar_range): i1 = scalar_range[0] i2 = scalar_range[1] i3 = scalar_range[2] volumeMapper = vtk.vtkFixedPointVolumeRayCastMapper() volumeMapper.SetInputData(self.volume) # The color transfer function maps voxel intensities to colors. # It is modality-specific, and often anatomy-specific as well. # The goal is to one color for flesh (between 500 and 1000) # and another color for bone (1150 and over). volumeColor = vtk.vtkColorTransferFunction() volumeColor.AddRGBPoint(0, 0.0, 0.0, 0.0) volumeColor.AddRGBPoint(i1, 1.0, 0.5, 0.3) volumeColor.AddRGBPoint(i2, 1.0, 0.5, 0.3) volumeColor.AddRGBPoint(i3, 1.0, 1.0, 0.9) # The opacity transfer function is used to control the opacity # of different tissue types. volumeScalarOpacity = vtk.vtkPiecewiseFunction() volumeScalarOpacity.AddPoint(0, 0.00) volumeScalarOpacity.AddPoint(i1, 0.15) volumeScalarOpacity.AddPoint(i2, 0.15) volumeScalarOpacity.AddPoint(i3, 0.85) # The gradient opacity function is used to decrease the opacity # in the "flat" regions of the volume while maintaining the opacity # at the boundaries between tissue types. The gradient is measured # as the amount by which the intensity changes over unit distance. # For most medical data, the unit distance is 1mm. volumeGradientOpacity = vtk.vtkPiecewiseFunction() volumeGradientOpacity.AddPoint(0, 0.0) volumeGradientOpacity.AddPoint(90, 0.5) volumeGradientOpacity.AddPoint(100, 1.0) volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(volumeColor) volumeProperty.SetScalarOpacity(volumeScalarOpacity) volumeProperty.SetGradientOpacity(volumeGradientOpacity) volumeProperty.SetInterpolationTypeToLinear() volumeProperty.ShadeOn() volumeProperty.SetAmbient(0.4) volumeProperty.SetDiffuse(0.6) volumeProperty.SetSpecular(0.2) volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) self.graphics.renderer.AddViewProp(volume)
def volumeRender(self): #Create transfer mapping scalar value to opacity opacityTransferFunction = vtk.vtkPiecewiseFunction() opacityTransferFunction.AddPoint(1, 0.0) opacityTransferFunction.AddPoint(100, 0.1) opacityTransferFunction.AddPoint(255,1.0) colorTransferFunction = vtk.vtkColorTransferFunction() colorTransferFunction.AddRGBPoint(0.0,0.0,0.0,0.0) colorTransferFunction.AddRGBPoint(64.0,1.0,0.0,0.0) colorTransferFunction.AddRGBPoint(128.0,0.0,0.0,1.0) colorTransferFunction.AddRGBPoint(192.0,0.0,1.0,0.0) colorTransferFunction.AddRGBPoint(255.0,0.0,0.2,0.0) volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(colorTransferFunction) volumeProperty.SetScalarOpacity(opacityTransferFunction) volumeProperty.ShadeOn() volumeProperty.SetInterpolationTypeToLinear() compositeFunction = vtk.vtkVolumeRayCastCompositeFunction() volumeMapper = vtk.vtkFixedPointVolumeRayCastMapper() volumeMapper.SetInputConnection(self.reader.GetOutputPort()) volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) ren.AddVolume(volume) ren.SetBackground(1,1,1) renWin.SetSize(600,600) renWin.Render() iren.Initialize() renWin.Render() iren.Start()
def main(): # The main window window = gtk.Window() window.set_title("A GtkGLExtVTKRenderWindow Demo!") window.connect("destroy", gtk.mainquit) window.connect("delete_event", gtk.mainquit) window.set_border_width(10) vtkda = GtkGLExtVTKRenderWindow() vtkda.show() vbox = gtk.VBox(spacing=3) vbox.show() vbox.pack_start(vtkda) button = gtk.Button('My Button') button.show() vbox.pack_start(button) window.add(vbox) # if one of the cones from above is not commented out, shows only # the cone on a mac, otherwise, it shows reader = vtk.vtkPNMReader() reader.SetFilePattern("mini/checkerboard%i.pgm") size = 5 reader.SetDataExtent(0, size, 0, size, 0, size) reader.SetDataSpacing(1, 1, 1) reader.SetDataScalarTypeToUnsignedChar() image = reader.GetOutput() image.Update() mapper = vtk.vtkFixedPointVolumeRayCastMapper() mapper.SetInput(image) if size < 20: mapper.SetSampleDistance(float(size) / 1000) mapper.SetInteractiveSampleDistance(float(size) / 500) volproperty = vtk.vtkVolumeProperty() color = vtk.vtkPiecewiseFunction() color.AddSegment(0, 0, 255, 1) volproperty.SetColor(0, color) volume = vtk.vtkVolume() volume.SetMapper(mapper) volume.SetProperty(volproperty) window.set_size_request(400, 400) # The VTK stuff. cone = vtk.vtkConeSource() cone.SetResolution(80) coneMapper = vtk.vtkPolyDataMapper() coneMapper.SetInput(cone.GetOutput()) #coneActor = vtk.vtkLODActor() coneActor = vtk.vtkActor() coneActor.SetMapper(coneMapper) coneActor.GetProperty().SetColor(0.5, 0.5, 1.0) ren = vtk.vtkRenderer() vtkda.GetRenderWindow().AddRenderer(ren) ren.AddActor(coneActor) ren.AddActor(volume) # show the main window and start event processing. window.show() gtk.mainloop()
def create_volume_prop(volume: np.ndarray, affine: np.ndarray) -> vtk.vtkVolume: """ Convert a numpy 3D matrix to a vtkVolume object :param volume: :param affine: :return: """ volume = volume / volume.max() * 255 volume = volume.astype('uint8') dims = volume.shape maxValue = volume.max() minValue = volume.min() dataImporter = vtk.vtkImageImport() data_string = volume.tostring() dataImporter.CopyImportVoidPointer(data_string, len(data_string)) dataImporter.SetDataScalarTypeToUnsignedChar() dataImporter.SetNumberOfScalarComponents(1) # todo ????????????????? # set data spacing _, _, spacing, _ = decompose(affine) z = abs(spacing) dataImporter.SetDataSpacing(z[2], z[0], z[1]) # dataImporter.SetDataSpacing(2.4, 0.7, 0.7) dataImporter.SetDataExtent(0, dims[2] - 1, 0, dims[1] - 1, 0, dims[0] - 1) dataImporter.SetWholeExtent(0, dims[2] - 1, 0, dims[1] - 1, 0, dims[0] - 1) try: # Compute by GPU volume_mapper = vtk.vtkGPUVolumeRayCastMapper() except Exception as e: logging.warning("Failed to connect to GPU, render with CPU") # Compute by CPU volume_mapper = vtk.vtkFixedPointVolumeRayCastMapper() out_port: vtk.vtkAlgorithmOutput = dataImporter.GetOutputPort() volume_mapper.SetInputConnection(out_port) # The color transfer function maps voxel intensities to colors. # It is modality-specific, and often anatomy-specific as well. # The goal is to one color for flesh (between 500 and 1000) # and another color for bone (1150 and over). colorLUT = np.arange(minValue, maxValue, maxValue / 5.0) print(colorLUT) volumeColor = vtk.vtkColorTransferFunction() volumeColor.AddRGBPoint(colorLUT[0], 0.0, 0.0, 0.0) volumeColor.AddRGBPoint(colorLUT[1], 1.0, 0.5, 0.3) volumeColor.AddRGBPoint(colorLUT[2], 1.0, 0.5, 0.3) volumeColor.AddRGBPoint(colorLUT[3], 1.0, 1.0, 0.9) # The opacity transfer function is used to control the opacity # of different tissue types. volumeScalarOpacity = vtk.vtkPiecewiseFunction() volumeScalarOpacity.AddPoint(colorLUT[0], 0.00) volumeScalarOpacity.AddPoint(colorLUT[1], 0.15) volumeScalarOpacity.AddPoint(colorLUT[2], 0.5) volumeScalarOpacity.AddPoint(colorLUT[3], 0.85) # The gradient opacity function is used to decrease the opacity # in the "flat" regions of the volume while maintaining the opacity # at the boundaries between tissue types. The gradient is measured # as the amount by which the intensity changes over unit distance. # For most medical data, the unit distance is 1mm. volumeGradientOpacity = vtk.vtkPiecewiseFunction() volumeGradientOpacity.AddPoint(0, 0.0) volumeGradientOpacity.AddPoint(colorLUT[1] / 2, 0.5) volumeGradientOpacity.AddPoint(colorLUT[2] / 2, 1.0) volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(volumeColor) volumeProperty.SetScalarOpacity(volumeScalarOpacity) volumeProperty.SetGradientOpacity(volumeGradientOpacity) volumeProperty.SetInterpolationTypeToLinear() volumeProperty.ShadeOn() volumeProperty.SetAmbient(0.4) volumeProperty.SetDiffuse(0.6) volumeProperty.SetSpecular(0.2) # The vtkVolume is a vtkProp3D (like a vtkActor) and controls the position # and orientation of the volume in world coordinates. actorVolume = vtk.vtkVolume() actorVolume.SetMapper(volume_mapper) actorVolume.SetProperty(volumeProperty) return actorVolume
def update(self): dicom_io = itk.GDCMImageIO.New() name_generator = itk.GDCMSeriesFileNames.New() name_generator.SetUseSeriesDetails(True) name_generator.SetDirectory(self._file_dir) series_uid = name_generator.GetSeriesUIDs() #cycle_number = len(series_uid) cycle_number = 1 render_window = vtk.vtkRenderWindow() render_window_interactor = vtk.vtkRenderWindowInteractor() camera = vtk.vtkCamera() camera.SetViewUp(0, 1, 0) camera.SetPosition(1.0, 0.0, 0.0) camera.SetFocalPoint(0.0, 0.0, 0.0) #camera.ComputeViewPlaneNormal() camera.Dolly(1.5) for cycle_id in range(0,cycle_number): print("*** load cycle: "+str(cycle_id)+" ***") series_identifier = series_uid[cycle_id] file_names = name_generator.GetFileNames(series_identifier) # sort file names file_names = list(file_names) file_names.sort() file_names = tuple(file_names) # set image type to signed short (16-bits/pixel) itk_reader = itk.ImageSeriesReader[itk.Image.SS3].New() itk_reader.SetImageIO(dicom_io) itk_reader.SetFileNames(file_names) itk_reader.Update() # =================================== spacing = itk_reader.GetOutput().GetSpacing() spacing[2] = 3 itk_reader.GetOutput().SetSpacing(spacing) # =================================== print(itk_reader().GetOutput().GetSpacing()) self.read_image(itk_reader) # only unsigned char or unsigned short can be accepted by vtkVolumeRayCastMapper, so convert signed short to unsigned short val_range = self._image.GetOutput().GetScalarRange() min_val = val_range[0] max_val = val_range[1] diff = max_val - min_val slope = 65536/diff # 16-bits/pixel inter = -slope*min_val shift = inter/slope shifter = vtk.vtkImageShiftScale() shifter.SetShift(shift) shifter.SetScale(slope) shifter.SetOutputScalarTypeToUnsignedShort() shifter.SetInputConnection(self._image.GetOutputPort()) shifter.ReleaseDataFlagOff() shifter.Update() volume_mapper = vtk.vtkFixedPointVolumeRayCastMapper() volume_mapper.SetInputConnection(shifter.GetOutputPort()) volume_color = vtk.vtkColorTransferFunction() volume_scalar_opacity = vtk.vtkPiecewiseFunction() volume_property = vtk.vtkVolumeProperty() volume_property.SetIndependentComponents(True) volume_property.SetColor(volume_color) volume_property.SetScalarOpacity(volume_scalar_opacity) volume_property.SetInterpolationTypeToNearest() volume = vtk.vtkVolume() volume.SetMapper(volume_mapper) volume.SetProperty(volume_property) volume_color.AddRGBSegment(0.0,0.0,0.0,0.0,1000,1.0,1.0,1.0) volume_scalar_opacity.AddSegment(0, 0, 65536, 1) # 16 bits/pixel volume_mapper.SetBlendModeToMaximumIntensity() renderer = vtk.vtkRenderer() render_window.AddRenderer(renderer) render_window_interactor.SetRenderWindow(render_window) renderer.AddViewProp(volume) #renderer.ResetCameraClippingRange() renderer.SetActiveCamera(camera) renderer.ResetCamera() renderer.SetBackground(0.0,0.0,0.0) render_window.Render() render_window_interactor.Initialize() #render_window_interactor.CreateRepeatingTimer(20) render_window_interactor.Start()
def __init__(self, ren, renWin, iren): self.ren = ren self.renWin = renWin self.iren = iren # Create a gaussian gs = vtk.vtkImageGaussianSource() gs.SetWholeExtent(0, 30, 0, 30, 0, 30) gs.SetMaximum(255.0) gs.SetStandardDeviation(5) gs.SetCenter(15, 15, 15) # threshold to leave a gap that should show up for # gradient opacity t = vtk.vtkImageThreshold() t.SetInputConnection(gs.GetOutputPort()) t.ReplaceInOn() t.SetInValue(0) t.ThresholdBetween(150, 200) # Use a shift scale to convert to unsigned char ss = vtk.vtkImageShiftScale() ss.SetInputConnection(t.GetOutputPort()) ss.SetOutputScalarTypeToUnsignedChar() # grid will be used for two component dependent grid0 = vtk.vtkImageGridSource() grid0.SetDataScalarTypeToUnsignedChar() grid0.SetGridSpacing(10, 10, 10) grid0.SetLineValue(200) grid0.SetFillValue(10) grid0.SetDataExtent(0, 30, 0, 30, 0, 30) # use dilation to thicken the grid d = vtk.vtkImageContinuousDilate3D() d.SetInputConnection(grid0.GetOutputPort()) d.SetKernelSize(3, 3, 3) # Now make a two component dependent iac = vtk.vtkImageAppendComponents() iac.AddInputConnection(d.GetOutputPort()) iac.AddInputConnection(ss.GetOutputPort()) # Some more gaussians for the four component indepent case gs1 = vtk.vtkImageGaussianSource() gs1.SetWholeExtent(0, 30, 0, 30, 0, 30) gs1.SetMaximum(255.0) gs1.SetStandardDeviation(4) gs1.SetCenter(5, 5, 5) t1 = vtk.vtkImageThreshold() t1.SetInputConnection(gs1.GetOutputPort()) t1.ReplaceInOn() t1.SetInValue(0) t1.ThresholdBetween(150, 256) gs2 = vtk.vtkImageGaussianSource() gs2.SetWholeExtent(0, 30, 0, 30, 0, 30) gs2.SetMaximum(255.0) gs2.SetStandardDeviation(4) gs2.SetCenter(12, 12, 12) gs3 = vtk.vtkImageGaussianSource() gs3.SetWholeExtent(0, 30, 0, 30, 0, 30) gs3.SetMaximum(255.0) gs3.SetStandardDeviation(4) gs3.SetCenter(19, 19, 19) t3 = vtk.vtkImageThreshold() t3.SetInputConnection(gs3.GetOutputPort()) t3.ReplaceInOn() t3.SetInValue(0) t3.ThresholdBetween(150, 256) gs4 = vtk.vtkImageGaussianSource() gs4.SetWholeExtent(0, 30, 0, 30, 0, 30) gs4.SetMaximum(255.0) gs4.SetStandardDeviation(4) gs4.SetCenter(26, 26, 26) # we need a few append filters ... iac1 = vtk.vtkImageAppendComponents() iac1.AddInputConnection(t1.GetOutputPort()) iac1.AddInputConnection(gs2.GetOutputPort()) iac2 = vtk.vtkImageAppendComponents() iac2.AddInputConnection(iac1.GetOutputPort()) iac2.AddInputConnection(t3.GetOutputPort()) iac3 = vtk.vtkImageAppendComponents() iac3.AddInputConnection(iac2.GetOutputPort()) iac3.AddInputConnection(gs4.GetOutputPort()) # create the four component dependend - # use lines in x, y, z for colors gridR = vtk.vtkImageGridSource() gridR.SetDataScalarTypeToUnsignedChar() gridR.SetGridSpacing(10, 100, 100) gridR.SetLineValue(250) gridR.SetFillValue(100) gridR.SetDataExtent(0, 30, 0, 30, 0, 30) dR = vtk.vtkImageContinuousDilate3D() dR.SetInputConnection(gridR.GetOutputPort()) dR.SetKernelSize(2, 2, 2) gridG = vtk.vtkImageGridSource() gridG.SetDataScalarTypeToUnsignedChar() gridG.SetGridSpacing(100, 10, 100) gridG.SetLineValue(250) gridG.SetFillValue(100) gridG.SetDataExtent(0, 30, 0, 30, 0, 30) dG = vtk.vtkImageContinuousDilate3D() dG.SetInputConnection(gridG.GetOutputPort()) dG.SetKernelSize(2, 2, 2) gridB = vtk.vtkImageGridSource() gridB.SetDataScalarTypeToUnsignedChar() gridB.SetGridSpacing(100, 100, 10) gridB.SetLineValue(0) gridB.SetFillValue(250) gridB.SetDataExtent(0, 30, 0, 30, 0, 30) dB = vtk.vtkImageContinuousDilate3D() dB.SetInputConnection(gridB.GetOutputPort()) dB.SetKernelSize(2, 2, 2) # need some appending iacRG = vtk.vtkImageAppendComponents() iacRG.AddInputConnection(dR.GetOutputPort()) iacRG.AddInputConnection(dG.GetOutputPort()) iacRGB = vtk.vtkImageAppendComponents() iacRGB.AddInputConnection(iacRG.GetOutputPort()) iacRGB.AddInputConnection(dB.GetOutputPort()) iacRGBA = vtk.vtkImageAppendComponents() iacRGBA.AddInputConnection(iacRGB.GetOutputPort()) iacRGBA.AddInputConnection(ss.GetOutputPort()) # We need a bunch of opacity functions # this one is a simple ramp to .2 rampPoint2 = vtk.vtkPiecewiseFunction() rampPoint2.AddPoint(0, 0.0) rampPoint2.AddPoint(255, 0.2) # this one is a simple ramp to 1 ramp1 = vtk.vtkPiecewiseFunction() ramp1.AddPoint(0, 0.0) ramp1.AddPoint(255, 1.0) # this one shows a sharp surface surface = vtk.vtkPiecewiseFunction() surface.AddPoint(0, 0.0) surface.AddPoint(10, 0.0) surface.AddPoint(50, 1.0) surface.AddPoint(255, 1.0) # this one is constant 1 constant1 = vtk.vtkPiecewiseFunction() constant1.AddPoint(0, 1.0) constant1.AddPoint(255, 1.0) # this one is used for gradient opacity gop = vtk.vtkPiecewiseFunction() gop.AddPoint(0, 0.0) gop.AddPoint(20, 0.0) gop.AddPoint(60, 1.0) gop.AddPoint(255, 1.0) # We need a bunch of color functions # This one is a simple rainbow rainbow = vtk.vtkColorTransferFunction() rainbow.SetColorSpaceToHSV() rainbow.HSVWrapOff() rainbow.AddHSVPoint(0, 0.1, 1.0, 1.0) rainbow.AddHSVPoint(255, 0.9, 1.0, 1.0) # this is constant red red = vtk.vtkColorTransferFunction() red.AddRGBPoint(0, 1, 0, 0) red.AddRGBPoint(255, 1, 0, 0) # this is constant green green = vtk.vtkColorTransferFunction() green.AddRGBPoint(0, 0, 1, 0) green.AddRGBPoint(255, 0, 1, 0) # this is constant blue blue = vtk.vtkColorTransferFunction() blue.AddRGBPoint(0, 0, 0, 1) blue.AddRGBPoint(255, 0, 0, 1) # this is constant yellow yellow = vtk.vtkColorTransferFunction() yellow.AddRGBPoint(0, 1, 1, 0) yellow.AddRGBPoint(255, 1, 1, 0) #ren = vtk.vtkRenderer() #renWin = vtk.vtkRenderWindow() self.renWin.AddRenderer(self.ren) self.renWin.SetSize(500, 500) #iren = vtk.vtkRenderWindowInteractor() self.iren.SetRenderWindow(self.renWin) self.ren.GetCullers().InitTraversal() culler = self.ren.GetCullers().GetNextItem() culler.SetSortingStyleToBackToFront() # We need 25 mapper / actor pairs which we will render # in a grid. Going down we will vary the input data # with the top row unsigned char, then float, then # two dependent components, then four dependent components # then four independent components. Going across we # will vary the rendering method with MIP, Composite, # Composite Shade, Composite GO, and Composite GO Shade. # Create the 5 by 5 grids self.volumeProperty = [[0 for col in range(0, 5)] for row in range(0, 5)] self.volumeMapper = [[0 for col in range(0, 5)] for row in range(0, 5)] volume = [[0 for col in range(0, 5)] for row in range(0, 5)] for i in range(0, 5): for j in range(0, 5): self.volumeProperty[i][j] = vtk.vtkVolumeProperty() self.volumeMapper[i][j] = vtk.vtkFixedPointVolumeRayCastMapper() self.volumeMapper[i][j].SetSampleDistance(0.25) volume[i][j] = vtk.vtkVolume() volume[i][j].SetMapper(self.volumeMapper[i][j]) volume[i][j].SetProperty(self.volumeProperty[i][j]) volume[i][j].AddPosition(i * 30, j * 30, 0) self.ren.AddVolume(volume[i][j]) for i in range(0, 5): self.volumeMapper[0][i].SetInputConnection(t.GetOutputPort()) self.volumeMapper[1][i].SetInputConnection(ss.GetOutputPort()) self.volumeMapper[2][i].SetInputConnection(iac.GetOutputPort()) self.volumeMapper[3][i].SetInputConnection(iac3.GetOutputPort()) self.volumeMapper[4][i].SetInputConnection(iacRGBA.GetOutputPort()) self.volumeMapper[i][0].SetBlendModeToMaximumIntensity() self.volumeMapper[i][1].SetBlendModeToComposite() self.volumeMapper[i][2].SetBlendModeToComposite() self.volumeMapper[i][3].SetBlendModeToComposite() self.volumeMapper[i][4].SetBlendModeToComposite() self.volumeProperty[0][i].IndependentComponentsOn() self.volumeProperty[1][i].IndependentComponentsOn() self.volumeProperty[2][i].IndependentComponentsOff() self.volumeProperty[3][i].IndependentComponentsOn() self.volumeProperty[4][i].IndependentComponentsOff() self.volumeProperty[0][i].SetColor(rainbow) self.volumeProperty[0][i].SetScalarOpacity(rampPoint2) self.volumeProperty[0][i].SetGradientOpacity(constant1) self.volumeProperty[1][i].SetColor(rainbow) self.volumeProperty[1][i].SetScalarOpacity(rampPoint2) self.volumeProperty[1][i].SetGradientOpacity(constant1) self.volumeProperty[2][i].SetColor(rainbow) self.volumeProperty[2][i].SetScalarOpacity(rampPoint2) self.volumeProperty[2][i].SetGradientOpacity(constant1) self.volumeProperty[3][i].SetColor(0, red) self.volumeProperty[3][i].SetColor(1, green) self.volumeProperty[3][i].SetColor(2, blue) self.volumeProperty[3][i].SetColor(3, yellow) self.volumeProperty[3][i].SetScalarOpacity(0, rampPoint2) self.volumeProperty[3][i].SetScalarOpacity(1, rampPoint2) self.volumeProperty[3][i].SetScalarOpacity(2, rampPoint2) self.volumeProperty[3][i].SetScalarOpacity(3, rampPoint2) self.volumeProperty[3][i].SetGradientOpacity(0, constant1) self.volumeProperty[3][i].SetGradientOpacity(1, constant1) self.volumeProperty[3][i].SetGradientOpacity(2, constant1) self.volumeProperty[3][i].SetGradientOpacity(3, constant1) self.volumeProperty[3][i].SetComponentWeight(0, 1) self.volumeProperty[3][i].SetComponentWeight(1, 1) self.volumeProperty[3][i].SetComponentWeight(2, 1) self.volumeProperty[3][i].SetComponentWeight(3, 1) self.volumeProperty[4][i].SetColor(rainbow) self.volumeProperty[4][i].SetScalarOpacity(rampPoint2) self.volumeProperty[4][i].SetGradientOpacity(constant1) self.volumeProperty[i][2].ShadeOn() self.volumeProperty[i][4].ShadeOn(0) self.volumeProperty[i][4].ShadeOn(1) self.volumeProperty[i][4].ShadeOn(2) self.volumeProperty[i][4].ShadeOn(3) self.volumeProperty[0][0].SetScalarOpacity(ramp1) self.volumeProperty[1][0].SetScalarOpacity(ramp1) self.volumeProperty[2][0].SetScalarOpacity(ramp1) self.volumeProperty[3][0].SetScalarOpacity(0, surface) self.volumeProperty[3][0].SetScalarOpacity(1, surface) self.volumeProperty[3][0].SetScalarOpacity(2, surface) self.volumeProperty[3][0].SetScalarOpacity(3, surface) self.volumeProperty[4][0].SetScalarOpacity(ramp1) self.volumeProperty[0][2].SetScalarOpacity(surface) self.volumeProperty[1][2].SetScalarOpacity(surface) self.volumeProperty[2][2].SetScalarOpacity(surface) self.volumeProperty[3][2].SetScalarOpacity(0, surface) self.volumeProperty[3][2].SetScalarOpacity(1, surface) self.volumeProperty[3][2].SetScalarOpacity(2, surface) self.volumeProperty[3][2].SetScalarOpacity(3, surface) self.volumeProperty[4][2].SetScalarOpacity(surface) self.volumeProperty[0][4].SetScalarOpacity(surface) self.volumeProperty[1][4].SetScalarOpacity(surface) self.volumeProperty[2][4].SetScalarOpacity(surface) self.volumeProperty[3][4].SetScalarOpacity(0, surface) self.volumeProperty[3][4].SetScalarOpacity(1, surface) self.volumeProperty[3][4].SetScalarOpacity(2, surface) self.volumeProperty[3][4].SetScalarOpacity(3, surface) self.volumeProperty[4][4].SetScalarOpacity(surface) self.volumeProperty[0][3].SetGradientOpacity(gop) self.volumeProperty[1][3].SetGradientOpacity(gop) self.volumeProperty[2][3].SetGradientOpacity(gop) self.volumeProperty[3][3].SetGradientOpacity(0, gop) self.volumeProperty[3][3].SetGradientOpacity(2, gop) self.volumeProperty[4][3].SetGradientOpacity(gop) self.volumeProperty[3][3].SetScalarOpacity(0, ramp1) self.volumeProperty[3][3].SetScalarOpacity(2, ramp1) self.volumeProperty[0][4].SetGradientOpacity(gop) self.volumeProperty[1][4].SetGradientOpacity(gop) self.volumeProperty[2][4].SetGradientOpacity(gop) self.volumeProperty[3][4].SetGradientOpacity(0, gop) self.volumeProperty[3][4].SetGradientOpacity(2, gop) self.volumeProperty[4][4].SetGradientOpacity(gop) self.renWin.Render() self.ren.GetActiveCamera().Dolly(1.3) self.ren.GetActiveCamera().Azimuth(15) self.ren.GetActiveCamera().Elevation(5) self.ren.ResetCameraClippingRange()
def __init__( self, inputobj=None, c=('b', 'lb', 'lg', 'y', 'r'), alpha=(0.0, 0.0, 0.2, 0.4, 0.8, 1), alphaGradient=None, mode=0, origin=None, spacing=None, shape=None, mapperType='smart', ): vtk.vtkVolume.__init__(self) ActorBase.__init__(self) inputtype = str(type(inputobj)) #colors.printc('Volume inputtype', inputtype) if isinstance(inputobj, str): import glob inputobj = sorted(glob.glob(inputobj)) if inputobj is None: img = vtk.vtkImageData() elif utils.isSequence(inputobj): if isinstance(inputobj[0], str): # scan sequence of BMP files ima = vtk.vtkImageAppend() ima.SetAppendAxis(2) pb = utils.ProgressBar(0, len(inputobj)) for i in pb.range(): f = inputobj[i] picr = vtk.vtkBMPReader() picr.SetFileName(f) picr.Update() mgf = vtk.vtkImageMagnitude() mgf.SetInputData(picr.GetOutput()) mgf.Update() ima.AddInputData(mgf.GetOutput()) pb.print('loading..') ima.Update() img = ima.GetOutput() else: if "ndarray" not in inputtype: inputobj = np.array(inputobj) varr = numpy_to_vtk(inputobj.ravel(order='F'), deep=True, array_type=vtk.VTK_FLOAT) varr.SetName('input_scalars') img = vtk.vtkImageData() if shape is not None: img.SetDimensions(shape) else: img.SetDimensions(inputobj.shape) img.GetPointData().SetScalars(varr) #to convert rgb to numpy # img_scalar = data.GetPointData().GetScalars() # dims = data.GetDimensions() # n_comp = img_scalar.GetNumberOfComponents() # temp = numpy_support.vtk_to_numpy(img_scalar) # numpy_data = temp.reshape(dims[1],dims[0],n_comp) # numpy_data = numpy_data.transpose(0,1,2) # numpy_data = np.flipud(numpy_data) elif "ImageData" in inputtype: img = inputobj elif "UniformGrid" in inputtype: img = inputobj elif "UnstructuredGrid" in inputtype: img = inputobj mapperType = 'tetra' elif hasattr( inputobj, "GetOutput"): # passing vtk object, try extract imagdedata if hasattr(inputobj, "Update"): inputobj.Update() img = inputobj.GetOutput() else: colors.printc("Volume(): cannot understand input type:\n", inputtype, c=1) return if 'gpu' in mapperType: self._mapper = vtk.vtkGPUVolumeRayCastMapper() elif 'opengl_gpu' in mapperType: self._mapper = vtk.vtkOpenGLGPUVolumeRayCastMapper() elif 'smart' in mapperType: self._mapper = vtk.vtkSmartVolumeMapper() elif 'fixed' in mapperType: self._mapper = vtk.vtkFixedPointVolumeRayCastMapper() elif 'tetra' in mapperType: self._mapper = vtk.vtkProjectedTetrahedraMapper() elif 'unstr' in mapperType: self._mapper = vtk.vtkUnstructuredGridVolumeRayCastMapper() else: print("Error unknown mapperType", mapperType) raise RuntimeError() if origin is not None: img.SetOrigin(origin) if spacing is not None: img.SetSpacing(spacing) if shape is not None: img.SetDimensions(shape) self._imagedata = img self._mapper.SetInputData(img) self.SetMapper(self._mapper) self.mode(mode).color(c).alpha(alpha).alphaGradient(alphaGradient) self.GetProperty().SetInterpolationType(1) # remember stuff: self._mode = mode self._color = c self._alpha = alpha self._alphaGrad = alphaGradient
def testVolumePicker(self): # volume render a medical data set # renderer and interactor ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iRen = vtk.vtkRenderWindowInteractor() iRen.SetRenderWindow(renWin) # read the volume v16 = vtk.vtkVolume16Reader() v16.SetDataDimensions(64, 64) v16.SetImageRange(1, 93) v16.SetDataByteOrderToLittleEndian() v16.SetFilePrefix(VTK_DATA_ROOT + "/Data/headsq/quarter") v16.SetDataSpacing(3.2, 3.2, 1.5) #--------------------------------------------------------- # set up the volume rendering volumeMapper = vtk.vtkFixedPointVolumeRayCastMapper() volumeMapper.SetInputConnection(v16.GetOutputPort()) volumeColor = vtk.vtkColorTransferFunction() volumeColor.AddRGBPoint(0, 0.0, 0.0, 0.0) volumeColor.AddRGBPoint(180, 0.3, 0.1, 0.2) volumeColor.AddRGBPoint(1000, 1.0, 0.7, 0.6) volumeColor.AddRGBPoint(2000, 1.0, 1.0, 0.9) volumeScalarOpacity = vtk.vtkPiecewiseFunction() volumeScalarOpacity.AddPoint(0, 0.0) volumeScalarOpacity.AddPoint(180, 0.0) volumeScalarOpacity.AddPoint(1000, 0.2) volumeScalarOpacity.AddPoint(2000, 0.8) volumeGradientOpacity = vtk.vtkPiecewiseFunction() volumeGradientOpacity.AddPoint(0, 0.0) volumeGradientOpacity.AddPoint(90, 0.5) volumeGradientOpacity.AddPoint(100, 1.0) volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(volumeColor) volumeProperty.SetScalarOpacity(volumeScalarOpacity) volumeProperty.SetGradientOpacity(volumeGradientOpacity) volumeProperty.SetInterpolationTypeToLinear() volumeProperty.ShadeOn() volumeProperty.SetAmbient(0.6) volumeProperty.SetDiffuse(0.6) volumeProperty.SetSpecular(0.1) volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) #--------------------------------------------------------- # Do the surface rendering boneExtractor = vtk.vtkMarchingCubes() boneExtractor.SetInputConnection(v16.GetOutputPort()) boneExtractor.SetValue(0, 1150) boneNormals = vtk.vtkPolyDataNormals() boneNormals.SetInputConnection(boneExtractor.GetOutputPort()) boneNormals.SetFeatureAngle(60.0) boneStripper = vtk.vtkStripper() boneStripper.SetInputConnection(boneNormals.GetOutputPort()) boneMapper = vtk.vtkPolyDataMapper() boneMapper.SetInputConnection(boneStripper.GetOutputPort()) boneMapper.ScalarVisibilityOff() boneProperty = vtk.vtkProperty() boneProperty.SetColor(1.0, 1.0, 0.9) bone = vtk.vtkActor() bone.SetMapper(boneMapper) bone.SetProperty(boneProperty) #--------------------------------------------------------- # Create an image actor table = vtk.vtkLookupTable() table.SetRange(0, 2000) table.SetRampToLinear() table.SetValueRange(0, 1) table.SetHueRange(0, 0) table.SetSaturationRange(0, 0) mapToColors = vtk.vtkImageMapToColors() mapToColors.SetInputConnection(v16.GetOutputPort()) mapToColors.SetLookupTable(table) imageActor = vtk.vtkImageActor() imageActor.GetMapper().SetInputConnection(mapToColors.GetOutputPort()) imageActor.SetDisplayExtent(32, 32, 0, 63, 0, 92) #--------------------------------------------------------- # make a transform and some clipping planes transform = vtk.vtkTransform() transform.RotateWXYZ(-20, 0.0, -0.7, 0.7) volume.SetUserTransform(transform) bone.SetUserTransform(transform) imageActor.SetUserTransform(transform) c = volume.GetCenter() volumeClip = vtk.vtkPlane() volumeClip.SetNormal(0, 1, 0) volumeClip.SetOrigin(c) boneClip = vtk.vtkPlane() boneClip.SetNormal(0, 0, 1) boneClip.SetOrigin(c) volumeMapper.AddClippingPlane(volumeClip) boneMapper.AddClippingPlane(boneClip) #--------------------------------------------------------- ren.AddViewProp(volume) ren.AddViewProp(bone) ren.AddViewProp(imageActor) camera = ren.GetActiveCamera() camera.SetFocalPoint(c) camera.SetPosition(c[0] + 500, c[1] - 100, c[2] - 100) camera.SetViewUp(0, 0, -1) ren.ResetCameraClippingRange() renWin.Render() #--------------------------------------------------------- # the cone should point along the Z axis coneSource = vtk.vtkConeSource() coneSource.CappingOn() coneSource.SetHeight(12) coneSource.SetRadius(5) coneSource.SetResolution(31) coneSource.SetCenter(6, 0, 0) coneSource.SetDirection(-1, 0, 0) #--------------------------------------------------------- picker = vtk.vtkVolumePicker() picker.SetTolerance(1.0e-6) picker.SetVolumeOpacityIsovalue(0.01) # This should usually be left alone, but is used here to increase coverage picker.UseVolumeGradientOpacityOn() # A function to point an actor along a vector def PointCone(actor, n): if n[0] < 0.0: actor.RotateWXYZ(180, 0, 1, 0) actor.RotateWXYZ(180, (n[0] - 1.0) * 0.5, n[1] * 0.5, n[2] * 0.5) else: actor.RotateWXYZ(180, (n[0] + 1.0) * 0.5, n[1] * 0.5, n[2] * 0.5) # Pick the actor picker.Pick(192, 103, 0, ren) #print picker p = picker.GetPickPosition() n = picker.GetPickNormal() coneActor1 = vtk.vtkActor() coneActor1.PickableOff() coneMapper1 = vtk.vtkDataSetMapper() coneMapper1.SetInputConnection(coneSource.GetOutputPort()) coneActor1.SetMapper(coneMapper1) coneActor1.GetProperty().SetColor(1, 0, 0) coneActor1.SetPosition(p) PointCone(coneActor1, n) ren.AddViewProp(coneActor1) # Pick the volume picker.Pick(90, 180, 0, ren) p = picker.GetPickPosition() n = picker.GetPickNormal() coneActor2 = vtk.vtkActor() coneActor2.PickableOff() coneMapper2 = vtk.vtkDataSetMapper() coneMapper2.SetInputConnection(coneSource.GetOutputPort()) coneActor2.SetMapper(coneMapper2) coneActor2.GetProperty().SetColor(1, 0, 0) coneActor2.SetPosition(p) PointCone(coneActor2, n) ren.AddViewProp(coneActor2) # Pick the image picker.Pick(200, 200, 0, ren) p = picker.GetPickPosition() n = picker.GetPickNormal() coneActor3 = vtk.vtkActor() coneActor3.PickableOff() coneMapper3 = vtk.vtkDataSetMapper() coneMapper3.SetInputConnection(coneSource.GetOutputPort()) coneActor3.SetMapper(coneMapper3) coneActor3.GetProperty().SetColor(1, 0, 0) coneActor3.SetPosition(p) PointCone(coneActor3, n) ren.AddViewProp(coneActor3) # Pick a clipping plane picker.PickClippingPlanesOn() picker.Pick(145, 160, 0, ren) p = picker.GetPickPosition() n = picker.GetPickNormal() coneActor4 = vtk.vtkActor() coneActor4.PickableOff() coneMapper4 = vtk.vtkDataSetMapper() coneMapper4.SetInputConnection(coneSource.GetOutputPort()) coneActor4.SetMapper(coneMapper4) coneActor4.GetProperty().SetColor(1, 0, 0) coneActor4.SetPosition(p) PointCone(coneActor4, n) ren.AddViewProp(coneActor4) ren.ResetCameraClippingRange() # render and interact with data renWin.Render() img_file = "VolumePicker.png" vtk.test.Testing.compareImage(iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25) vtk.test.Testing.interact()
def LoadVolume(self): proj = prj.Project() #image = imagedata_utils.to_vtk(n_array, spacing, slice_number, orientation) if not self.loaded_image: self.LoadImage() self.loaded_image = 1 image = self.image number_filters = len(self.config['convolutionFilters']) if (prj.Project().original_orientation == const.AXIAL): flip_image = True else: flip_image = False #if (flip_image): update_progress = vtk_utils.ShowProgress(2 + number_filters) # Flip original vtkImageData flip = vtk.vtkImageFlip() flip.SetInputData(image) flip.SetFilteredAxis(1) flip.FlipAboutOriginOn() # flip.ReleaseDataFlagOn() flip_ref = weakref.ref(flip) flip_ref().AddObserver( "ProgressEvent", lambda obj, evt: update_progress(flip_ref(), "Rendering...")) flip.Update() image = flip.GetOutput() scale = image.GetScalarRange() self.scale = scale cast = vtk.vtkImageShiftScale() cast.SetInputData(image) cast.SetShift(abs(scale[0])) cast.SetOutputScalarTypeToUnsignedShort() # cast.ReleaseDataFlagOn() cast_ref = weakref.ref(cast) cast_ref().AddObserver( "ProgressEvent", lambda obj, evt: update_progress(cast_ref(), "Rendering...")) cast.Update() image2 = cast self.imagedata = image2 if self.config['advancedCLUT']: self.Create16bColorTable(scale) self.CreateOpacityTable(scale) else: self.Create8bColorTable(scale) self.Create8bOpacityTable(scale) image2 = self.ApplyConvolution(image2.GetOutput(), update_progress) self.final_imagedata = image2 # Changed the vtkVolumeRayCast to vtkFixedPointVolumeRayCastMapper # because it's faster and the image is better # TODO: To test if it's true. if const.TYPE_RAYCASTING_MAPPER: volume_mapper = vtk.vtkVolumeRayCastMapper() #volume_mapper.AutoAdjustSampleDistancesOff() #volume_mapper.SetInput(image2) #volume_mapper.SetVolumeRayCastFunction(composite_function) #volume_mapper.SetGradientEstimator(gradientEstimator) volume_mapper.IntermixIntersectingGeometryOn() self.volume_mapper = volume_mapper else: if int(ses.Session().rendering) == 0: volume_mapper = vtk.vtkFixedPointVolumeRayCastMapper() #volume_mapper.AutoAdjustSampleDistancesOff() self.volume_mapper = volume_mapper volume_mapper.IntermixIntersectingGeometryOn() else: volume_mapper = vtk.vtkGPUVolumeRayCastMapper() volume_mapper.UseJitteringOn() self.volume_mapper = volume_mapper self.SetTypeRaycasting() volume_mapper.SetInputData(image2) # TODO: Look to this #volume_mapper_hw = vtk.vtkVolumeTextureMapper3D() #volume_mapper_hw.SetInput(image2) #Cut Plane #CutPlane(image2, volume_mapper) #self.color_transfer = color_transfer volume_properties = vtk.vtkVolumeProperty() #volume_properties.IndependentComponentsOn() volume_properties.SetInterpolationTypeToLinear() volume_properties.SetColor(self.color_transfer) try: volume_properties.SetScalarOpacity(self.opacity_transfer_func) except NameError: pass if not self.volume_mapper.IsA("vtkGPUVolumeRayCastMapper"): # Using these lines to improve the raycasting quality. These values # seems related to the distance from ray from raycasting. # TODO: Need to see values that improve the quality and don't decrease # the performance. 2.0 seems to be a good value to pix_diag pix_diag = 2.0 volume_mapper.SetImageSampleDistance(0.25) volume_mapper.SetSampleDistance(pix_diag / 5.0) volume_properties.SetScalarOpacityUnitDistance(pix_diag) self.volume_properties = volume_properties self.SetShading() volume = vtk.vtkVolume() volume.SetMapper(volume_mapper) volume.SetProperty(volume_properties) self.volume = volume colour = self.GetBackgroundColour() self.exist = 1 if self.plane: self.plane.SetVolumeMapper(volume_mapper) Publisher.sendMessage('Load volume into viewer', volume=volume, colour=colour, ww=self.ww, wl=self.wl) del flip del cast
coneActor.SetMapper(coneMapper) coneActor.GetProperty().SetColor(0.5, 0.5, 1.0) # if one of the cones from above is not commented out, shows only # the cone on a mac, otherwise, it shows reader = vtk.vtkPNMReader() reader.SetFilePattern("mini/checkerboard%i.pgm") size = 5 reader.SetDataExtent(0, size, 0, size, 0, size) reader.SetDataSpacing(1, 1, 1) reader.SetDataScalarTypeToUnsignedChar() image = reader.GetOutput() image.Update() mapper = vtk.vtkFixedPointVolumeRayCastMapper() mapper.SetInput(image) if size < 20: mapper.SetSampleDistance(float(size) / 1000) mapper.SetInteractiveSampleDistance(float(size) / 500) volproperty = vtk.vtkVolumeProperty() color = vtk.vtkPiecewiseFunction() color.AddSegment(0, 0, 255, 1) volproperty.SetColor(0, color) volume = vtk.vtkVolume() volume.SetMapper(mapper) volume.SetProperty(volproperty) ren = vtk.vtkRenderer() ren.SetBackground(.5, .5, .5) vtkda.GetRenderWindow().AddRenderer(ren)
def __init__( self, inputobj=None, c='RdBu_r', alpha=(0.0, 0.0, 0.2, 0.4, 0.8, 1.0), alphaGradient=None, alphaUnit=1, mode=0, shade=False, spacing=None, dims=None, origin=None, mapper='smart', ): vtk.vtkVolume.__init__(self) BaseGrid.__init__(self) ################### if isinstance(inputobj, str): if "https://" in inputobj: from vedo.io import download inputobj = download(inputobj, verbose=False) # fpath elif os.path.isfile(inputobj): pass else: inputobj = sorted(glob.glob(inputobj)) ################### if 'gpu' in mapper: self._mapper = vtk.vtkGPUVolumeRayCastMapper() elif 'opengl_gpu' in mapper: self._mapper = vtk.vtkOpenGLGPUVolumeRayCastMapper() elif 'smart' in mapper: self._mapper = vtk.vtkSmartVolumeMapper() elif 'fixed' in mapper: self._mapper = vtk.vtkFixedPointVolumeRayCastMapper() elif isinstance(mapper, vtk.vtkMapper): self._mapper = mapper else: print("Error unknown mapper type", [mapper]) raise RuntimeError() self.SetMapper(self._mapper) ################### inputtype = str(type(inputobj)) #colors.printc('Volume inputtype', inputtype) if inputobj is None: img = vtk.vtkImageData() elif utils.isSequence(inputobj): if isinstance(inputobj[0], str): # scan sequence of BMP files ima = vtk.vtkImageAppend() ima.SetAppendAxis(2) pb = utils.ProgressBar(0, len(inputobj)) for i in pb.range(): f = inputobj[i] picr = vtk.vtkBMPReader() picr.SetFileName(f) picr.Update() mgf = vtk.vtkImageMagnitude() mgf.SetInputData(picr.GetOutput()) mgf.Update() ima.AddInputData(mgf.GetOutput()) pb.print('loading...') ima.Update() img = ima.GetOutput() else: if "ndarray" not in inputtype: inputobj = np.array(inputobj) if len(inputobj.shape) == 1: varr = numpy_to_vtk(inputobj, deep=True, array_type=vtk.VTK_FLOAT) else: if len(inputobj.shape) > 2: inputobj = np.transpose(inputobj, axes=[2, 1, 0]) varr = numpy_to_vtk(inputobj.ravel(order='F'), deep=True, array_type=vtk.VTK_FLOAT) varr.SetName('input_scalars') img = vtk.vtkImageData() if dims is not None: img.SetDimensions(dims) else: if len(inputobj.shape) == 1: colors.printc( "Error: must set dimensions (dims keyword) in Volume.", c='r') raise RuntimeError() img.SetDimensions(inputobj.shape) img.GetPointData().SetScalars(varr) #to convert rgb to numpy # img_scalar = data.GetPointData().GetScalars() # dims = data.GetDimensions() # n_comp = img_scalar.GetNumberOfComponents() # temp = numpy_support.vtk_to_numpy(img_scalar) # numpy_data = temp.reshape(dims[1],dims[0],n_comp) # numpy_data = numpy_data.transpose(0,1,2) # numpy_data = np.flipud(numpy_data) elif "ImageData" in inputtype: img = inputobj elif isinstance(inputobj, Volume): img = inputobj.inputdata() elif "UniformGrid" in inputtype: img = inputobj elif hasattr( inputobj, "GetOutput"): # passing vtk object, try extract imagdedata if hasattr(inputobj, "Update"): inputobj.Update() img = inputobj.GetOutput() elif isinstance(inputobj, str): from vedo.io import loadImageData, download if "https://" in inputobj: inputobj = download(inputobj, verbose=False) img = loadImageData(inputobj) else: colors.printc("Volume(): cannot understand input type:\n", inputtype, c='r') return if dims is not None: img.SetDimensions(dims) if origin is not None: img.SetOrigin(origin) ### DIFFERENT from volume.origin()! if spacing is not None: img.SetSpacing(spacing) self._data = img self._mapper.SetInputData(img) self.mode(mode).color(c).alpha(alpha).alphaGradient(alphaGradient) self.GetProperty().SetShade(True) self.GetProperty().SetInterpolationType(1) self.GetProperty().SetScalarOpacityUnitDistance(alphaUnit) # remember stuff: self._mode = mode self._color = c self._alpha = alpha self._alphaGrad = alphaGradient self._alphaUnit = alphaUnit
def SetUp(self): ''' Set up cursor3D ''' def OnClosing(): self.root.quit() def ViewerDown(tkvw): viewer = tkvw.GetImageViewer() ViewerSetZSlice(tkvw, viewer.GetZSlice() - 1) def ViewerUp(tkvw): viewer = tkvw.GetImageViewer() ViewerSetZSlice(tkvw, viewer.GetZSlice() + 1) def ViewerSetZSlice(tkvw, z): viewer = tkvw.GetImageViewer() viewer.SetZSlice(z) txt = 'slice: ' + str(z) sliceLabel.configure(text=txt) tkvw.Render() def SetCursorFromViewer(event): x = int(event.x) y = int(event.y) # We have to flip y axis because tk uses upper right origin. self.root.update_idletasks() height = int(self.tkvw.configure()['height'][4]) y = height - y z = self.tkvw.GetImageViewer().GetZSlice() SetCursor(x / IMAGE_MAG_X, y / IMAGE_MAG_Y, z / IMAGE_MAG_Z) def SetCursor(x, y, z): CURSOR_X = x CURSOR_Y = y CURSOR_Z = z axes.SetOrigin(CURSOR_X, CURSOR_Y, CURSOR_Z) imageCursor.SetCursorPosition(CURSOR_X * IMAGE_MAG_X, CURSOR_Y * IMAGE_MAG_Y, CURSOR_Z * IMAGE_MAG_Z) self.viewer.Render() self.tkrw.Render() # Pipeline stuff. reader = vtk.vtkSLCReader() reader.SetFileName(VTK_DATA_ROOT + "/Data/neghip.slc") # Cursor stuff magnify = vtk.vtkImageMagnify() magnify.SetInputConnection(reader.GetOutputPort()) magnify.SetMagnificationFactors(IMAGE_MAG_X, IMAGE_MAG_Y, IMAGE_MAG_Z) imageCursor = vtk.vtkImageCursor3D() imageCursor.SetInputConnection(magnify.GetOutputPort()) imageCursor.SetCursorPosition(CURSOR_X * IMAGE_MAG_X, CURSOR_Y * IMAGE_MAG_Y, CURSOR_Z * IMAGE_MAG_Z) imageCursor.SetCursorValue(255) imageCursor.SetCursorRadius(50 * IMAGE_MAG_X) axes = vtk.vtkAxes() axes.SymmetricOn() axes.SetOrigin(CURSOR_X, CURSOR_Y, CURSOR_Z) axes.SetScaleFactor(50.0) axes_mapper = vtk.vtkPolyDataMapper() axes_mapper.SetInputConnection(axes.GetOutputPort()) axesActor = vtk.vtkActor() axesActor.SetMapper(axes_mapper) axesActor.GetProperty().SetAmbient(0.5) # Image viewer stuff. viewer = vtk.vtkImageViewer() viewer.SetInputConnection(imageCursor.GetOutputPort()) viewer.SetZSlice(CURSOR_Z * IMAGE_MAG_Z) viewer.SetColorWindow(256) viewer.SetColorLevel(128) # Create transfer functions for opacity and color. opacity_transfer_function = vtk.vtkPiecewiseFunction() opacity_transfer_function.AddPoint(20, 0.0) opacity_transfer_function.AddPoint(255, 0.2) color_transfer_function = vtk.vtkColorTransferFunction() color_transfer_function.AddRGBPoint(0, 0, 0, 0) color_transfer_function.AddRGBPoint(64, 1, 0, 0) color_transfer_function.AddRGBPoint(128, 0, 0, 1) color_transfer_function.AddRGBPoint(192, 0, 1, 0) color_transfer_function.AddRGBPoint(255, 0, .2, 0) # Create properties, mappers, volume actors, and ray cast function. volume_property = vtk.vtkVolumeProperty() volume_property.SetColor(color_transfer_function) # volume_property.SetColor(color_transfer_function[0], # color_transfer_function[1], # color_transfer_function[2]) volume_property.SetScalarOpacity(opacity_transfer_function) volume_mapper = vtk.vtkFixedPointVolumeRayCastMapper() volume_mapper.SetInputConnection(reader.GetOutputPort()) volume = vtk.vtkVolume() volume.SetMapper(volume_mapper) volume.SetProperty(volume_property) # Create outline. outline = vtk.vtkOutlineFilter() outline.SetInputConnection(reader.GetOutputPort()) outline_mapper = vtk.vtkPolyDataMapper() outline_mapper.SetInputConnection(outline.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(outline_mapper) outlineActor.GetProperty().SetColor(1, 1, 1) # Create the renderer. ren = vtk.vtkRenderer() ren.AddActor(axesActor) ren.AddVolume(volume) ren.SetBackground(0.1, 0.2, 0.4) renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) renWin.SetSize(256, 256) # Create the GUI: two renderer widgets and a quit button. self.root = tkinter.Tk() self.root.title("cursor3D") # Define what to do when the user explicitly closes a window. self.root.protocol("WM_DELETE_WINDOW", OnClosing) # Help label, frame and quit button helpLabel = tkinter.Label( self.root, text= "MiddleMouse (or shift-LeftMouse) in image viewer to place cursor") displayFrame = tkinter.Frame(self.root) quitButton = tkinter.Button(self.root, text="Quit", command=OnClosing) # Pack the GUI. helpLabel.pack() displayFrame.pack(fill=BOTH, expand=TRUE) quitButton.pack(fill=X) # Create the viewer widget. viewerFrame = tkinter.Frame(displayFrame) viewerFrame.pack(padx=3, pady=3, side=LEFT, anchor=N, fill=BOTH, expand=FALSE) self.tkvw = vtkTkImageViewerWidget(viewerFrame, iv=viewer, width=264, height=264) viewerControls = tkinter.Frame(viewerFrame) viewerControls.pack(side=BOTTOM, anchor=S, fill=BOTH, expand=TRUE) self.tkvw.pack(side=TOP, anchor=N, fill=BOTH, expand=FALSE) downButton = tkinter.Button(viewerControls, text="Down", command=[ViewerDown, self.tkvw]) upButton = tkinter.Button(viewerControls, text="Up", command=[ViewerUp, self.tkvw]) sliceLabel = tkinter.Label(viewerControls, text="slice: " + str(CURSOR_Z * IMAGE_MAG_Z)) downButton.pack(side=LEFT, expand=TRUE, fill=BOTH) upButton.pack(side=LEFT, expand=TRUE, fill=BOTH) sliceLabel.pack(side=LEFT, expand=TRUE, fill=BOTH) # Create the render widget renderFrame = tkinter.Frame(displayFrame) renderFrame.pack(padx=3, pady=3, side=LEFT, anchor=N, fill=BOTH, expand=TRUE) self.tkrw = vtkTkRenderWidget(renderFrame, rw=renWin, width=264, height=264) self.tkrw.pack(side=TOP, anchor=N, fill=BOTH, expand=TRUE) # Bindings self.tkvw.BindTkImageViewer() self.tkrw.BindTkRenderWidget() # Lets add an extra binding of the middle button in the image viewer # to set the cursor location. self.tkvw.bind('<Button-2>', SetCursorFromViewer) self.tkvw.bind('<Shift-Button-1>', SetCursorFromViewer) # Associate the functions with the buttons and label. # downButton.config(command=partial(ViewerDown, self.tkvw)) upButton.config(command=partial(ViewerUp, self.tkvw))
def SetUp(self): """ Set up cursor3D """ def OnClosing(): self.root.quit() def ViewerDown(tkvw): viewer = tkvw.GetImageViewer() ViewerSetZSlice(tkvw, viewer.GetZSlice() - 1) def ViewerUp(tkvw): viewer = tkvw.GetImageViewer() ViewerSetZSlice(tkvw, viewer.GetZSlice() + 1) def ViewerSetZSlice(tkvw, z): viewer = tkvw.GetImageViewer() viewer.SetZSlice(z) txt = "slice: " + str(z) sliceLabel.configure(text=txt) tkvw.Render() def SetCursorFromViewer(event): x = int(event.x) y = int(event.y) # We have to flip y axis because tk uses upper right origin. self.root.update_idletasks() height = int(self.tkvw.configure()["height"][4]) y = height - y z = self.tkvw.GetImageViewer().GetZSlice() SetCursor(x / IMAGE_MAG_X, y / IMAGE_MAG_Y, z / IMAGE_MAG_Z) def SetCursor(x, y, z): CURSOR_X = x CURSOR_Y = y CURSOR_Z = z axes.SetOrigin(CURSOR_X, CURSOR_Y, CURSOR_Z) imageCursor.SetCursorPosition(CURSOR_X * IMAGE_MAG_X, CURSOR_Y * IMAGE_MAG_Y, CURSOR_Z * IMAGE_MAG_Z) self.viewer.Render() self.tkrw.Render() # Pipeline stuff. reader = vtk.vtkSLCReader() reader.SetFileName(VTK_DATA_ROOT + "/Data/neghip.slc") # Cursor stuff magnify = vtk.vtkImageMagnify() magnify.SetInputConnection(reader.GetOutputPort()) magnify.SetMagnificationFactors(IMAGE_MAG_X, IMAGE_MAG_Y, IMAGE_MAG_Z) imageCursor = vtk.vtkImageCursor3D() imageCursor.SetInputConnection(magnify.GetOutputPort()) imageCursor.SetCursorPosition(CURSOR_X * IMAGE_MAG_X, CURSOR_Y * IMAGE_MAG_Y, CURSOR_Z * IMAGE_MAG_Z) imageCursor.SetCursorValue(255) imageCursor.SetCursorRadius(50 * IMAGE_MAG_X) axes = vtk.vtkAxes() axes.SymmetricOn() axes.SetOrigin(CURSOR_X, CURSOR_Y, CURSOR_Z) axes.SetScaleFactor(50.0) axes_mapper = vtk.vtkPolyDataMapper() axes_mapper.SetInputConnection(axes.GetOutputPort()) axesActor = vtk.vtkActor() axesActor.SetMapper(axes_mapper) axesActor.GetProperty().SetAmbient(0.5) # Image viewer stuff. viewer = vtk.vtkImageViewer() viewer.SetInputConnection(imageCursor.GetOutputPort()) viewer.SetZSlice(CURSOR_Z * IMAGE_MAG_Z) viewer.SetColorWindow(256) viewer.SetColorLevel(128) # Create transfer functions for opacity and color. opacity_transfer_function = vtk.vtkPiecewiseFunction() opacity_transfer_function.AddPoint(20, 0.0) opacity_transfer_function.AddPoint(255, 0.2) color_transfer_function = vtk.vtkColorTransferFunction() color_transfer_function.AddRGBPoint(0, 0, 0, 0) color_transfer_function.AddRGBPoint(64, 1, 0, 0) color_transfer_function.AddRGBPoint(128, 0, 0, 1) color_transfer_function.AddRGBPoint(192, 0, 1, 0) color_transfer_function.AddRGBPoint(255, 0, 0.2, 0) # Create properties, mappers, volume actors, and ray cast function. volume_property = vtk.vtkVolumeProperty() volume_property.SetColor(color_transfer_function) # volume_property.SetColor(color_transfer_function[0], # color_transfer_function[1], # color_transfer_function[2]) volume_property.SetScalarOpacity(opacity_transfer_function) volume_mapper = vtk.vtkFixedPointVolumeRayCastMapper() volume_mapper.SetInputConnection(reader.GetOutputPort()) volume = vtk.vtkVolume() volume.SetMapper(volume_mapper) volume.SetProperty(volume_property) # Create outline. outline = vtk.vtkOutlineFilter() outline.SetInputConnection(reader.GetOutputPort()) outline_mapper = vtk.vtkPolyDataMapper() outline_mapper.SetInputConnection(outline.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(outline_mapper) outlineActor.GetProperty().SetColor(1, 1, 1) # Create the renderer. ren = vtk.vtkRenderer() ren.AddActor(axesActor) ren.AddVolume(volume) ren.SetBackground(0.1, 0.2, 0.4) renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) renWin.SetSize(256, 256) # Create the GUI: two renderer widgets and a quit button. self.root = tkinter.Tk() self.root.title("cursor3D") # Define what to do when the user explicitly closes a window. self.root.protocol("WM_DELETE_WINDOW", OnClosing) # Help label, frame and quit button helpLabel = tkinter.Label(self.root, text="MiddleMouse (or shift-LeftMouse) in image viewer to place cursor") displayFrame = tkinter.Frame(self.root) quitButton = tkinter.Button(self.root, text="Quit", command=OnClosing) # Pack the GUI. helpLabel.pack() displayFrame.pack(fill=BOTH, expand=TRUE) quitButton.pack(fill=X) # Create the viewer widget. viewerFrame = tkinter.Frame(displayFrame) viewerFrame.pack(padx=3, pady=3, side=LEFT, anchor=N, fill=BOTH, expand=FALSE) self.tkvw = vtkTkImageViewerWidget(viewerFrame, iv=viewer, width=264, height=264) viewerControls = tkinter.Frame(viewerFrame) viewerControls.pack(side=BOTTOM, anchor=S, fill=BOTH, expand=TRUE) self.tkvw.pack(side=TOP, anchor=N, fill=BOTH, expand=FALSE) downButton = tkinter.Button(viewerControls, text="Down", command=[ViewerDown, self.tkvw]) upButton = tkinter.Button(viewerControls, text="Up", command=[ViewerUp, self.tkvw]) sliceLabel = tkinter.Label(viewerControls, text="slice: " + str(CURSOR_Z * IMAGE_MAG_Z)) downButton.pack(side=LEFT, expand=TRUE, fill=BOTH) upButton.pack(side=LEFT, expand=TRUE, fill=BOTH) sliceLabel.pack(side=LEFT, expand=TRUE, fill=BOTH) # Create the render widget renderFrame = tkinter.Frame(displayFrame) renderFrame.pack(padx=3, pady=3, side=LEFT, anchor=N, fill=BOTH, expand=TRUE) self.tkrw = vtkTkRenderWidget(renderFrame, rw=renWin, width=264, height=264) self.tkrw.pack(side=TOP, anchor=N, fill=BOTH, expand=TRUE) # Bindings self.tkvw.BindTkImageViewer() self.tkrw.BindTkRenderWidget() # Lets add an extra binding of the middle button in the image viewer # to set the cursor location. self.tkvw.bind("<Button-2>", SetCursorFromViewer) self.tkvw.bind("<Shift-Button-1>", SetCursorFromViewer) # Associate the functions with the buttons and label. # downButton.config(command=partial(ViewerDown, self.tkvw)) upButton.config(command=partial(ViewerUp, self.tkvw))
def updateData(self, data, ctf = None): """ Method that initializes the VTK rendering based on a dataset """ if self.data: del self.data self.data = data self.outline.SetInput(self.data) self.outlinemapper.SetInput (self.outline.GetOutput ()) self.outlineactor.SetMapper (self.outlinemapper) self.outlineactor.GetProperty().SetColor((255, 255, 255)) self.renderer.AddActor(self.outlineactor) # Create transfer mapping scalar value to opacity opacityTransferFunction = vtk.vtkPiecewiseFunction() opacityTransferFunction.AddPoint(10, 0.0) opacityTransferFunction.AddPoint(255, 0.2) colorTransferFunction = ctf if not colorTransferFunction: print "DIDN'T GET CTF!!" # Create transfer mapping scalar value to color colorTransferFunction = vtk.vtkColorTransferFunction() colorTransferFunction.AddRGBPoint(0.0, 0.0, 0.0, 0.0) colorTransferFunction.AddRGBPoint(255.0, 0.0, 1.0, 0.0) volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(colorTransferFunction) volumeProperty.SetScalarOpacity(opacityTransferFunction) volumeProperty.ShadeOff() data.Update() ncomps = data.GetNumberOfScalarComponents() if ncomps > 1: volumeProperty.IndependentComponentsOff() else: volumeProperty.IndependentComponentsOn() self.volumeMapper = vtk.vtkFixedPointVolumeRayCastMapper() self.volumeMapper.SetIntermixIntersectingGeometry(1) self.volumeMapper.SetSampleDistance(2) self.volumeMapper.SetBlendModeToComposite() self.volumeMapper.SetInput(self.data) volumeMapper = self.volumeMapper volume = vtk.vtkVolume() # temporary self.renderer.AddVolume(volume) volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) txt = ("X", "Y", "Z") for t in txt: eval ("self.axes.%sAxisVisibilityOn ()" % t) eval ("self.axes.Get%sAxisActor2D().SetLabelFactor(0.5)" % t) self.axes.GetProperty ().SetColor ((255, 255, 255)) self.axes.SetNumberOfLabels (2) self.axes.SetFontFactor (1.0) self.axes.SetFlyModeToOuterEdges () self.axes.SetCornerOffset (0.0) self.axes.ScalingOff () self.axes.SetCamera (self.renderer.GetActiveCamera ()) self.renderer.AddActor (self.axes) self.axes.SetInput (self.outline.GetOutput ()) self.volume = volume self.volumeMapper = volumeMapper self.volumeProperty = volumeProperty self.wxrenwin.Render()
def createActor(self, vtkImageData): logging.debug("In VtkImageVolume::createActor()") self.vtkImageData = vtkImageData self.mapper = vtk.vtkFixedPointVolumeRayCastMapper() self.mapper.SetInput(self.vtkImageData)#clip.GetOutput()) self.updateClipPlanes() self.independentComponents = True self.scalar = self.vtkImageData.GetScalarRange() self.opacityWindow = self.scalar[1] - self.scalar[0] # print "self.scalar[1] - self.scalar[0]:", self.scalar[1] , self.scalar[0] self.opacityLevel = (self.scalar[1] + self.scalar[0]) / 2.0 self.lastmousex = 0 self.lastmousey = 0 (xpos, ypos) = self.interactor.GetEventPosition() self.opacityWindow += xpos - self.lastmousex self.opacityLevel += ypos - self.lastmousey self.lastmousex = xpos self.lastmousey = ypos self.createCubeOrientation() self.colorFun = vtk.vtkColorTransferFunction() self.colorFun.RemoveAllPoints() self.opacityFun = vtk.vtkPiecewiseFunction() self.opacityFun.RemoveAllPoints() self.volumeProperty = vtk.vtkVolumeProperty() self.volumeProperty.SetIndependentComponents(self.independentComponents) self.volumeProperty.SetColor(self.colorFun) self.volumeProperty.SetScalarOpacity(self.opacityFun) self.volumeProperty.SetInterpolationTypeToLinear() self.volume = vtk.vtkVolume() self.volume.SetProperty(self.volumeProperty) self.volume.SetMapper(self.mapper) self.interactor.Modified() self.interactor.Render() self.mode = None self.changeHounsfieldMode("MIP") self.interactorStyle = vtk.vtkInteractorStyleTrackballCamera() self.renderer.SetBackground(0.0, 0.0, 0.0) self.camera.SetFocalPoint(0, 0, 0) self.camera.SetPosition(0, -1, 0) self.camera.SetViewUp(0, 0, 1) self.renderer.ResetCamera() self.defaultWindow = self.opacityWindow self.defaultLevel = self.opacityLevel self.setWindowLevel(self.opacityWindow, self.opacityLevel)
def updateMethod(self): """ Set the Rendering method used """ self.parameters["QualityValue"] = 0 if not self.initDone: return method = self.parameters["Method"] self.volumeProperty.SetScalarOpacity(self.otfs[method]) self.updateOpacityTransferFunction() tbl = ["Ray cast", "Texture Map", "3D texture map", "MIP", "Isosurface"] Logging.info("Volume rendering method: ", tbl[method], kw = "rendering") #Ray Casting, RGBA Ray Casting, Texture Mapping, MIP composites = [vtk.vtkVolumeRayCastCompositeFunction, None, None, vtk.vtkVolumeRayCastMIPFunction, vtk.vtkVolumeRayCastIsosurfaceFunction ] blendModes = ["Composite", "Composite", "Composite", "MaximumIntensity", "Composite"] if method in [RAYCAST, MIP, ISOSURFACE]: # Iso surfacing with fixedpoint mapper is not supported if method != ISOSURFACE: self.mapper = vtk.vtkFixedPointVolumeRayCastMapper() #self.mapper.SetAutoAdjustSampleDistances(1) self.sampleDistance = self.mapper.GetSampleDistance() #self.volumeProperty.IndependentComponentsOff() mode = blendModes[method] Logging.info("Setting fixed point rendering mode to ", mode, kw = "rendering") eval("self.mapper.SetBlendModeTo%s()" % mode) else: self.mapper = vtk.vtkVolumeRayCastMapper() self.function = composites[method]() Logging.info("Using ray cast function ", self.function, kw = "rendering") self.mapper.SetVolumeRayCastFunction(self.function) elif method == TEXTURE_MAPPING_3D: # 3d texture mapping self.mapper = vtk.vtkVolumeTextureMapper3D() self.sampleDistance = self.mapper.GetSampleDistance() elif method == TEXTURE_MAPPING: # texture mapping self.mapper = vtk.vtkVolumeTextureMapper2D() self.maxPlanes = self.mapper.GetMaximumNumberOfPlanes() # changed following because seems like a mistake, 19.7.2007 SS # if self.haveVolpro and self.method in [RAYCAST, ISOSURFACE, MIP] and self.parameters["UseVolumepro"]: if self.haveVolpro and method in [RAYCAST, ISOSURFACE, MIP] and self.parameters["UseVolumepro"]: # use volumepro accelerated rendering self.mapper = vtk.vtkVolumeProMapper() modes = ["Composite", None, None, "MaximumIntensity", "MinimumIntensity"] acc = modes[method] cmd = "self.mapper.SetBlendModeTo%s()" % acc Logging.info("Setting blending mode to ", acc, kw = "rendering") eval(cmd) Logging.info("Setting parallel projetion", kw = "rendering") self.renderer.GetActiveCamera().ParallelProjectionOn() #self.settingEdit.Enable(0) #self.qualitySlider.Enable(0) else: self.renderer.GetActiveCamera().ParallelProjectionOff() self.mapperUpdated = True
def updateMethod(self): """ Set the Rendering method used """ self.parameters["QualityValue"] = 0 if not self.initDone: return method = self.parameters["Method"] self.volumeProperty.SetScalarOpacity(self.otfs[method]) self.updateOpacityTransferFunction() tbl = [ "Ray cast", "Texture Map", "3D texture map", "MIP", "Isosurface" ] Logging.info("Volume rendering method: ", tbl[method], kw="rendering") #Ray Casting, RGBA Ray Casting, Texture Mapping, MIP composites = [ vtk.vtkVolumeRayCastCompositeFunction, None, None, vtk.vtkVolumeRayCastMIPFunction, vtk.vtkVolumeRayCastIsosurfaceFunction ] blendModes = [ "Composite", "Composite", "Composite", "MaximumIntensity", "Composite" ] if method in [RAYCAST, MIP, ISOSURFACE]: # Iso surfacing with fixedpoint mapper is not supported if method != ISOSURFACE: self.mapper = vtk.vtkFixedPointVolumeRayCastMapper() #self.mapper.SetAutoAdjustSampleDistances(1) self.sampleDistance = self.mapper.GetSampleDistance() #self.volumeProperty.IndependentComponentsOff() mode = blendModes[method] Logging.info("Setting fixed point rendering mode to ", mode, kw="rendering") eval("self.mapper.SetBlendModeTo%s()" % mode) else: self.mapper = vtk.vtkVolumeRayCastMapper() self.function = composites[method]() Logging.info("Using ray cast function ", self.function, kw="rendering") self.mapper.SetVolumeRayCastFunction(self.function) elif method == TEXTURE_MAPPING_3D: # 3d texture mapping self.mapper = vtk.vtkVolumeTextureMapper3D() self.sampleDistance = self.mapper.GetSampleDistance() elif method == TEXTURE_MAPPING: # texture mapping self.mapper = vtk.vtkVolumeTextureMapper2D() self.maxPlanes = self.mapper.GetMaximumNumberOfPlanes() # changed following because seems like a mistake, 19.7.2007 SS # if self.haveVolpro and self.method in [RAYCAST, ISOSURFACE, MIP] and self.parameters["UseVolumepro"]: if self.haveVolpro and method in [ RAYCAST, ISOSURFACE, MIP ] and self.parameters["UseVolumepro"]: # use volumepro accelerated rendering self.mapper = vtk.vtkVolumeProMapper() modes = [ "Composite", None, None, "MaximumIntensity", "MinimumIntensity" ] acc = modes[method] cmd = "self.mapper.SetBlendModeTo%s()" % acc Logging.info("Setting blending mode to ", acc, kw="rendering") eval(cmd) Logging.info("Setting parallel projetion", kw="rendering") self.renderer.GetActiveCamera().ParallelProjectionOn() #self.settingEdit.Enable(0) #self.qualitySlider.Enable(0) else: self.renderer.GetActiveCamera().ParallelProjectionOff() self.mapperUpdated = True
def main(): colors = vtk.vtkNamedColors() fileName = 'C:/Users/chenjiaxing/Desktop/Python/vmtk/Spine_Neck.vti' reader = vtk.vtkXMLImageDataReader() reader.SetFileName(fileName) reader.Update() cast = vtk.vtkImageCast() cast.SetInputData(reader.GetOutput()) cast.SetOutputScalarTypeToFloat() cast.SetOutputScalarTypeToUnsignedChar() cast.Update() #********************************************************************** rayCastFun = vtk.vtkPiecewiseFunction() #定义光线经过体数据后的颜色计算方式 volumeMapper = vtk.vtkFixedPointVolumeRayCastMapper() #光线投射法-最常用的体绘制方法 volumeMapper.SetInputData(cast.GetOutput()) #volumeMapper.SetVolumeRayCastFunction(rayCastFun) ##method 2 #vtk.vtkGPUVolumeRayCastMapper> volumeMapperGpu = vtk.vtkGPUVolumeRayCastMapper() ##基于GPU加速的光线投射体绘制算法 #volumeMapperGpu.SetInputData(cast.GetOutput()) #volumeMapperGpu.SetImageSampleDistance(0.5) #volumeMapperGpu.SetSampleDistance(1.0) #volumeMapperGpu.SetAutoAdjustSampleDistances(1) #*********************************************************************** volumeProperty = vtk.vtkVolumeProperty()#定义对象属性 volumeProperty.SetInterpolationTypeToLinear() volumeProperty.ShadeOn() volumeProperty.SetAmbient(0.4) volumeProperty.SetDiffuse(0.6) volumeProperty.SetSpecular(0.2) compositeOpacity = vtk.vtkPiecewiseFunction() #Defines a piecewise function mapping. compositeOpacity.AddPoint(0, 0.00) compositeOpacity.AddPoint(216.19, 0.00) compositeOpacity.AddPoint(216.19, 0.851) compositeOpacity.AddPoint(256, 1) volumeProperty.SetScalarOpacity(compositeOpacity) color = vtk.vtkColorTransferFunction() color.AddRGBPoint(0, 0.231373, 0.298039, 0.7529) color.AddRGBPoint(210.8, 0.517, 0.654, 0.988) color.AddRGBPoint(256, 0.705, 0.0156, 0.149) volumeProperty.SetColor(color) volume = vtk.vtkVolume() #represents a volume(data & properties) in a rendered scene #volume.SetMapper(volumeMapperGpu) volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) rendererVolume = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindowInteractor = vtk.vtkRenderWindowInteractor() rendererVolume.AddVolume(volume) renderWindow.AddRenderer(rendererVolume) renderWindowInteractor.SetRenderWindow(renderWindow) renderWindow.Render() renderWindowInteractor.Start()
opacityTransferFunction.ClampingOn() # Create transfer mapping scalar value to color colorTransferFunction = vtk.vtkColorTransferFunction() colorTransferFunction.AddHSVPoint(0.0, 0.66, 1.0, 1.0) colorTransferFunction.AddHSVPoint(50.0, 0.33, 1.0, 1.0) colorTransferFunction.AddHSVPoint(100.0, 0.00, 1.0, 1.0) # The property describes how the data will look volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(colorTransferFunction) volumeProperty.SetScalarOpacity(opacityTransferFunction) volumeProperty.SetInterpolationTypeToLinear() # The mapper knows how to render the data volumeMapper = vtk.vtkFixedPointVolumeRayCastMapper() volumeMapper.SetInputConnection(readerSS.GetOutputPort()) # The volume holds the mapper and the property and # can be used to position/orient the volume volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) ren1.AddVolume(volume) # ren1 AddActor contourActor ren1.AddActor(boundsActor) ###################################################################### Sphere = vtk.vtkSphereSource()
def LoadVolume(self): proj = prj.Project() #image = imagedata_utils.to_vtk(n_array, spacing, slice_number, orientation) if not self.loaded_image: self.LoadImage() self.loaded_image = 1 image = self.image number_filters = len(self.config['convolutionFilters']) if (prj.Project().original_orientation == const.AXIAL): flip_image = True else: flip_image = False #if (flip_image): update_progress= vtk_utils.ShowProgress(2 + number_filters) # Flip original vtkImageData flip = vtk.vtkImageFlip() flip.SetInputData(image) flip.SetFilteredAxis(1) flip.FlipAboutOriginOn() # flip.ReleaseDataFlagOn() flip_ref = weakref.ref(flip) flip_ref().AddObserver("ProgressEvent", lambda obj,evt: update_progress(flip_ref(), "Rendering...")) flip.Update() image = flip.GetOutput() scale = image.GetScalarRange() self.scale = scale cast = vtk.vtkImageShiftScale() cast.SetInputData(image) cast.SetShift(abs(scale[0])) cast.SetOutputScalarTypeToUnsignedShort() # cast.ReleaseDataFlagOn() cast_ref = weakref.ref(cast) cast_ref().AddObserver("ProgressEvent", lambda obj,evt: update_progress(cast_ref(), "Rendering...")) cast.Update() image2 = cast self.imagedata = image2 if self.config['advancedCLUT']: self.Create16bColorTable(scale) self.CreateOpacityTable(scale) else: self.Create8bColorTable(scale) self.Create8bOpacityTable(scale) image2 = self.ApplyConvolution(image2.GetOutput(), update_progress) self.final_imagedata = image2 # Changed the vtkVolumeRayCast to vtkFixedPointVolumeRayCastMapper # because it's faster and the image is better # TODO: To test if it's true. if const.TYPE_RAYCASTING_MAPPER: volume_mapper = vtk.vtkVolumeRayCastMapper() #volume_mapper.AutoAdjustSampleDistancesOff() #volume_mapper.SetInput(image2) #volume_mapper.SetVolumeRayCastFunction(composite_function) #volume_mapper.SetGradientEstimator(gradientEstimator) volume_mapper.IntermixIntersectingGeometryOn() self.volume_mapper = volume_mapper else: if int(ses.Session().rendering) == 0: volume_mapper = vtk.vtkFixedPointVolumeRayCastMapper() #volume_mapper.AutoAdjustSampleDistancesOff() self.volume_mapper = volume_mapper volume_mapper.IntermixIntersectingGeometryOn() else: volume_mapper = vtk.vtkGPUVolumeRayCastMapper() self.volume_mapper = volume_mapper self.SetTypeRaycasting() volume_mapper.SetInputData(image2) # TODO: Look to this #volume_mapper_hw = vtk.vtkVolumeTextureMapper3D() #volume_mapper_hw.SetInput(image2) #Cut Plane #CutPlane(image2, volume_mapper) #self.color_transfer = color_transfer volume_properties = vtk.vtkVolumeProperty() #volume_properties.IndependentComponentsOn() volume_properties.SetInterpolationTypeToLinear() volume_properties.SetColor(self.color_transfer) try: volume_properties.SetScalarOpacity(self.opacity_transfer_func) except NameError: pass # Using these lines to improve the raycasting quality. These values # seems related to the distance from ray from raycasting. # TODO: Need to see values that improve the quality and don't decrease # the performance. 2.0 seems to be a good value to pix_diag pix_diag = 2.0 volume_mapper.SetImageSampleDistance(0.25) volume_mapper.SetSampleDistance(pix_diag / 5.0) volume_properties.SetScalarOpacityUnitDistance(pix_diag) self.volume_properties = volume_properties self.SetShading() volume = vtk.vtkVolume() volume.SetMapper(volume_mapper) volume.SetProperty(volume_properties) self.volume = volume colour = self.GetBackgroundColour() self.exist = 1 Publisher.sendMessage('Load volume into viewer', (volume, colour, (self.ww, self.wl))) del flip del cast
def dual_volumeRendering(image, image2, lowerThreshold, upperThreshold, sigmoid_image): color = vtk.vtkColorTransferFunction() color.AddRGBPoint(0, 0.0, 0.0, 0.0) # background color.AddRGBPoint(lowerThreshold, 0.0, 0.0, 0.0) color.AddRGBPoint(upperThreshold, 1.0, 1.0, 1.0) opacity = vtk.vtkPiecewiseFunction() opacity.AddPoint(0, 0.0) opacity.AddPoint(lowerThreshold, 0.0) opacity.AddPoint(upperThreshold, 1) gradient = vtk.vtkPiecewiseFunction() gradient.AddPoint(0, 0.0) # gradient.AddPoint(90, 0.5) gradient.AddPoint(255, 1.0) volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(color) volumeProperty.SetScalarOpacity(opacity) volumeProperty.SetGradientOpacity(gradient) volumeProperty.SetInterpolationTypeToLinear() volumeProperty.ShadeOn() volumeProperty.SetAmbient(0.1) volumeProperty.SetDiffuse(0.7) volumeProperty.SetSpecular(0.1) color2 = vtk.vtkColorTransferFunction() color2.AddRGBPoint(0, 0.0, 0.0, 0.0) # background color2.AddRGBPoint(lowerThreshold, 0.0, 0.0, 0.0) color2.AddRGBPoint(upperThreshold, 1.0, 0.0, 0.0) opacity2 = vtk.vtkPiecewiseFunction() opacity2.AddPoint(0, 0.0) opacity2.AddPoint(lowerThreshold, 0.0) opacity2.AddPoint(upperThreshold, 1.0) gradient2 = vtk.vtkPiecewiseFunction() gradient2.AddPoint(0, 0.0) # gradient2.AddPoint(90, 0.5) # gradient2.AddPoint(100,1.0) gradient2.AddPoint(255, 1.0) volumeProperty2 = vtk.vtkVolumeProperty() volumeProperty2.SetColor(color2) volumeProperty2.SetScalarOpacity(opacity2) volumeProperty2.SetGradientOpacity(gradient2) volumeProperty2.SetInterpolationTypeToLinear() volumeProperty2.ShadeOn() volumeProperty2.SetAmbient(0.1) volumeProperty2.SetDiffuse(1.0) volumeProperty2.SetSpecular(0.1) ####################################### color3 = vtk.vtkColorTransferFunction() color3.AddRGBPoint(0, 0.0, 0.0, 0.0) # background color3.AddRGBPoint(lowerThreshold, 0.0, 0.0, 0.0) color3.AddRGBPoint(upperThreshold, 0.0, 1.0, 0.0) opacity3 = vtk.vtkPiecewiseFunction() opacity3.AddPoint(0, 0.0) opacity3.AddPoint(lowerThreshold, 0.0) opacity3.AddPoint(upperThreshold, 1) gradient3 = vtk.vtkPiecewiseFunction() gradient3.AddPoint(0, 0.0) # gradient.AddPoint(90, 0.5) gradient3.AddPoint(255, 1.0) volumeProperty3 = vtk.vtkVolumeProperty() volumeProperty3.SetColor(color3) volumeProperty3.SetScalarOpacity(opacity) volumeProperty3.SetGradientOpacity(gradient) volumeProperty3.SetInterpolationTypeToLinear() volumeProperty3.ShadeOn() volumeProperty3.SetAmbient(0.1) volumeProperty3.SetDiffuse(0.7) volumeProperty3.SetSpecular(0.1) ########################################### volumeMapper = vtk.vtkFixedPointVolumeRayCastMapper() volumeMapper.SetInputData(image) volumeMapper2 = vtk.vtkFixedPointVolumeRayCastMapper() volumeMapper2.SetInputData(image2) volumeMapper3 = vtk.vtkFixedPointVolumeRayCastMapper() volumeMapper3.SetInputData(sigmoid_image) volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) volume.Update() volume2 = vtk.vtkVolume() volume2.SetMapper(volumeMapper2) volume2.SetProperty(volumeProperty2) volume2.Update() volume3 = vtk.vtkVolume() volume3.SetMapper(volumeMapper3) volume3.SetProperty(volumeProperty3) volume3.Update() sphere_view = vtk.vtkSphereSource() sphere_view.SetCenter(30, 0, 550) sphere_view.SetRadius(5.0) # sphere_view.SetColor(0.0,1.0,1.0) # mapper mapper = vtk.vtkPolyDataMapper() if vtk.VTK_MAJOR_VERSION <= 5: mapper.SetInput(sphere_view.GetOutput()) else: mapper.SetInputConnection(sphere_view.GetOutputPort()) # actor sphere_actor = vtk.vtkActor() sphere_actor.SetMapper(mapper) sphere_actor.GetProperty().SetColor(1.0, 0.0, 1.0) ren = vtk.vtkRenderer() ren.AddActor(sphere_actor) # ren.AddActor(vol2_actor) ren.AddViewProp(volume) ren.AddViewProp(volume2) ren.AddViewProp(volume3) ren.SetBackground(0, 0, 0) renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) renWin.SetSize(400, 400) # create a renderwindowinteractor iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) iren.Initialize() renWin.Render() iren.Start()
def main(): colors = vtk.vtkNamedColors() colors.SetColor("BkgColor", [51, 77, 102, 255]) # Create the renderer, the render window, and the interactor. The renderer # draws into the render window, the interactor enables mouse- and # keyboard-based interaction with the scene. ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # The following reader is used to read a series of 2D slices (images) # that compose the volume. The slice dimensions are set, and the # pixel spacing. The data Endianness must also be specified. The reader # uses the FilePrefix in combination with the slice number to construct # filenames using the format FilePrefix.%d. (In this case the FilePrefix # is the root name of the file: quarter.) reader = vtk.vtkPNGReader() reader.SetFileDimensionality(2) #存储在文件中的维数 reader.SetFilePrefix( "E:\PYproject\BrainConnect/allen_data/img512/s") #指定图像文件的前缀 #reader.SetFileNameSliceSpacing()#当读取具有常规但非连续切片的文件(例如filename.1,filename.3,filename.5)时,可以指定间距以跳过丢失的文件(默认值= 1) reader.SetFilePattern( "%s%d.png") #配合SetFilePrefix使用,用于从FilePrefix和切片编号构建文件名的snprintf样式格式字符串 reader.SetDataExtent(0, 511, 0, 511, 0, 131) #设置disk数据范围,前两个为img大小,最后一个为slice数量 reader.SetDataSpacing(1, 1, 4) #设置文件中数据的间距 # The volume will be displayed by ray-cast alpha compositing. # A ray-cast mapper is needed to do the ray-casting. volumeMapper = vtk.vtkFixedPointVolumeRayCastMapper() volumeMapper.SetInputConnection(reader.GetOutputPort()) # The color transfer function maps voxel intensities to colors. # It is modality-specific, and often anatomy-specific as well. # The goal is to one color for flesh (between 500 and 1000) # and another color for bone (1150 and over). volumeColor = vtk.vtkColorTransferFunction() volumeColor.AddRGBPoint(0, 0.0, 0.0, 0.0) volumeColor.AddRGBPoint(500, 0.0, 139.0, 139.0) volumeColor.AddRGBPoint(1000, 255.0, 215.5, 0.3) volumeColor.AddRGBPoint(1150, 139.0, 105.0, 105.9) # The opacity transfer function is used to control the opacity # of different tissue types. volumeScalarOpacity = vtk.vtkPiecewiseFunction() volumeScalarOpacity.AddPoint(0, 0.00) volumeScalarOpacity.AddPoint(500, 0.15) volumeScalarOpacity.AddPoint(1000, 0.15) volumeScalarOpacity.AddPoint(1150, 0.85) # The gradient opacity function is used to decrease the opacity # in the "flat" regions of the volume while maintaining the opacity # at the boundaries between tissue types. The gradient is measured # as the amount by which the intensity changes over unit distance. # For most medical data, the unit distance is 1mm. volumeGradientOpacity = vtk.vtkPiecewiseFunction() volumeGradientOpacity.AddPoint(0, 0.0) volumeGradientOpacity.AddPoint(90, 0.5) volumeGradientOpacity.AddPoint(100, 1.0) # The VolumeProperty attaches the color and opacity functions to the # volume, and sets other volume properties. The interpolation should # be set to linear to do a high-quality rendering. The ShadeOn option # turns on directional lighting, which will usually enhance the # appearance of the volume and make it look more "3D". However, # the quality of the shading depends on how accurately the gradient # of the volume can be calculated, and for noisy data the gradient # estimation will be very poor. The impact of the shading can be # decreased by increasing the Ambient coefficient while decreasing # the Diffuse and Specular coefficient. To increase the impact # of shading, decrease the Ambient and increase the Diffuse and Specular. volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(volumeColor) volumeProperty.SetScalarOpacity(volumeScalarOpacity) volumeProperty.SetGradientOpacity(volumeGradientOpacity) volumeProperty.SetInterpolationTypeToLinear() volumeProperty.ShadeOn() volumeProperty.SetAmbient(0.4) volumeProperty.SetDiffuse(0.6) volumeProperty.SetSpecular(0.2) # The vtkVolume is a vtkProp3D (like a vtkActor) and controls the position # and orientation of the volume in world coordinates. volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) # Finally, add the volume to the renderer ren.AddViewProp(volume) # Set up an initial view of the volume. The focal point will be the # center of the volume, and the camera position will be 400mm to the # patient's left (which is our right). camera = ren.GetActiveCamera() c = volume.GetCenter() camera.SetViewUp(0, 0, -1) camera.SetPosition(c[0], c[1] - 400, c[2]) camera.SetFocalPoint(c[0], c[1], c[2]) camera.Azimuth(30.0) camera.Elevation(30.0) # Set a background color for the renderer ren.SetBackground(colors.GetColor3d("BkgColor")) # Increase the size of the render window renWin.SetSize(640, 480) # Interact with the data. iren.Start()
def update(self): # only unsigned char or unsigned short can be accepted by vtkVolumeRayCastMapper, so convert signed short to unsigned short val_range = self._image.GetOutput().GetScalarRange() min_val = val_range[0] max_val = val_range[1] diff = max_val - min_val slope = 65536/diff # 16 bits/pixel inter = -slope*min_val shift = inter/slope shifter = vtk.vtkImageShiftScale() shifter.SetShift(shift) shifter.SetScale(slope) shifter.SetOutputScalarTypeToUnsignedShort() shifter.SetInputConnection(self._image.GetOutputPort()) shifter.ReleaseDataFlagOff() shifter.Update() volume_mapper = vtk.vtkFixedPointVolumeRayCastMapper() volume_mapper.SetInputConnection(shifter.GetOutputPort()) volume_color = vtk.vtkColorTransferFunction() volume_scalar_opacity = vtk.vtkPiecewiseFunction() volume_property = vtk.vtkVolumeProperty() volume_property.SetIndependentComponents(True) volume_property.SetColor(volume_color) volume_property.SetScalarOpacity(volume_scalar_opacity) volume_property.SetInterpolationTypeToLinear() volume = vtk.vtkVolume() volume.SetMapper(volume_mapper) volume.SetProperty(volume_property) volume_color.AddRGBSegment(0.0,0.0,0.0,0.0,1000,1.0,1.0,1.0) volume_scalar_opacity.AddSegment(0, 0, 65536, 1) # 16 bits/pixel volume_mapper.SetBlendModeToMaximumIntensity() camera = vtk.vtkCamera() camera.SetViewUp(0.0, 0.0, -1.0) camera.SetPosition(0.0, 1.0, 0.0) camera.SetFocalPoint(0.0, 0.0, 0.0) camera.ComputeViewPlaneNormal() camera.Dolly(1.5) renderer = vtk.vtkRenderer() renderer.AddViewProp(volume) renderer.SetActiveCamera(camera) renderer.ResetCamera() renderer.SetBackground(0.0,0.0,0.0) renderer.ResetCameraClippingRange() render_window = vtk.vtkRenderWindow() render_window.AddRenderer(renderer) render_window_interactor = vtk.vtkRenderWindowInteractor() render_window_interactor.SetRenderWindow(render_window) render_window_interactor.Initialize() render_window.Render() render_window_interactor.Start()
def __init__(self, ren, renWin, iren): self.ren = ren self.renWin = renWin self.iren = iren # Create a gaussian gs = vtk.vtkImageGaussianSource() gs.SetWholeExtent(0, 30, 0, 30, 0, 30) gs.SetMaximum(255.0) gs.SetStandardDeviation(5) gs.SetCenter(15, 15, 15) # threshold to leave a gap that should show up for # gradient opacity t = vtk.vtkImageThreshold() t.SetInputConnection(gs.GetOutputPort()) t.ReplaceInOn() t.SetInValue(0) t.ThresholdBetween(150, 200) # Use a shift scale to convert to unsigned char ss = vtk.vtkImageShiftScale() ss.SetInputConnection(t.GetOutputPort()) ss.SetOutputScalarTypeToUnsignedChar() # grid will be used for two component dependent grid0 = vtk.vtkImageGridSource() grid0.SetDataScalarTypeToUnsignedChar() grid0.SetGridSpacing(10, 10, 10) grid0.SetLineValue(200) grid0.SetFillValue(10) grid0.SetDataExtent(0, 30, 0, 30, 0, 30) # use dilation to thicken the grid d = vtk.vtkImageContinuousDilate3D() d.SetInputConnection(grid0.GetOutputPort()) d.SetKernelSize(3, 3, 3) # Now make a two component dependent iac = vtk.vtkImageAppendComponents() iac.AddInputConnection(d.GetOutputPort()) iac.AddInputConnection(ss.GetOutputPort()) # Some more gaussians for the four component indepent case gs1 = vtk.vtkImageGaussianSource() gs1.SetWholeExtent(0, 30, 0, 30, 0, 30) gs1.SetMaximum(255.0) gs1.SetStandardDeviation(4) gs1.SetCenter(5, 5, 5) t1 = vtk.vtkImageThreshold() t1.SetInputConnection(gs1.GetOutputPort()) t1.ReplaceInOn() t1.SetInValue(0) t1.ThresholdBetween(150, 256) gs2 = vtk.vtkImageGaussianSource() gs2.SetWholeExtent(0, 30, 0, 30, 0, 30) gs2.SetMaximum(255.0) gs2.SetStandardDeviation(4) gs2.SetCenter(12, 12, 12) gs3 = vtk.vtkImageGaussianSource() gs3.SetWholeExtent(0, 30, 0, 30, 0, 30) gs3.SetMaximum(255.0) gs3.SetStandardDeviation(4) gs3.SetCenter(19, 19, 19) t3 = vtk.vtkImageThreshold() t3.SetInputConnection(gs3.GetOutputPort()) t3.ReplaceInOn() t3.SetInValue(0) t3.ThresholdBetween(150, 256) gs4 = vtk.vtkImageGaussianSource() gs4.SetWholeExtent(0, 30, 0, 30, 0, 30) gs4.SetMaximum(255.0) gs4.SetStandardDeviation(4) gs4.SetCenter(26, 26, 26) # we need a few append filters ... iac1 = vtk.vtkImageAppendComponents() iac1.AddInputConnection(t1.GetOutputPort()) iac1.AddInputConnection(gs2.GetOutputPort()) iac2 = vtk.vtkImageAppendComponents() iac2.AddInputConnection(iac1.GetOutputPort()) iac2.AddInputConnection(t3.GetOutputPort()) iac3 = vtk.vtkImageAppendComponents() iac3.AddInputConnection(iac2.GetOutputPort()) iac3.AddInputConnection(gs4.GetOutputPort()) # create the four component dependent - # use lines in x, y, z for colors gridR = vtk.vtkImageGridSource() gridR.SetDataScalarTypeToUnsignedChar() gridR.SetGridSpacing(10, 100, 100) gridR.SetLineValue(250) gridR.SetFillValue(100) gridR.SetDataExtent(0, 30, 0, 30, 0, 30) dR = vtk.vtkImageContinuousDilate3D() dR.SetInputConnection(gridR.GetOutputPort()) dR.SetKernelSize(2, 2, 2) gridG = vtk.vtkImageGridSource() gridG.SetDataScalarTypeToUnsignedChar() gridG.SetGridSpacing(100, 10, 100) gridG.SetLineValue(250) gridG.SetFillValue(100) gridG.SetDataExtent(0, 30, 0, 30, 0, 30) dG = vtk.vtkImageContinuousDilate3D() dG.SetInputConnection(gridG.GetOutputPort()) dG.SetKernelSize(2, 2, 2) gridB = vtk.vtkImageGridSource() gridB.SetDataScalarTypeToUnsignedChar() gridB.SetGridSpacing(100, 100, 10) gridB.SetLineValue(0) gridB.SetFillValue(250) gridB.SetDataExtent(0, 30, 0, 30, 0, 30) dB = vtk.vtkImageContinuousDilate3D() dB.SetInputConnection(gridB.GetOutputPort()) dB.SetKernelSize(2, 2, 2) # need some appending iacRG = vtk.vtkImageAppendComponents() iacRG.AddInputConnection(dR.GetOutputPort()) iacRG.AddInputConnection(dG.GetOutputPort()) iacRGB = vtk.vtkImageAppendComponents() iacRGB.AddInputConnection(iacRG.GetOutputPort()) iacRGB.AddInputConnection(dB.GetOutputPort()) iacRGBA = vtk.vtkImageAppendComponents() iacRGBA.AddInputConnection(iacRGB.GetOutputPort()) iacRGBA.AddInputConnection(ss.GetOutputPort()) # We need a bunch of opacity functions # this one is a simple ramp to .2 rampPoint2 = vtk.vtkPiecewiseFunction() rampPoint2.AddPoint(0, 0.0) rampPoint2.AddPoint(255, 0.2) # this one is a simple ramp to 1 ramp1 = vtk.vtkPiecewiseFunction() ramp1.AddPoint(0, 0.0) ramp1.AddPoint(255, 1.0) # this one shows a sharp surface surface = vtk.vtkPiecewiseFunction() surface.AddPoint(0, 0.0) surface.AddPoint(10, 0.0) surface.AddPoint(50, 1.0) surface.AddPoint(255, 1.0) # this one is constant 1 constant1 = vtk.vtkPiecewiseFunction() constant1.AddPoint(0, 1.0) constant1.AddPoint(255, 1.0) # this one is used for gradient opacity gop = vtk.vtkPiecewiseFunction() gop.AddPoint(0, 0.0) gop.AddPoint(20, 0.0) gop.AddPoint(60, 1.0) gop.AddPoint(255, 1.0) # We need a bunch of color functions # This one is a simple rainbow rainbow = vtk.vtkColorTransferFunction() rainbow.SetColorSpaceToHSV() rainbow.HSVWrapOff() rainbow.AddHSVPoint(0, 0.1, 1.0, 1.0) rainbow.AddHSVPoint(255, 0.9, 1.0, 1.0) # this is constant red red = vtk.vtkColorTransferFunction() red.AddRGBPoint(0, 1, 0, 0) red.AddRGBPoint(255, 1, 0, 0) # this is constant green green = vtk.vtkColorTransferFunction() green.AddRGBPoint(0, 0, 1, 0) green.AddRGBPoint(255, 0, 1, 0) # this is constant blue blue = vtk.vtkColorTransferFunction() blue.AddRGBPoint(0, 0, 0, 1) blue.AddRGBPoint(255, 0, 0, 1) # this is constant yellow yellow = vtk.vtkColorTransferFunction() yellow.AddRGBPoint(0, 1, 1, 0) yellow.AddRGBPoint(255, 1, 1, 0) #ren = vtk.vtkRenderer() #renWin = vtk.vtkRenderWindow() self.renWin.AddRenderer(self.ren) self.renWin.SetSize(500, 500) #iren = vtk.vtkRenderWindowInteractor() self.iren.SetRenderWindow(self.renWin) self.ren.GetCullers().InitTraversal() culler = self.ren.GetCullers().GetNextItem() culler.SetSortingStyleToBackToFront() # We need 25 mapper / actor pairs which we will render # in a grid. Going down we will vary the input data # with the top row unsigned char, then float, then # two dependent components, then four dependent components # then four independent components. Going across we # will vary the rendering method with MIP, Composite, # Composite Shade, Composite GO, and Composite GO Shade. # Create the 5 by 5 grids self.volumeProperty = [[0 for col in range(0, 5)] for row in range(0, 5)] self.volumeMapper = [[0 for col in range(0, 5)] for row in range(0, 5)] volume = [[0 for col in range(0, 5)] for row in range(0, 5)] for i in range(0, 5): for j in range(0, 5): self.volumeProperty[i][j] = vtk.vtkVolumeProperty() self.volumeMapper[i][j] = vtk.vtkFixedPointVolumeRayCastMapper( ) self.volumeMapper[i][j].SetSampleDistance(0.25) self.volumeMapper[i][j].SetNumberOfThreads(1) volume[i][j] = vtk.vtkVolume() volume[i][j].SetMapper(self.volumeMapper[i][j]) volume[i][j].SetProperty(self.volumeProperty[i][j]) volume[i][j].AddPosition(i * 30, j * 30, 0) self.ren.AddVolume(volume[i][j]) for i in range(0, 5): self.volumeMapper[0][i].SetInputConnection(t.GetOutputPort()) self.volumeMapper[1][i].SetInputConnection(ss.GetOutputPort()) self.volumeMapper[2][i].SetInputConnection(iac.GetOutputPort()) self.volumeMapper[3][i].SetInputConnection(iac3.GetOutputPort()) self.volumeMapper[4][i].SetInputConnection(iacRGBA.GetOutputPort()) self.volumeMapper[i][0].SetBlendModeToMaximumIntensity() self.volumeMapper[i][1].SetBlendModeToComposite() self.volumeMapper[i][2].SetBlendModeToComposite() self.volumeMapper[i][3].SetBlendModeToComposite() self.volumeMapper[i][4].SetBlendModeToComposite() self.volumeProperty[0][i].IndependentComponentsOn() self.volumeProperty[1][i].IndependentComponentsOn() self.volumeProperty[2][i].IndependentComponentsOff() self.volumeProperty[3][i].IndependentComponentsOn() self.volumeProperty[4][i].IndependentComponentsOff() self.volumeProperty[0][i].SetColor(rainbow) self.volumeProperty[0][i].SetScalarOpacity(rampPoint2) self.volumeProperty[0][i].SetGradientOpacity(constant1) self.volumeProperty[1][i].SetColor(rainbow) self.volumeProperty[1][i].SetScalarOpacity(rampPoint2) self.volumeProperty[1][i].SetGradientOpacity(constant1) self.volumeProperty[2][i].SetColor(rainbow) self.volumeProperty[2][i].SetScalarOpacity(rampPoint2) self.volumeProperty[2][i].SetGradientOpacity(constant1) self.volumeProperty[3][i].SetColor(0, red) self.volumeProperty[3][i].SetColor(1, green) self.volumeProperty[3][i].SetColor(2, blue) self.volumeProperty[3][i].SetColor(3, yellow) self.volumeProperty[3][i].SetScalarOpacity(0, rampPoint2) self.volumeProperty[3][i].SetScalarOpacity(1, rampPoint2) self.volumeProperty[3][i].SetScalarOpacity(2, rampPoint2) self.volumeProperty[3][i].SetScalarOpacity(3, rampPoint2) self.volumeProperty[3][i].SetGradientOpacity(0, constant1) self.volumeProperty[3][i].SetGradientOpacity(1, constant1) self.volumeProperty[3][i].SetGradientOpacity(2, constant1) self.volumeProperty[3][i].SetGradientOpacity(3, constant1) self.volumeProperty[3][i].SetComponentWeight(0, 1) self.volumeProperty[3][i].SetComponentWeight(1, 1) self.volumeProperty[3][i].SetComponentWeight(2, 1) self.volumeProperty[3][i].SetComponentWeight(3, 1) self.volumeProperty[4][i].SetColor(rainbow) self.volumeProperty[4][i].SetScalarOpacity(rampPoint2) self.volumeProperty[4][i].SetGradientOpacity(constant1) self.volumeProperty[i][2].ShadeOn() self.volumeProperty[i][4].ShadeOn(0) self.volumeProperty[i][4].ShadeOn(1) self.volumeProperty[i][4].ShadeOn(2) self.volumeProperty[i][4].ShadeOn(3) self.volumeProperty[0][0].SetScalarOpacity(ramp1) self.volumeProperty[1][0].SetScalarOpacity(ramp1) self.volumeProperty[2][0].SetScalarOpacity(ramp1) self.volumeProperty[3][0].SetScalarOpacity(0, surface) self.volumeProperty[3][0].SetScalarOpacity(1, surface) self.volumeProperty[3][0].SetScalarOpacity(2, surface) self.volumeProperty[3][0].SetScalarOpacity(3, surface) self.volumeProperty[4][0].SetScalarOpacity(ramp1) self.volumeProperty[0][2].SetScalarOpacity(surface) self.volumeProperty[1][2].SetScalarOpacity(surface) self.volumeProperty[2][2].SetScalarOpacity(surface) self.volumeProperty[3][2].SetScalarOpacity(0, surface) self.volumeProperty[3][2].SetScalarOpacity(1, surface) self.volumeProperty[3][2].SetScalarOpacity(2, surface) self.volumeProperty[3][2].SetScalarOpacity(3, surface) self.volumeProperty[4][2].SetScalarOpacity(surface) self.volumeProperty[0][4].SetScalarOpacity(surface) self.volumeProperty[1][4].SetScalarOpacity(surface) self.volumeProperty[2][4].SetScalarOpacity(surface) self.volumeProperty[3][4].SetScalarOpacity(0, surface) self.volumeProperty[3][4].SetScalarOpacity(1, surface) self.volumeProperty[3][4].SetScalarOpacity(2, surface) self.volumeProperty[3][4].SetScalarOpacity(3, surface) self.volumeProperty[4][4].SetScalarOpacity(surface) self.volumeProperty[0][3].SetGradientOpacity(gop) self.volumeProperty[1][3].SetGradientOpacity(gop) self.volumeProperty[2][3].SetGradientOpacity(gop) self.volumeProperty[3][3].SetGradientOpacity(0, gop) self.volumeProperty[3][3].SetGradientOpacity(2, gop) self.volumeProperty[4][3].SetGradientOpacity(gop) self.volumeProperty[3][3].SetScalarOpacity(0, ramp1) self.volumeProperty[3][3].SetScalarOpacity(2, ramp1) self.volumeProperty[0][4].SetGradientOpacity(gop) self.volumeProperty[1][4].SetGradientOpacity(gop) self.volumeProperty[2][4].SetGradientOpacity(gop) self.volumeProperty[3][4].SetGradientOpacity(0, gop) self.volumeProperty[3][4].SetGradientOpacity(2, gop) self.volumeProperty[4][4].SetGradientOpacity(gop) self.renWin.Render() self.ren.GetActiveCamera().Dolly(1.3) self.ren.GetActiveCamera().Azimuth(15) self.ren.GetActiveCamera().Elevation(5) self.ren.ResetCameraClippingRange()
def create_volume(self): if self._actor is None: if int(ses.Session().rendering) == 0: self._volume_mapper = vtk.vtkFixedPointVolumeRayCastMapper() #volume_mapper.AutoAdjustSampleDistancesOff() self._volume_mapper.IntermixIntersectingGeometryOn() pix_diag = 2.0 self._volume_mapper.SetImageSampleDistance(0.25) self._volume_mapper.SetSampleDistance(pix_diag / 5.0) else: self._volume_mapper = vtk.vtkGPUVolumeRayCastMapper() self._volume_mapper.UseJitteringOn() if LooseVersion(vtk.vtkVersion().GetVTKVersion() ) > LooseVersion('8.0'): self._volume_mapper.SetBlendModeToIsoSurface() # else: # isosurfaceFunc = vtk.vtkVolumeRayCastIsosurfaceFunction() # isosurfaceFunc.SetIsoValue(127) # self._volume_mapper = vtk.vtkVolumeRayCastMapper() # self._volume_mapper.SetVolumeRayCastFunction(isosurfaceFunc) self._flip = vtk.vtkImageFlip() self._flip.SetInputData(self.mask.imagedata) self._flip.SetFilteredAxis(1) self._flip.FlipAboutOriginOn() self._volume_mapper.SetInputConnection(self._flip.GetOutputPort()) self._volume_mapper.Update() r, g, b = self.colour self._color_transfer = vtk.vtkColorTransferFunction() self._color_transfer.RemoveAllPoints() self._color_transfer.AddRGBPoint(0.0, 0, 0, 0) self._color_transfer.AddRGBPoint(254.0, r, g, b) self._color_transfer.AddRGBPoint(255.0, r, g, b) self._piecewise_function = vtk.vtkPiecewiseFunction() self._piecewise_function.RemoveAllPoints() self._piecewise_function.AddPoint(0.0, 0.0) self._piecewise_function.AddPoint(127, 1.0) self._volume_property = vtk.vtkVolumeProperty() self._volume_property.SetColor(self._color_transfer) self._volume_property.SetScalarOpacity(self._piecewise_function) self._volume_property.ShadeOn() self._volume_property.SetInterpolationTypeToLinear() self._volume_property.SetSpecular(0.75) self._volume_property.SetSpecularPower(2) if not self._volume_mapper.IsA("vtkGPUVolumeRayCastMapper"): self._volume_property.SetScalarOpacityUnitDistance(pix_diag) else: if LooseVersion(vtk.vtkVersion().GetVTKVersion() ) > LooseVersion('8.0'): self._volume_property.GetIsoSurfaceValues().SetValue( 0, 127) self._actor = vtk.vtkVolume() self._actor.SetMapper(self._volume_mapper) self._actor.SetProperty(self._volume_property) self._actor.Update()
def _render_blurry_particles(self, particles_dataset): particles_per_species = dict((k, vtk.vtkPoints()) for k in self._species_idmap.iterkeys()) scaling = self.settings.scaling position_idx = particles_dataset.dtype.names.index('position') species_id_idx = particles_dataset.dtype.names.index('species_id') for p in particles_dataset: pos = p[position_idx] display_species_id = self._species_idmap.get(p[species_id_idx]) if display_species_id is None: continue particles_per_species[display_species_id].InsertNextPoint( pos * scaling / self._world_size) nx = ny = nz = self.settings.fluorimetry_axial_voxel_number for display_species_id, points in particles_per_species.iteritems(): poly_data = vtk.vtkPolyData() poly_data.SetPoints(points) poly_data.ComputeBounds() pattr = self._pattrs[display_species_id] # Calc standard deviation of gauss distribution function wave_length = pattr['fluorimetry_wave_length'] sigma = scaling * 0.5 * wave_length / self._world_size # Create guassian splatter gs = vtk.vtkGaussianSplatter() gs.SetInput(poly_data) gs.SetSampleDimensions(nx, ny, nz) gs.SetRadius(sigma) gs.SetExponentFactor(-.5) gs.ScalarWarpingOff() gs.SetModelBounds([-sigma, scaling + sigma] * 3) gs.SetAccumulationModeToMax() # Create filter for volume rendering filter = vtk.vtkImageShiftScale() # Scales to unsigned char filter.SetScale(255. * pattr['fluorimetry_brightness']) filter.ClampOverflowOn() filter.SetOutputScalarTypeToUnsignedChar() filter.SetInputConnection(gs.GetOutputPort()) mapper = vtk.vtkFixedPointVolumeRayCastMapper() mapper.SetInputConnection(filter.GetOutputPort()) volume = vtk.vtkVolume() property = volume.GetProperty() # vtk.vtkVolumeProperty() color = pattr['fluorimetry_luminescence_color'] color_tfunc = vtk.vtkColorTransferFunction() color_tfunc.AddRGBPoint(0, color[0], color[1], color[2]) property.SetColor(color_tfunc) opacity_tfunc = vtk.vtkPiecewiseFunction() opacity_tfunc.AddPoint(0, 0.0) opacity_tfunc.AddPoint(255., 1.0) property.SetScalarOpacity(opacity_tfunc) property.SetInterpolationTypeToLinear() if self.settings.fluorimetry_shadow_display: property.ShadeOn() else: property.ShadeOff() volume.SetMapper(mapper) self.renderer.AddVolume(volume)
def addVol(self, data, header=None): pix_diag = 5.0 / 10.0 img = vtkImageImportFromArray() img.SetArray(data) img.ConvertIntToUnsignedShortOn() """ Origin and Data spacing setting are essential for a normalized volume rendering of the DWI image volumes ------- dawdling for a long time for addressing the problem that the volume is too thin and even resorted to pre-resampling of the DWI volumes """ # img.GetImport().SetDataSpacing(0.9375, 0.9375, 4.5200) img.GetImport().SetDataSpacing(header["pixdim"][1:4]) # img.GetImport().SetDataOrigin(128.0, 128.0, 68.50) img.GetImport().SetDataOrigin( header["dim"][0] * header["pixdim"][0], header["dim"][1] * header["pixdim"][1], header["dim"][2] * header["pixdim"][2], ) print img.GetDataExtent() volMapper = vtk.vtkFixedPointVolumeRayCastMapper() # compositeFunction = vtk.vtkFixedPointVolumeRayCastCompositeHelper() # compositeFunction.SetCompositeMethodToInterpolateFirst() # compositeFunction.SetCompositeMethodToClassifyFirst() # volMapper.SetVolumeRayCastFunction(compositeFunction) volMapper.SetSampleDistance(pix_diag / 5.0) volMapper.SetImageSampleDistance(1.0) volMapper.SetInputConnection(img.GetOutputPort()) # The property describes how the data will look self.volProperty = volProperty = vtk.vtkVolumeProperty() volProperty.SetColor(self.color_tf) volProperty.SetScalarOpacity(self.opacity_tf) volProperty.SetGradientOpacity(self.opacity_tf) if self.parent.lighting: volProperty.ShadeOn() # volProperty.SetInterpolationTypeToLinear() volProperty.SetInterpolationTypeToNearest() volProperty.SetScalarOpacityUnitDistance(pix_diag / 5.0) vol = vtk.vtkVolume() vol.SetMapper(volMapper) vol.SetProperty(volProperty) self.ren.AddVolume(vol) boxWidget = vtk.vtkBoxWidget() boxWidget.SetInteractor(self.parent.m_ui.renderView) boxWidget.SetPlaceFactor(1.0) planes = vtk.vtkPlanes() def ClipVolumeRender(obj, event): obj.GetPlanes(planes) volMapper.SetClippingPlanes(planes) boxWidget.SetInput(img.GetOutput()) boxWidget.PlaceWidget(img.GetOutput().GetBounds()) boxWidget.InsideOutOn() boxWidget.AddObserver("InteractionEvent", ClipVolumeRender) outlineProperty = boxWidget.GetOutlineProperty() outlineProperty.SetRepresentationToWireframe() outlineProperty.SetAmbient(1.0) outlineProperty.SetAmbientColor(1, 1, 1) outlineProperty.SetLineWidth(3) selectedOutlineProperty = boxWidget.GetSelectedOutlineProperty() selectedOutlineProperty.SetRepresentationToWireframe() selectedOutlineProperty.SetAmbient(1.0) selectedOutlineProperty.SetAmbientColor(1, 0, 0) selectedOutlineProperty.SetLineWidth(1) outline = vtk.vtkOutlineFilter() outline.SetInputConnection(img.GetOutputPort()) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInputConnection(outline.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(outlineMapper) self.ren.AddActor(outlineActor) self.volnum += 1
def __init__(self,imagetype,prefix,extent): if imagetype == "jpg": reader = vtk.vtkJPEGReader() elif imagetype == "pnm": reader = vtk.vtkPNMReader() elif imagetype == "tif": reader = vtk.vtkTIFFReader() # todo: add more image types else: print "unknown type!" sys.exit() reader.SetDataExtent(extent) #reader.SetFilePrefix(prefix) reader.SetFilePattern(prefix) reader.SetDataSpacing(1,1,1) imageoriginal = reader.GetOutput() # pad the image with extra voxels because of vtk off by 1 # annoyance in calculating image bounds # extentcopy = extent[:] # for i in xrange(1,7,2): # extentcopy[i] += 1 # padder = vtk.vtkImageConstantPad() # padder.SetInput(imageoriginal) # padder.SetOutputWholeExtent(extentcopy) # padder.SetConstant(255) # arbitrary # self.image = padder.GetOutput() # self.image.Update() self.image = imageoriginal self.image.Update() # must use this particular mapper so color images work, also # handles off by 1 annoyance in a slightly better way. mapper = vtk.vtkFixedPointVolumeRayCastMapper() mapper.IntermixIntersectingGeometryOn() min_extent = min(extent[1:6:2]) # todo: can use a built in function for this # for very small images we need to reset the sample distance if min_extent < 50: mapper.SetSampleDistance(float(min_extent)/100) mapper.SetInteractiveSampleDistance(float(min_extent)/50) mapper.SetInput(self.image) volproperty = vtk.vtkVolumeProperty() volproperty.IndependentComponentsOff() # we initially set the opacity to a constant value of 1, but # we need the function so we can change it later self.opacity = vtk.vtkPiecewiseFunction() self.opacity.AddSegment(0,1,255,1) # the type of color function we use depends on how many # components the image has, 3 for a color image, 1 for a black # and white image num_components = self.image.GetNumberOfScalarComponents() if num_components == 1: color = vtk.vtkPiecewiseFunction() color.AddSegment(0,0,255,1) volproperty.SetColor(color) volproperty.SetScalarOpacity(self.opacity) elif num_components == 4: ## red = vtk.vtkColorTransferFunction() ## red.AddRGBSegment(0,0,0,0,255,1,0,0) ## green = vtk.vtkColorTransferFunction() ## green.AddRGBSegment(0,0,0,0,255,0,1,0) ## blue = vtk.vtkColorTransferFunction() ## blue.AddRGBSegment(0,0,0,0,255,0,0,1) ## volproperty.SetColor(0,red) ## volproperty.SetColor(1,green) ## volproperty.SetColor(2,blue) volproperty.SetScalarOpacity(self.opacity) ## volproperty.SetScalarOpacity(1,self.opacity) ## volproperty.SetScalarOpacity(2,self.opacity) else: pass print num_components volume = vtk.vtkVolume() volume.SetMapper(mapper) volume.SetProperty(volproperty) self.ren = vtk.vtkRenderer() self.ren.AddActor(volume) # on mac, this shows only the cone #self.DrawCone() #print self.ren.VisibleActorCount() #print self.ren.VisibleVolumeCount() self.ren.ResetCamera()