def axonComparison(axons, N): axonsToRender = [] for i in range(N): axon = axons.pop(random.randrange(len(axons))) axonsToRender.append(axon) bins = main.BINS data_matrix = numpy.zeros([500, 500, 500], dtype=numpy.uint16) dataImporter = vtk.vtkImageImport() data_string = data_matrix.tostring() dataImporter.CopyImportVoidPointer(data_string, len(data_string)) dataImporter.SetDataScalarTypeToUnsignedChar() dataImporter.SetNumberOfScalarComponents(1) dataImporter.SetDataExtent(0, 500, 0, 500, 0, 500) dataImporter.SetWholeExtent(0, 500, 0, 500, 0, 500) volumeProperty = vtk.vtkVolumeProperty() compositeFunction = vtk.vtkVolumeRayCastCompositeFunction() volumeMapper = vtk.vtkVolumeRayCastMapper() volumeMapper.SetVolumeRayCastFunction(compositeFunction) volumeMapper.SetInputConnection(dataImporter.GetOutputPort()) volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) renderer = vtk.vtkRenderer() renderWin = vtk.vtkRenderWindow() renderWin.AddRenderer(renderer) renderInteractor = vtk.vtkRenderWindowInteractor() renderInteractor.SetRenderWindow(renderWin) renderer.SetBackground(1, 1, 1) renderWin.SetSize(400, 400) for axon in axonsToRender: renderer = Utils.renderSingleAxon(axon, renderer, [random.random(), random.random(), random.random()]) renderWin.AddObserver("AbortCheckEvent", exitCheck) renderInteractor.Initialize() renderWin.Render() renderInteractor.Start()
def setVolumeVisualization(self, volumeVisualization): """ Updates the volume property. It actually removes the volume, creates a new volume and sets the updated volume property and then adds the new volume to the renderer. Just updating the vtkVolumeProperty gives artifacts and seems to not work correctly. :type volumeVisualization: volumeVisualization """ self.volumeVisualization = volumeVisualization if self.imageData is None or self.volumeVisualization is None: if self.volume is not None: self.renderer.RemoveViewProp(self.volume) self.volume = None return if self.volume is None: self.volume = vtkVolume() self.renderer.AddViewProp(self.volume) self.volumeVisualization.setMapper(self.mapper) self.mapper.SetShaderType(self.volumeVisualization.shaderType()) if self.volume.GetProperty() != self.volumeVisualization.volProp: self.volume.SetProperty(self.volumeVisualization.volProp) if self.volume.GetMapper() != self.mapper: self.volume.SetMapper(self.mapper) self.render()
def create_volume_rendering(self): opacityfunction=vtk.vtkPiecewiseFunction() opacityfunction.AddPoint(0,0.0) opacityfunction.AddPoint(0.1,0.01) opacityfunction.AddPoint(1,0.02) opacityfunction.AddPoint(1.5,0.03) volproperty=vtk.vtkVolumeProperty() volproperty.SetColor(self.arrowColor) volproperty.SetScalarOpacity(opacityfunction) volproperty.ShadeOn() volproperty.SetInterpolationTypeToLinear() volumeMapper = vtk.vtkGPUVolumeRayCastMapper() volumeMapper.SetInputConnection(self.vol_reader.GetOutputPort()) volumeMapper.SetSampleDistance(0.01) volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volproperty) return volume
def initUI(self): self.frame = QtGui.QFrame() self.widgetLayout = QtGui.QVBoxLayout() self.setLayout(self.widgetLayout) self.widgetLayout.addWidget(self.frame) self.frameLayout = QtGui.QVBoxLayout() self.frame.setLayout(self.frameLayout) self.vtkWidget = QVTKRenderWindowInteractor(self.frame) self.frameLayout.addWidget(self.vtkWidget) self.sliceNumber = QtGui.QLineEdit("50") self.sliceConfirm = QtGui.QPushButton("confirm") self.sliceConfirm.clicked.connect(self.showLayer) self.sliceButtonLayout = QtGui.QHBoxLayout() self.sliceButtonLayout.addWidget(self.sliceNumber) self.sliceButtonLayout.addWidget(self.sliceConfirm) self.frameLayout.addLayout(self.sliceButtonLayout) self.volume = vtk.vtkVolume() self.ren = vtk.vtkRenderer() self.vtkWidget.GetRenderWindow().AddRenderer(self.ren) self.iren = self.vtkWidget.GetRenderWindow().GetInteractor() self.show() self.iren.Initialize() self.setGeometry(300, 300, 300, 150) self.setWindowTitle('Layer View') self.show()
def __init__(self, input=None, MinOpacity=0.0, MaxOpacity=0.1) : import qt import vtk from vtk.qt.QVTKRenderWindowInteractor import QVTKRenderWindowInteractor self.__MinOpacity__ = MinOpacity self.__MaxOpacity__ = MaxOpacity # every QT app needs an app self.__app__ = qt.QApplication(['itkviewer']) # create the widget self.__widget__ = QVTKRenderWindowInteractor() self.__ren__ = vtk.vtkRenderer() self.__widget__.GetRenderWindow().AddRenderer(self.__ren__) self.__itkvtkConverter__ = None self.__volumeMapper__ = vtk.vtkVolumeTextureMapper2D() self.__volume__ = vtk.vtkVolume() self.__volumeProperty__ = vtk.vtkVolumeProperty() self.__volume__.SetMapper(self.__volumeMapper__) self.__volume__.SetProperty(self.__volumeProperty__) self.__ren__.AddVolume(self.__volume__) self.__outline__ = None self.__outlineMapper__ = None self.__outlineActor__ = None self.AdaptColorAndOpacity(0, 255) if input : self.SetInput(input) self.AdaptColorAndOpacity()
def _create_pipeline(self): # setup our pipeline self._otf = vtk.vtkPiecewiseFunction() self._ctf = vtk.vtkColorTransferFunction() self._volume_property = vtk.vtkVolumeProperty() self._volume_property.SetScalarOpacity(self._otf) self._volume_property.SetColor(self._ctf) self._volume_property.ShadeOn() self._volume_property.SetAmbient(0.1) self._volume_property.SetDiffuse(0.7) self._volume_property.SetSpecular(0.2) self._volume_property.SetSpecularPower(10) self._volume_raycast_function = vtk.vtkVolumeRayCastMIPFunction() self._volume_mapper = vtk.vtkVolumeRayCastMapper() # can also used FixedPoint, but then we have to use: # SetBlendModeToMaximumIntensity() and not SetVolumeRayCastFunction #self._volume_mapper = vtk.vtkFixedPointVolumeRayCastMapper() self._volume_mapper.SetVolumeRayCastFunction( self._volume_raycast_function) module_utils.setup_vtk_object_progress(self, self._volume_mapper, 'Preparing render.') self._volume = vtk.vtkVolume() self._volume.SetProperty(self._volume_property) self._volume.SetMapper(self._volume_mapper)
def __init__(self, img, color): self.volume = vtk.vtkVolume() self.__color = color dataImporter = vtk.vtkImageImport() simg = np.ascontiguousarray(img, np.uint8) dataImporter.CopyImportVoidPointer(simg.data, len(simg.data)) dataImporter.SetDataScalarTypeToUnsignedChar() dataImporter.SetNumberOfScalarComponents(1) dataImporter.SetDataExtent(0, simg.shape[2]-1, 0, simg.shape[1]-1, 0, simg.shape[0]-1) dataImporter.SetWholeExtent(0, simg.shape[2]-1, 0, simg.shape[1]-1, 0, simg.shape[0]-1) self.__smoother = vtk.vtkImageGaussianSmooth() self.__smoother.SetStandardDeviation(1, 1, 1) self.__smoother.SetInputConnection(dataImporter.GetOutputPort()) volumeMapper = vtk.vtkSmartVolumeMapper() volumeMapper.SetInputConnection(self.__smoother.GetOutputPort()) self.__volumeProperty = vtk.vtkVolumeProperty() self.__colorFunc = vtk.vtkColorTransferFunction() self.__alpha = vtk.vtkPiecewiseFunction() for i in range(256): self.__colorFunc.AddRGBPoint(i, i * color[0], i * color[1], i * color[2]) self.__alpha.AddPoint(5, .01) self.__alpha.AddPoint(10, .03) self.__alpha.AddPoint(50, .1) self.__alpha.AddPoint(150, .2) self.__volumeProperty.SetColor(self.__colorFunc) self.__volumeProperty.SetScalarOpacity(self.__alpha) self.volume.SetMapper(volumeMapper) self.volume.SetProperty(self.__volumeProperty)
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 _createPipeline(self): # setup our pipeline self._splatMapper = vtkdevide.vtkOpenGLVolumeShellSplatMapper() self._splatMapper.SetOmegaL(0.9) self._splatMapper.SetOmegaH(0.9) # high-quality rendermode self._splatMapper.SetRenderMode(0) self._otf = vtk.vtkPiecewiseFunction() self._otf.AddPoint(0.0, 0.0) self._otf.AddPoint(0.9, 0.0) self._otf.AddPoint(1.0, 1.0) self._ctf = vtk.vtkColorTransferFunction() self._ctf.AddRGBPoint(0.0, 0.0, 0.0, 0.0) self._ctf.AddRGBPoint(0.9, 0.0, 0.0, 0.0) self._ctf.AddRGBPoint(1.0, 1.0, 0.937, 0.859) self._volumeProperty = vtk.vtkVolumeProperty() self._volumeProperty.SetScalarOpacity(self._otf) self._volumeProperty.SetColor(self._ctf) self._volumeProperty.ShadeOn() self._volumeProperty.SetAmbient(0.1) self._volumeProperty.SetDiffuse(0.7) self._volumeProperty.SetSpecular(0.2) self._volumeProperty.SetSpecularPower(10) self._volume = vtk.vtkVolume() self._volume.SetProperty(self._volumeProperty) self._volume.SetMapper(self._splatMapper)
def get_volume(self, color_file=None, volume_opacity=0.25): """ Default Volume Rendering Return vtkActor. For volume rendering it is vtkVolume """ if not self.flag_read: sys.stderr.write('No Image Loaded.') return # TEST print self.is_blank_image() transfer_func = self.get_transfer_functioin(color_file, volume_opacity) prop_volume = vtk.vtkVolumeProperty() prop_volume.ShadeOff() prop_volume.SetColor(transfer_func[0]) prop_volume.SetScalarOpacity(transfer_func[1]) prop_volume.SetGradientOpacity(transfer_func[2]) prop_volume.SetInterpolationTypeToLinear() prop_volume.SetAmbient(0.4) prop_volume.SetDiffuse(0.6) prop_volume.SetSpecular(0.2) mapper = vtk.vtkSmartVolumeMapper() mapper.SetRequestedRenderMode(0) # mapper = vtk.vtkGPUVolumeRayCastMapper() mapper.SetInputData(self.reader) actor = vtk.vtkVolume() actor.SetMapper(mapper) actor.SetProperty(prop_volume) return actor
def volumeRender(img, tf=[],spacing=[1.0,1.0,1.0]): importer = numpy2VTK(img,spacing) # Transfer Functions opacity_tf = vtk.vtkPiecewiseFunction() color_tf = vtk.vtkColorTransferFunction() if len(tf) == 0: tf.append([img.min(),0,0,0,0]) tf.append([img.max(),1,1,1,1]) for p in tf: color_tf.AddRGBPoint(p[0], p[1], p[2], p[3]) opacity_tf.AddPoint(p[0], p[4]) volMapper = vtk.vtkGPUVolumeRayCastMapper() volMapper.SetInputConnection(importer.GetOutputPort()) # The property describes how the data will look volProperty = vtk.vtkVolumeProperty() volProperty.SetColor(color_tf) volProperty.SetScalarOpacity(opacity_tf) volProperty.ShadeOn() volProperty.SetInterpolationTypeToLinear() vol = vtk.vtkVolume() vol.SetMapper(volMapper) vol.SetProperty(volProperty) return [vol]
def __init__(self, name, image_data): if not isinstance(image_data, vtk.vtkImageData): raise TypeError("input has to be vtkImageData") self.name = name # Create transfer mapping scalar value to opacity. opacity_function = vtk.vtkPiecewiseFunction() opacity_function.AddPoint(0, 0.0) opacity_function.AddPoint(127, 0.0) opacity_function.AddPoint(128, 0.2) opacity_function.AddPoint(255, 0.2) # Create transfer mapping scalar value to color. color_function = vtk.vtkColorTransferFunction() color_function.SetColorSpaceToHSV() color_function.AddHSVPoint(0, 0.0, 0.0, 0.0) color_function.AddHSVPoint(127, 0.0, 0.0, 0.0) color_function.AddHSVPoint(128, 0.0, 0.0, 1.0) color_function.AddHSVPoint(255, 0.0, 0.0, 1.0) volume_property = vtk.vtkVolumeProperty() volume_property.SetColor(color_function) volume_property.SetScalarOpacity(opacity_function) volume_property.ShadeOn() volume_property.SetInterpolationTypeToLinear() volume_mapper = vtk.vtkSmartVolumeMapper() volume_mapper.SetInputData(image_data) self.volume = vtk.vtkVolume() self.volume.SetMapper(volume_mapper) self.volume.SetProperty(volume_property)
def RenderVTKVolume(image, volprops): volmap = vtk.vtkVolumeRayCastMapper() volmap.SetVolumeRayCastFunction(vtk.vtkVolumeRayCastCompositeFunction()) volmap.SetInputConnection(image.GetOutputPort()) vol = vtk.vtkVolume() vol.SetMapper(volmap) vol.SetProperty(volprops) #Standard VTK stuff ren = vtk.vtkRenderer() ren.AddVolume(vol) ren.SetBackground((1, 1, 1)) renwin = vtk.vtkRenderWindow() renwin.AddRenderer(ren) istyle = vtk.vtkInteractorStyleSwitch() istyle.SetCurrentStyleToTrackballCamera() iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renwin) iren.SetInteractorStyle(istyle) renwin.Render() iren.Start()
def rebuildVolume( self ): self.volume = vtk.vtkVolume() self.volume.SetMapper( self.volumeMapper ) self.volume.SetScale( 1.0, 1.0, 1.0 ) self.volume.SetMapper(self.volumeMapper) self.volume.SetProperty(self.volumeProperty) self.volume.SetPosition( self.pos ) self.setVolRenderCfg( None, False ) self.renderer.AddVolume( self.volume )
def _create_pipeline(self): # setup our pipeline self._volume_property = vtk.vtkVolumeProperty() self._volume_property.ShadeOn() self._volume_mapper = None self._volume = vtk.vtkVolume() self._volume.SetProperty(self._volume_property) self._volume.SetMapper(self._volume_mapper)
def __init__ (self, mod_m): debug ("In Volume::__init__ ()") Common.state.busy () Base.Objects.Module.__init__ (self, mod_m) self.actor = self.act = vtk.vtkVolume () self.data_out = self.mod_m.GetOutput () self._initialize () self._gui_init () self.legend = VolumeLegend(self.renwin, mod_m) self.legend.update_lut(self.actor.GetProperty()) self.renwin.add_actors(self.legend.get_scalar_bar()) self.renwin.Render () Common.state.idle ()
def test_wrap_vtk(self): """Test if the wrap_vtk function works.""" o = vtk.vtkVolume() w = tvtk_helper.wrap_vtk(o) self.assertEqual(w.__class__.__name__, 'Volume') w1 = tvtk_helper.wrap_vtk(w) self.assertEqual(w, w1) del w1, w, o class A: pass a = A() w = tvtk_helper.wrap_vtk(a) self.assertEqual(a, w)
def volumeRender(img, tf=[], spacing=[1.0, 1.0, 1.0]): importer = numpy2VTK(img, spacing) # Transfer Functions opacity_tf = vtk.vtkPiecewiseFunction() color_tf = vtk.vtkColorTransferFunction() if len(tf) == 0: tf.append([img.min(), 0, 0, 0, 0]) tf.append([img.max(), 1, 1, 1, 1]) for p in tf: color_tf.AddRGBPoint(p[0], p[1], p[2], p[3]) opacity_tf.AddPoint(p[0], p[4]) # working on the GPU volMapper = vtk.vtkGPUVolumeRayCastMapper() volMapper.SetInputConnection(importer.GetOutputPort()) # # The property describes how the data will look # volProperty = vtk.vtkVolumeProperty() # volProperty.SetColor(color_tf) # volProperty.SetScalarOpacity(opacity_tf) # volProperty.ShadeOn() # volProperty.SetInterpolationTypeToLinear() # # working on the CPU # #volMapper = vtk.vtkVolumeRayCastMapper() # volMapper = vtkFixedPointVolumeRayCastMapper() # #compositeFunction = vtk.vtkVolumeRayCastCompositeFunction() # #compositeFunction.SetCompositeMethodToInterpolateFirst() # #volMapper.SetVolumeRayCastFunction(compositeFunction) # volMapper.SetInputConnection(importer.GetOutputPort()) # The property describes how the data will look volProperty = vtk.vtkVolumeProperty() volProperty.SetColor(color_tf) volProperty.SetScalarOpacity(opacity_tf) #volProperty.ShadeOn() #volProperty.SetInterpolationTypeToLinear() # Do the lines below speed things up? pix_diag = 5.0 volMapper.SetSampleDistance(pix_diag / 1.0) volProperty.SetScalarOpacityUnitDistance(pix_diag) vol = vtk.vtkVolume() vol.SetMapper(volMapper) vol.SetProperty(volProperty) return [vol]
def BuildView(self): if not self.vmtkRenderer: self.vmtkRenderer = vmtkrenderer.vmtkRenderer() self.vmtkRenderer.Initialize() self.OwnRenderer = 1 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 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 volumeRender(img, tf=[],spacing=[1.0,1.0,1.0]): importer = numpy2VTK(img,spacing) # Transfer Functions opacity_tf = vtk.vtkPiecewiseFunction() color_tf = vtk.vtkColorTransferFunction() if len(tf) == 0: tf.append([img.min(),0,0,0,0]) tf.append([img.max(),1,1,1,1]) for p in tf: color_tf.AddRGBPoint(p[0], p[1], p[2], p[3]) opacity_tf.AddPoint(p[0], p[4]) # working on the GPU # volMapper = vtk.vtkGPUVolumeRayCastMapper() # volMapper.SetInputConnection(importer.GetOutputPort()) # # The property describes how the data will look # volProperty = vtk.vtkVolumeProperty() # volProperty.SetColor(color_tf) # volProperty.SetScalarOpacity(opacity_tf) # volProperty.ShadeOn() # volProperty.SetInterpolationTypeToLinear() # working on the CPU volMapper = vtk.vtkVolumeRayCastMapper() compositeFunction = vtk.vtkVolumeRayCastCompositeFunction() compositeFunction.SetCompositeMethodToInterpolateFirst() volMapper.SetVolumeRayCastFunction(compositeFunction) volMapper.SetInputConnection(importer.GetOutputPort()) # The property describes how the data will look volProperty = vtk.vtkVolumeProperty() volProperty.SetColor(color_tf) volProperty.SetScalarOpacity(opacity_tf) volProperty.ShadeOn() volProperty.SetInterpolationTypeToLinear() # Do the lines below speed things up? # pix_diag = 5.0 # volMapper.SetSampleDistance(pix_diag / 5.0) # volProperty.SetScalarOpacityUnitDistance(pix_diag) vol = vtk.vtkVolume() vol.SetMapper(volMapper) vol.SetProperty(volProperty) return [vol]
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 __init__(self, data_dir, opacityL, opacityH): # Read the data filename = "vol_t00_x5_70_d4pt5_inner.vti" vSource = vtk.vtkXMLImageDataReader() vSource.SetFileName(filename) vSource.Update() #blocks = reader1.GetOutput() #b0 = blocks.GetBlock(0) # Setup VTK environment #Create a mapper and actor opacityTransferFunction = vtk.vtkPiecewiseFunction() opacityTransferFunction.AddPoint(opacityL, 0.0) opacityTransferFunction.AddPoint(opacityH, 0.8) colorTransferFunction = vtk.vtkColorTransferFunction() colorTransferFunction.AddRGBPoint(0.0, 0.0, 0.0, 0.0) colorTransferFunction.AddRGBPoint(64.0, 1.0, 0.2, 0.4) #colorTransferFunction.AddRGBPoint(128.0, 0.0, 0.0, 1.0) #colorTransferFunction.AddRGBPoint(192.0, 0.0, 1.0, 0.0) volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(colorTransferFunction) #volumeProperty.SetGradientOpacity(gradientTransferFunction) volumeProperty.SetScalarOpacity(opacityTransferFunction) #volumeProperty.ShadeOn() volumeProperty.SetInterpolationTypeToLinear() volumeProperty.SetAmbient(1.0) volumeProperty.SetDiffuse(0.7) volumeProperty.SetSpecular(0.5) volumeMapper = vtk.vtkSmartVolumeMapper() volumeMapper.SetInputConnection(vSource.GetOutputPort()) #volumeMapper.CroppingOn() volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) volume.Update() #renderer.AddVolume(volume) # Mapper #glyph_mapper = vtk.vtkPolyDataMapper() #glyph_mapper.SetInputConnection(glyphs.GetOutputPort()) #glyph_actor = vtk.vtkActor() #glyph_actor.SetMapper(glyph_mapper) #self.b0 = b0 self.volume = volume self.vSource = vSource
def load_atlas(path, intensities, signs): ''' path: path to atlas file opacity: opacity of overlayed atlas brain ''' nifti_reader = vtk.vtkNIFTIImageReader() nifti_reader.SetFileName(path) nifti_reader.Update() # intensities = intensities/math.sqrt(np.mean(intensities**2)) # The following class is used to store transparencyv-values for later # retrival. In our case, we want the value 0 to be completly opaque alphaChannelFunc = vtk.vtkPiecewiseFunction() alphaChannelFunc.AddPoint(0, 0.0) for i in range(len(intensities)): alphaChannelFunc.AddPoint(i + 1, intensities[i]) # This class stores color data and can create color tables from a few color # points. For this demo, we want the three cubes to be of the colors red # green and blue. colorFunc = vtk.vtkColorTransferFunction() colorFunc.AddRGBPoint(0, 0.0, 0.0, 0.0) for i in range(len(signs)): if signs[i] < 0: colorFunc.AddRGBPoint(i + 1, 0.0, 0.0, intensities[i]) elif signs[i] > 0: colorFunc.AddRGBPoint(i + 1, intensities[i], 0.0, 0.0) else: colorFunc.AddRGBPoint(i + 1, 1.0, 1.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 prpoperties. volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(colorFunc) volumeProperty.SetScalarOpacity(alphaChannelFunc) volumeProperty.ShadeOn() # We can finally create our volume. We also have to specify the data for # it, as well as how the data will be rendered. volumeMapper = vtk.vtkSmartVolumeMapper() volumeMapper.SetInputDataObject(nifti_reader.GetOutput()) # The class vtkVolume is used to pair the preaviusly declared volume as # well as the properties to be used when rendering that volume. volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) return volume
def load_atlas(path, intensities, signs): ''' path: path to atlas file opacity: opacity of overlayed atlas brain ''' nifti_reader = vtk.vtkNIFTIImageReader() nifti_reader.SetFileName(path) nifti_reader.Update() # intensities = intensities/math.sqrt(np.mean(intensities**2)) # The following class is used to store transparencyv-values for later # retrival. In our case, we want the value 0 to be completly opaque alphaChannelFunc = vtk.vtkPiecewiseFunction() alphaChannelFunc.AddPoint(0, 0.0) for i in range(len(intensities)): alphaChannelFunc.AddPoint(i+1, intensities[i]) # This class stores color data and can create color tables from a few color # points. For this demo, we want the three cubes to be of the colors red # green and blue. colorFunc = vtk.vtkColorTransferFunction() colorFunc.AddRGBPoint(0, 0.0, 0.0, 0.0) for i in range(len(signs)): if signs[i] < 0: colorFunc.AddRGBPoint(i+1, 0.0, 0.0, intensities[i]) elif signs[i] > 0: colorFunc.AddRGBPoint(i+1, intensities[i], 0.0, 0.0) else: colorFunc.AddRGBPoint(i+1, 1.0, 1.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 prpoperties. volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(colorFunc) volumeProperty.SetScalarOpacity(alphaChannelFunc) volumeProperty.ShadeOn() # We can finally create our volume. We also have to specify the data for # it, as well as how the data will be rendered. volumeMapper = vtk.vtkSmartVolumeMapper() volumeMapper.SetInputDataObject(nifti_reader.GetOutput()) # The class vtkVolume is used to pair the preaviusly declared volume as # well as the properties to be used when rendering that volume. volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) return volume
def save_vtk_image(images, dst, i): image_import = vtk.vtkImageImport() image_import.CopyImportVoidPointer(images.tostring(), len(images.tostring())) image_import.SetDataScalarTypeToUnsignedChar() image_import.SetNumberOfScalarComponents(1) image_import.SetDataExtent(0, images.shape[2] - 1, 0, images.shape[1] - 1, 0, images.shape[0] - 1) image_import.SetWholeExtent(0, images.shape[2] - 1, 0, images.shape[1] - 1, 0, images.shape[0] - 1) volume = vtk.vtkVolume() volume_mapper = vtk.vtkVolumeRayCastMapper() alpha_channel_func = vtk.vtkPiecewiseFunction() alpha_channel_func.AddPoint(0, 0.0) # alpha_channel_func.AddPoint(64, 0.3) # alpha_channel_func.AddPoint(128, 0.5) alpha_channel_func.AddPoint(100, 1.0) alpha_channel_func.ClampingOn() color_func = vtk.vtkPiecewiseFunction() color_func.AddPoint(5, 0.3) color_func.AddPoint(25, 0.5) color_func.AddPoint(125, 0.7) color_func.AddPoint(255, 1.0) volume_property = vtk.vtkVolumeProperty() volume_property.SetColor(color_func) volume_property.SetInterpolationTypeToLinear() volume_property.SetScalarOpacity(alpha_channel_func) volume.SetProperty(volume_property) volume_ray_cast_func = vtk.vtkVolumeRayCastMIPFunction() volume_mapper.SetInputConnection(image_import.GetOutputPort()) volume_mapper.SetVolumeRayCastFunction(volume_ray_cast_func) # volume_mapper.SetSampleDistance(1) # volume_mapper.SetAutoAdjustSampleDistances(0) # volume_mapper.SetImageSampleDistance(1) volume.SetMapper(volume_mapper) ren = vtk.vtkRenderer() ren.AddVolume(volume) ren.SetBackground(0, 0, 0) renWin = vtk.vtkRenderWindow() renWin.SetSize(1024, 1024) renWin.AddRenderer(ren) renWin.Render() window_2_image = vtk.vtkWindowToImageFilter() window_2_image.SetInput(renWin) window_2_image.Update() png_writer = vtk.vtkPNGWriter() png_writer.SetFileName(dst + '%05d'%(i) + '.png') png_writer.SetInput(window_2_image.GetOutput()) png_writer.Write()
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 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 main(argv): if len(argv) < 2: print "usage:",argv[0]," data.nrrd data.cmap" exit(1) data_fn = argv[1] cmap_fn = argv[2] reader = vtk.vtkPNrrdReader() reader.SetFileName(data_fn) reader.Update() data = reader.GetOutput() # opacity function opacityFunction = vtk.vtkPiecewiseFunction() # color function colorFunction = vtk.vtkColorTransferFunction() cmap = open(cmap_fn, 'r') for line in cmap.readlines(): parts = line.split() value = float(parts[0]) r = float(parts[1]) g = float(parts[2]) b = float(parts[3]) a = float(parts[4]) opacityFunction.AddPoint(value, a) colorFunction.AddRGBPoint(value, r, g, b) # volume setup: volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(colorFunction) volumeProperty.SetScalarOpacity(opacityFunction) # composite function (using ray tracing) compositeFunction = vtk.vtkVolumeRayCastMIPFunction() volumeMapper = vtk.vtkVolumeRayCastMapper() volumeMapper.SetVolumeRayCastFunction(compositeFunction) volumeMapper.SetInput(data) # make the volume volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) # renderer renderer = vtk.vtkRenderer() renderWin = vtk.vtkRenderWindow() renderWin.AddRenderer(renderer) renderInteractor = vtk.vtkRenderWindowInteractor() renderInteractor.SetRenderWindow(renderWin) renderer.AddVolume(volume) renderer.SetBackground(0,0,0) renderWin.SetSize(400, 400) renderInteractor.Initialize() renderWin.Render() renderInteractor.Start()
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 createVolumeRender(File, ScalarList, ColorList, OpacList, PieceList): #Create the mappers volumeMapper = vtk.vtkGPUVolumeRayCastMapper() volumeMapper.SetInputConnection(File.GetOutputPort()) volumeMapper.SetBlendModeToComposite() #Create the color transfer function volumeCTF = vtk.vtkColorTransferFunction() volumeCTF.AddRGBPoint(ScalarList[0], ColorList[0][0], ColorList[0][1], ColorList[0][2]) volumeCTF.AddRGBPoint(ScalarList[1], ColorList[1][0], ColorList[1][1], ColorList[1][2]) volumeCTF.AddRGBPoint(ScalarList[2], ColorList[2][0], ColorList[2][1], ColorList[2][2]) volumeCTF.AddRGBPoint(ScalarList[3], ColorList[3][0], ColorList[3][1], ColorList[3][2]) #Create the piecewise function for opacity function volumeOTF = vtk.vtkPiecewiseFunction() volumeOTF.AddPoint(ScalarList[0], OpacList[0]) volumeOTF.AddPoint(ScalarList[1], OpacList[1]) volumeOTF.AddPoint(ScalarList[2], OpacList[2]) volumeOTF.AddPoint(ScalarList[3], OpacList[3]) #Create the piecewise function for internal opacity function volumeGOTF = vtk.vtkPiecewiseFunction() volumeGOTF.AddPoint(0, PieceList[0]) volumeGOTF.AddPoint(90, PieceList[1]) volumeGOTF.AddPoint(100, PieceList[2]) #Add all the function and ambient, diffuse and specular to the volume property volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(volumeCTF) volumeProperty.SetScalarOpacity(volumeOTF) volumeProperty.SetGradientOpacity(volumeGOTF) volumeProperty.SetInterpolationTypeToLinear() volumeProperty.ShadeOn() volumeProperty.SetAmbient(0.5) volumeProperty.SetDiffuse(0.5) volumeProperty.SetSpecular(0.5) #Create volume and set mapper and property to volume volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) #Return volume return volume
def volume_rendering(data, opacity, samp_dist=1.0, shade=True, diffuse=1.0, renderer=None): vmin,vmax = opacity.get_range() vrange = float(vtk.VTK_UNSIGNED_SHORT_MAX-1) crg0 = vrange/3.0 crg1 = vrange*2.0/3.0 scale = (crg1-crg0) / (vmax-vmin) shift = -vmin + crg0/scale clipped = data + shift clipped *= scale np.clip(clipped.data, 0, vrange, out=clipped.data) image = RegData_to_vtkImageData(clipped, dtype=np.uint16) ctf = opacity.get_vtkColorTransferFunction(scale, shift) otf = opacity.get_vtkPiecewiseFunction(scale, shift) volume = vtk.vtkVolume() vol_prop = vtk.vtkVolumeProperty() volume.SetProperty(vol_prop) vol_prop.SetColor(ctf) vol_prop.SetScalarOpacity(otf) vol_prop.SetInterpolationTypeToLinear() if shade: vol_prop.ShadeOn() else: vol_prop.ShadeOff() # #vol_prop.SetAmbient(ambient) # no effect ! vol_prop.SetDiffuse(diffuse) #vol_prop.SetSpecular(0) vol_map = vtkGetVolumeRayCastMapper() volume.SetMapper(vol_map) vtkConnectDataInput(image, vol_map) vol_map.SetSampleDistance(samp_dist*np.min(data.dx())) if renderer is not None: renderer.AddVolume(volume) # ctfbar = opacity.get_vtkLookupTable() return volume, ctfbar
def _update_region(self, org_x, org_y, org_z, update_size): ''' :param pa, pb, pc: Requires tuple format of 3 coordinates TCL Update region inside the box constructed by pa, pb and pc ''' for i in range(org_x, org_x + update_size): for j in range(org_y, org_y + update_size): for k in range(org_z, org_z + update_size): self.reader.GetOutput().SetScalarComponentFromFloat(i, j, k, 0, 255) # self.voi = vtk.vtkExtractVOI() # self.voi.SetInputConnection(self.reader.GetOutputPort()) # self.voi.SetVOI(org_x, org_x + update_size, # org_y, org_y + update_size, # org_z, org_z + update_size) # self.voi.Update() self.regionMC = vtk.vtkImageMarchingCubes() self.regionMC.SetInputConnection(self.reader.GetOutputPort()) self.regionMC.SetValue(0, self.ui.mc_spin.value()) self.regionMC.Update() # self.mc.SetInputConnection(self.reader.GetOutputPort()) # self.mc.Update() # self.appendData = vtk.vtkAppendPolyData() # self.appendData.AddInputData(self.mc.GetOutput()) # self.appendData.AddInputData(self.regionMC.GetOutput()) # self.mapper.SetInputConnection(self.appendData.GetOutputPort()) self.mapper2 = vtk.vtkPolyDataMapper() self.mapper2.SetInputConnection(self.regionMC.GetOutputPort()) self.volumeMapper = vtk.vtkVolumeMapper() self.volumeMapper.SetCropping(1) self.volumeMapper.SetCroppingRegionPlanes(org_x, org_x + update_size, org_y, org_y + update_size, org_z, org_z + update_size) self.volumeMapper.SetCroppingRegionFlags(0x0002000) self.volume = vtk.vtkVolume() self.volume.SetMapper(self.volumeMapper) self.upperRender = vtk.vtkRenderer() self.upperRender.AddVolume(self.volume) self.upperRender.SetBackground(0.9, 0.9, 0.9) self.upperRender.SetLayer(2) self.vtk3DWidget.GetRenderWindow().AddRenderer(self.upperRender)
def __init__(self, parent): wx.SplitterWindow.__init__(self, parent) # # setup the control panel # self.controlPanel = wx.lib.scrolledpanel.ScrolledPanel( self ) vBox = wx.BoxSizer( wx.VERTICAL ) self.mode = wx.RadioBox( self.controlPanel, label="Mode", choices=["2D", "3D"] ) vBox.Add( self.mode, 0, wx.EXPAND ) self.colorAndOpacityEditor = WrapITKColorAndOpacityEditor( self.controlPanel ) vBox.Add( self.colorAndOpacityEditor, 0, wx.EXPAND ) self.controlPanel.SetSizer( vBox ) self.controlPanel.SetupScrolling() # # setup the render window # from vtk.wx.wxVTKRenderWindowInteractor import wxVTKRenderWindowInteractor from vtk import vtkRenderer, vtkVolumeTextureMapper2D, vtkVolumeProperty, vtkVolume self.rendererWindow = wxVTKRenderWindowInteractor(self, -1) self.renderer = vtkRenderer() self.rendererWindow.GetRenderWindow().AddRenderer(self.renderer) self.volumeMapper = vtkVolumeTextureMapper2D() self.volume = vtkVolume() self.volumeProperty = vtkVolumeProperty() self.volumeProperty.SetScalarOpacity( self.colorAndOpacityEditor.opacityTransferFunction ) self.volumeProperty.SetColor( self.colorAndOpacityEditor.colorTransferFunction ) self.volume.SetMapper( self.volumeMapper ) self.volume.SetProperty( self.volumeProperty ) self.renderer.AddVolume( self.volume ) self.outline = None self.outlineMapper = None self.outlineActor = None # fill the split pane self.SplitVertically( self.controlPanel, self.rendererWindow ) # avoid loosing on panel or the other self.SetMinimumPaneSize( 1 ) # to manage update event correctly self.updateInProgress = False
def __init__(self, reader): logging.info("begin Init ViewerVR") self._reader = reader #init VolumeRayCastMapper self._volumeMapper = vtk.vtkGPUVolumeRayCastMapper() self._volumeMapper.SetSampleDistance(self._volumeMapper.GetSampleDistance()/2) self._volumeMapper.SetBlendModeToComposite() self._volumeMapper.SetInputConnection(reader.GetOutputPort()) self._volumeColor = vtk.vtkColorTransferFunction() self._volumeScalarOpacity = vtk.vtkPiecewiseFunction() self._volumeGradientOpacity = vtk.vtkPiecewiseFunction() self._volumeProperty = vtk.vtkVolumeProperty() self._volume = vtk.vtkVolume() self._render = vtk.vtkRenderer() logging.info("End Init ViewerVR")
def open_another_volume_and_tf(self, volume_filename, tf_filename): self.ui.setWindowTitle(volume_filename) opacityTransferFunction, colorTransferFunction = load_transfer_function(tf_filename) plot_tf(opacityTransferFunction, colorTransferFunction) # Create the reader for the data reader = vtk.vtkMetaImageReader() reader.SetFileName(volume_filename) # store the filenames and vtk reader for later use self.volume_filename = volume_filename self.tf_filename = tf_filename self.reader = reader # The property describes how the data will look volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(colorTransferFunction) volumeProperty.SetScalarOpacity(opacityTransferFunction) volumeProperty.ShadeOn() volumeProperty.SetInterpolationTypeToLinear() # for vtkGPUVolumeRayCastMapper volumeMapper = vtk.vtkGPUVolumeRayCastMapper() 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) self.ren = vtk.vtkRenderer() self.ren.AddVolume(volume) self.ren.SetBackground(1, 1, 1) window = self.vtkWidget.GetRenderWindow() collection = window.GetRenderers() item = collection.GetNextItem() while item is not None: window.RemoveRenderer(item) item = collection.GetNextItem() window.AddRenderer(self.ren) window.Render() self.iren.Initialize()
def setupImageProcessingPipeline(self): # Caster self.caster = vtk.vtkImageShiftScale() self.caster.SetOutputScalarTypeToUnsignedChar() self.caster.ClampOverflowOn() # Setup composite ray cast function self.rayCastFunction = vtk.vtkVolumeRayCastCompositeFunction() # Add to mapper self.volumeMapper = vtk.vtkVolumeRayCastMapper() self.volumeMapper.SetInputConnection(self.caster.GetOutputPort()) self.volumeMapper.SetVolumeRayCastFunction(self.rayCastFunction) # The color transfer function maps voxel intensities to colors. self.volumeColor = vtk.vtkColorTransferFunction() self.volumeColor.AddRGBPoint(0, 0.0, 0.0, 0.0) self.volumeColor.AddRGBPoint(255, 1.0, 1.0, 1.0) # The opacity transfer function (tissue opacity) self.volumeScalarOpacity = vtk.vtkPiecewiseFunction() self.volumeScalarOpacity.AddPoint(0, 0.00) self.volumeScalarOpacity.AddPoint(255, 1) # The gradient opacity function (decrease opacity in flat regions) self.volumeGradientOpacity = vtk.vtkPiecewiseFunction() self.volumeGradientOpacity.AddPoint(0, 0.0) self.volumeGradientOpacity.AddPoint(90, 0.5) self.volumeGradientOpacity.AddPoint(100, 1.0) # Property self.volumeProperty = vtk.vtkVolumeProperty() self.volumeProperty.SetColor(self.volumeColor) self.volumeProperty.SetScalarOpacity(self.volumeScalarOpacity) self.volumeProperty.SetGradientOpacity(self.volumeGradientOpacity) self.volumeProperty.SetInterpolationTypeToLinear() self.volumeProperty.ShadeOn() self.volumeProperty.SetAmbient(1) self.volumeProperty.SetDiffuse(1) self.volumeProperty.SetSpecular(0.2) # Prop self.volume = vtk.vtkVolume() self.volume.SetMapper(self.volumeMapper) self.volume.SetProperty(self.volumeProperty)
def opImplement(self): opacity = vtk.vtkPiecewiseFunction(); #x is scaler value , y is opacity value opacity.AddPoint(IMAGEOUT,0.0); opacity.AddPoint(IMAGEIN ,1.0); #x is scaler value , other is rgb value color = vtk.vtkColorTransferFunction(); color.AddRGBPoint(IMAGEIN ,255.0/255.0,255.0/255.0,255.0/255.0); volumeProperty = vtk.vtkVolumeProperty(); volumeProperty.ShadeOn(); volumeProperty.SetScalarOpacity(opacity) volumeProperty.SetColor(color); mapper = vtk.vtkSmartVolumeMapper(); mapper.SetInputData(self.data); volume = vtk.vtkVolume(); volume.SetMapper(mapper); volume.SetProperty(volumeProperty); return volume;
def render_cloud(self): self.ren.RemoveVolume(self.cloud_volume) if not self.config["CLOUD"][0]: return data_path = compose_file_name(self.base_dir, "/CLOUD", self.data_folders["CLOUD"], self.time_step) reader = vtk.vtkXMLImageDataReader() reader.SetFileName(data_path) reader.Update() spacing = reader.GetOutput().GetSpacing() reader.GetOutput().SetSpacing(spacing[0], spacing[1], spacing[2] * 30) myrange = reader.GetOutput().GetPointData().GetScalars().GetRange() opacityTransferFunction = vtk.vtkPiecewiseFunction() opacityTransferFunction.AddPoint(myrange[0], 0.0) opacityTransferFunction.AddPoint(myrange[1], 0.1) color = vtk.vtkColorTransferFunction() # Blue color.AddRGBPoint(myrange[0], 0.8, 0.8, 0.8) color.AddRGBPoint((myrange[0] + myrange[1]) / 2, 1., 1., 1) color.AddRGBPoint(myrange[1], 0.8, 0.8, 0.8) volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(color) volumeProperty.SetScalarOpacity(opacityTransferFunction) volumeProperty.SetInterpolationTypeToLinear() volumeProperty.ShadeOff() volumeMapper = vtk.vtkSmartVolumeMapper() volumeMapper.SetBlendModeToComposite() volumeMapper.SetAutoAdjustSampleDistances(0) volumeMapper.SetSampleDistance(0.5) 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) self.cloud_volume = volume self.ren.AddVolume(volume)
def __init__(self, parent): super(NeuroGLWidget, self).__init__(parent) self.iren = self.GetRenderWindow().GetInteractor() self.volume = vtk.vtkVolume() self.GetRenderWindow().SetNumberOfLayers(2) self.ren = [] for i in range(2): self.ren.append(vtk.vtkRenderer()) self.ren[i].SetLayer(i) self.GetRenderWindow().AddRenderer(self.ren[i]) #self.ren[i].GetActiveCamera().ParallelProjectionOn() self.ren[1].SetActiveCamera(self.ren[0].GetActiveCamera()) self.ren[0].GetActiveCamera().ParallelProjectionOn() self.style = InteractorStyle.MyInteractorStyle() self.style.SetInteractor(self.iren) self.style.SetRenderers(self.ren) #self.style.SetRendererCollection(self.GetRenderWindow().GetRenderers()) self.style.AutoAdjustCameraClippingRangeOff() self.iren.SetInteractorStyle(self.style) self.style.SetGLWidgetHandle(self) self.transform = vtk.vtkTransform() self.transform.Identity() self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu) self.customContextMenuRequested.connect(self.onContextMenu) self.volumeSize = [0, 0, 0] #d,h,w self.volumeRes = [1, 1, 1] #d,h,w self.outLine = vtk.vtkActor() self.axes = vtk.vtkAxesActor() self.marker = vtk.vtkOrientationMarkerWidget() self.marker.SetOutlineColor(1, 1, 1) self.marker.SetOrientationMarker(self.axes) self.marker.SetInteractor(self.GetRenderWindow().GetInteractor()) self.marker.SetViewport(0, 0, 0.1, 0.1) self.marker.SetEnabled(True) self.marker.InteractiveOn() self.picker = vtk.vtkCellPicker() self.picker.SetTolerance(0.005) self.importData = vtk.vtkImageData() self.colorFunc = vtk.vtkColorTransferFunction() self.planeWidgetZ = vtkImagePlaneWidget() self.planeWidgetZ.SetSliceIndex(0) self.planeMode = False self.CreateSliderWidget()
def makeVolumeRenderingPipeline(in_volume): dataImporter = vtk.vtkImageImport() if in_volume.dtype == numpy.uint8: dataImporter.SetDataScalarTypeToUnsignedChar() elif in_volume.dtype == numpy.uint16: dataImporter.SetDataScalarTypeToUnsignedShort() elif in_volume.dtype == numpy.int32: dataImporter.SetDataScalarTypeToInt() elif in_volume.dtype == numpy.int16: dataImporter.SetDataScalarTypeToShort() else: raise RuntimeError("unknown data type %r of volume" % (in_volume.dtype, )) dataImporter.SetImportVoidPointer(in_volume, len(in_volume)) dataImporter.SetNumberOfScalarComponents(1) extent = [ 0, in_volume.shape[2] - 1, 0, in_volume.shape[1] - 1, 0, in_volume.shape[0] - 1 ] dataImporter.SetDataExtent(*extent) dataImporter.SetWholeExtent(*extent) alphaChannelFunc = vtk.vtkPiecewiseFunction() alphaChannelFunc.AddPoint(0, 0.0) for i in range(1, NOBJECTS): alphaChannelFunc.AddPoint(i, 1.0) colorFunc = vtk.vtkColorTransferFunction() volumeMapper = vtk.vtkSmartVolumeMapper() volumeMapper.SetInputConnection(dataImporter.GetOutputPort()) volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(colorFunc) volumeProperty.SetScalarOpacity(alphaChannelFunc) volumeProperty.ShadeOn() volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) return dataImporter, colorFunc, volume, volumeMapper
def createVolume(image): ''' create volume of image - image must be a typical irm image with gray values comprised between 0 and 255 ''' # Create transfer mapping scalar value to opacity opacityTransferFunction = vtk.vtkPiecewiseFunction() opacityTransferFunction.AddPoint(0, 0.0) opacityTransferFunction.AddPoint(10.0, 0.0) opacityTransferFunction.AddPoint(40.0, 1.0) opacityTransferFunction.AddPoint(60, 1.0) opacityTransferFunction.AddPoint(200, 0.0) opacityTransferFunction.AddPoint(255, 0.0) # 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() volumeProperty.SetDiffuse(0.7) volumeProperty.SetSpecular(0.5) volumeProperty.SetSpecularPower(70.0) # mapper volumeMapper=None if 1: compositeFunction = vtk.vtkVolumeRayCastCompositeFunction() volumeMapper = vtk.vtkVolumeRayCastMapper() volumeMapper.SetVolumeRayCastFunction(compositeFunction) volumeMapper.SetInput(image) else: volumeMapper = vtk.vtkVolumeTextureMapper2D() volumeMapper.SetInput(image) # volume volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) return volume, volumeMapper
def initWindow(self, path): self.vcolor = [[0, 0.0, 0.0, 0.0], [500, 0.6, 0.5, 0.3], [1000, 0.9, 0.9, 0.3], [1150, 1.0, 1.0, 0.9]] self.vOpacity = [[0, 0], [500, 0.55], [1000, 0.55], [1150, 0.85]] self.gOpacity = [[0, 0.0], [90, 0.8], [100, 1.0]] self.source = vtk.vtkDICOMImageReader() self.source.SetDirectoryName(path) self.source.Update() self.volumcolors = vtk.vtkColorTransferFunction() self.setOpacityColor(self.vcolor) self.volumScalarOpacity = vtk.vtkPiecewiseFunction() self.setOpacityValue(self.vOpacity) self.volumGradientOpacity = vtk.vtkPiecewiseFunction() self.setGradientOpacity(self.gOpacity) self.volumMapper = vtk.vtkGPUVolumeRayCastMapper() self.volumMapper.SetInputConnection(self.source.GetOutputPort()) self.volumeProperty = vtk.vtkVolumeProperty() self.volumeProperty.SetColor(self.volumcolors) self.volumeProperty.SetScalarOpacity(self.volumScalarOpacity) self.volumeProperty.SetGradientOpacity(self.volumGradientOpacity) self.volumeProperty.SetInterpolationTypeToLinear() self.volumeProperty.ShadeOn() self.volumeProperty.SetAmbient(0.4) self.volumeProperty.SetDiffuse(0.6) self.volumeProperty.SetSpecular(0.2) self.volume = vtk.vtkVolume() self.volume.SetMapper(self.volumMapper) self.volume.SetProperty(self.volumeProperty) self.colors = vtk.vtkNamedColors() self.colors.SetColor("BackGroundcolors", [255, 255, 255, 255]) self.ren.SetBackground(self.colors.GetColor3d("BackGroundcolors")) self.ren.AddVolume(self.volume) self.iren.Initialize() pass
def getVolumeVolume(fname, rangelow, rangehigh, opacitylow, opacityhigh, color_transfer_func): volreader = vtk.vtkStructuredPointsReader() volreader.SetFileName(fname) volreader.Update() volrange = (rangelow, rangehigh) imageShift = vtk.vtkImageShiftScale() imageShift.SetShift(-1*volrange[0]) imageShift.SetScale(255.0/(volrange[1]-volrange[0])) imageShift.SetOutputScalarTypeToUnsignedChar() imageShift.SetInput(volreader.GetOutput()) extractVol = vtk.vtkExtractVOI() if (options.xmax > -1 or options.ymax > -1 or options.zmax > -1): if ( options.verbose): print " Extracting subvolume ..." extractVol.SetVOI( options.zmin, options.zmax, options.ymin, options.ymax, options.xmin, options.xmax ) extractVol.SetInput(imageShift.GetOutput()) volume_mapper = vtk.vtkVolumeRayCastMapper() volume_mapper.SetInput(extractVol.GetOutput()) composite_function = vtk.vtkVolumeRayCastCompositeFunction() volume_mapper.SetVolumeRayCastFunction(composite_function) # Setting opacity functions opacity_transfer_func = vtk.vtkPiecewiseFunction() opacity_transfer_func.AddPoint( 0, opacitylow ) opacity_transfer_func.AddPoint( 118, opacityhigh ) opacity_transfer_func.AddPoint( 138, opacityhigh ) opacity_transfer_func.AddPoint( 255, opacitylow ) # Adding colour and opacity to properties volume_properties = vtk.vtkVolumeProperty() volume_properties.SetColor( color_transfer_func ) volume_properties.SetScalarOpacity( opacity_transfer_func ) # Adding properties to volume volume = vtk.vtkVolume() volume.SetMapper( volume_mapper ) volume.SetProperty( volume_properties ) return ( volreader, volume )
def showVolume(self, vtkImageData, preserveState): '''Shows volume of image.''' producer = vtk.vtkTrivialProducer() producer.SetOutput(vtkImageData) flip = vtk.vtkImageFlip() # flip over y axis flip.SetFilteredAxis(1) flip.SetInputConnection(producer.GetOutputPort()) mapper = vtk.vtkSmartVolumeMapper() mapper.SetInputConnection(flip.GetOutputPort()) scalarRange = vtkImageData.GetScalarRange() opacity = vtk.vtkPiecewiseFunction() opacity.AddPoint(scalarRange[0], 0.2) opacity.AddPoint(scalarRange[1], 0.9) color = vtk.vtkColorTransferFunction() color.AddRGBPoint(scalarRange[0], 0, 0, 0) color.AddRGBPoint(scalarRange[1], 1, 1, 1) prop = vtk.vtkVolumeProperty() prop.ShadeOff() prop.SetInterpolationType(vtk.VTK_LINEAR_INTERPOLATION) prop.SetColor(color) prop.SetScalarOpacity(opacity) # save tubes and property if preserving state if preserveState and self.volume: prop = self.volume.GetProperty() self.volumeRenderer.RemoveViewProp(self.volume) else: self.volumeRenderer.RemoveAllViewProps() self.volume = vtk.vtkVolume() self.volume.SetMapper(mapper) self.volume.SetProperty(prop) self.volumeRenderer.AddViewProp(self.volume) self.volumeRenderer.ResetCamera()
def volumeProperty(reader, opacityTransferFunction, colorTransferFunction): volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(colorTransferFunction) volumeProperty.SetScalarOpacity(opacityTransferFunction) volumeProperty.ShadeOn() volumeProperty.SetSpecular(0.3) volumeProperty.SetInterpolationTypeToLinear() MIPFunction = vtk.vtkVolumeRayCastMIPFunction() volumeMapper = vtk.vtkVolumeRayCastMapper() volumeMapper.SetSampleDistance(1.0) volumeMapper.SetInput(reader.GetOutput()) volumeMapper.SetVolumeRayCastFunction(MIPFunction) volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) volume.RotateX(-90) return volume
def volren(self): filename = self.params.colour_file self.volreader = vtk.vtkStructuredPointsReader() self.volreader.SetFileName(filename) self.volreader.Update() #self.volreader.GetOutput().SetOrigin(1,1,1) #volrange=self.volreader.GetOutput().GetScalarRange() volrange = (-1.0, 1.0) imageShift = vtk.vtkImageShiftScale() imageShift.SetShift(-1 * volrange[0]) imageShift.SetScale(255.0 / (volrange[1] - volrange[0])) imageShift.SetOutputScalarTypeToUnsignedChar() imageShift.SetInput(self.volreader.GetOutput()) volume_mapper = vtk.vtkVolumeRayCastMapper() volume_mapper.SetInput(imageShift.GetOutput()) composite_function = vtk.vtkVolumeRayCastCompositeFunction() volume_mapper.SetVolumeRayCastFunction(composite_function) color_transfer_func = vtk.vtkColorTransferFunction() color_transfer_func.AddRGBPoint(0, 0.0, 0.0, 1.0) color_transfer_func.AddRGBPoint((255 / 2) - 10, 0.0, 0.0, 1.0) color_transfer_func.AddRGBPoint((255 / 2) + 10, 1.0, 0.0, 0.0) color_transfer_func.AddRGBPoint(255, 1.0, 0.0, 0.0) opacity_transfer_func = vtk.vtkPiecewiseFunction() opacity_transfer_func.AddPoint(0, self.params.volumeopacitylow) opacity_transfer_func.AddPoint(118, self.params.volumeopacityhigh) opacity_transfer_func.AddPoint(138, self.params.volumeopacityhigh) opacity_transfer_func.AddPoint(255, self.params.volumeopacitylow) volume_properties = vtk.vtkVolumeProperty() volume_properties.SetColor(color_transfer_func) volume_properties.SetScalarOpacity(opacity_transfer_func) volume = vtk.vtkVolume() volume.SetMapper(volume_mapper) volume.SetProperty(volume_properties) self.ren.AddVolume(volume)
def DisplayVolume(self, vtk_image_data): #Save vtk_image_data as global param gldefIndex = gldef.GetGlobalDefLen() gldef.SetValue(gldefIndex, vtk_image_data) #VolumeProperty: Opacity vtk_piecewisefunc = vtk.vtkPiecewiseFunction() vtk_piecewisefunc.AddPoint(20, 0.0) vtk_piecewisefunc.AddPoint(255, 0.2) #VolumeProperty: Color vtk_colortransfunc = vtk.vtkColorTransferFunction() vtk_colortransfunc.AddRGBPoint(0.0, 0.0, 0.5, 0.0) vtk_colortransfunc.AddRGBPoint(60.0, 1.0, 0.0, 0.0) vtk_colortransfunc.AddRGBPoint(128.0, 0.2, 0.1, 0.9) vtk_colortransfunc.AddRGBPoint(196.0, 0.27, 0.21, 0.1) vtk_colortransfunc.AddRGBPoint(255.0, 0.8, 0.8, 0.8) #VolumeProperty vtk_volproperty = vtk.vtkVolumeProperty() vtk_volproperty.SetColor(vtk_colortransfunc) vtk_volproperty.SetScalarOpacity(vtk_piecewisefunc) vtk_volproperty.ShadeOn() vtk_volproperty.SetInterpolationTypeToLinear() vtk_volproperty.SetAmbient(0.2) vtk_volproperty.SetDiffuse(0.9) vtk_volproperty.SetSpecular(0.2) vtk_volproperty.SetSpecularPower(10) self.vtk_volume_mapper.SetInputData(vtk_image_data) vtk_volume = vtk.vtkVolume() vtk_volume.SetMapper(self.vtk_volume_mapper) vtk_volume.SetProperty(vtk_volproperty) self.vtk_renderer.RemoveAllViewProps() #Delete All Images self.vtk_renderer.AddVolume(vtk_volume) self.vtk_renderer.ResetCamera() self.vtk_render_win.Render() pass
def render_volume_data(self, vtk_img_data): # Create transfer mapping scalar value to opacity opacity_transfer_function = vtk.vtkPiecewiseFunction() opacity_transfer_function.AddPoint(0, 0.0) opacity_transfer_function.AddPoint(50, 0.0) opacity_transfer_function.AddPoint(100, 0.8) opacity_transfer_function.AddPoint(1200, 0.8) # Create transfer mapping scalar value to color color_transfer_function = vtk.vtkColorTransferFunction() color_transfer_function.AddRGBPoint(0, 0.0, 0.0, 0.0) color_transfer_function.AddRGBPoint(50, 0.0, 0.0, 0.0) color_transfer_function.AddRGBPoint(100, 1.0, 0.0, 0.0) color_transfer_function.AddRGBPoint(1200, 1.0, 0.0, 0.0) # The property describes how the data will look volume_property = vtk.vtkVolumeProperty() volume_property.SetColor(color_transfer_function) volume_property.SetScalarOpacity(opacity_transfer_function) volume_property.ShadeOff() volume_property.SetInterpolationTypeToLinear() # The mapper / ray cast function know how to render the data compositeFunction = vtk.vtkVolumeRayCastCompositeFunction() volume_mapper = vtk.vtkVolumeRayCastMapper() volume_mapper.SetVolumeRayCastFunction(compositeFunction) if vtk.VTK_MAJOR_VERSION <= 5: volume_mapper.SetInput(vtk_img_data) else: volume_mapper.SetInputData(vtk_img_data) volume_mapper.SetBlendModeToMaximumIntensity() # The volume holds the mapper and the property and # can be used to position/orient the volume volume = vtk.vtkVolume() volume.SetMapper(volume_mapper) volume.SetProperty(volume_property) self.ren.AddVolume(volume) self.ren.ResetCamera() self.iren.Initialize()
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 makeVolumeRenderingPipeline(in_volume): dataImporter = vtk.vtkImageImport() if in_volume.dtype == numpy.uint8: dataImporter.SetDataScalarTypeToUnsignedChar() elif in_volume.dtype == numpy.uint16: dataImporter.SetDataScalarTypeToUnsignedShort() elif in_volume.dtype == numpy.int32: dataImporter.SetDataScalarTypeToInt() elif in_volume.dtype == numpy.int16: dataImporter.SetDataScalarTypeToShort() else: raise RuntimeError("unknown data type %r of volume" % (in_volume.dtype,)) dataImporter.SetImportVoidPointer(in_volume, len(in_volume)) dataImporter.SetNumberOfScalarComponents(1) extent = [0, in_volume.shape[2]-1, 0, in_volume.shape[1]-1, 0, in_volume.shape[0]-1] dataImporter.SetDataExtent(*extent) dataImporter.SetWholeExtent(*extent) alphaChannelFunc = vtk.vtkPiecewiseFunction() alphaChannelFunc.AddPoint(0, 0.0) for i in range(1, NOBJECTS): alphaChannelFunc.AddPoint(i, 1.0) colorFunc = vtk.vtkColorTransferFunction() volumeMapper = vtk.vtkSmartVolumeMapper() volumeMapper.SetInputConnection(dataImporter.GetOutputPort()) volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(colorFunc) volumeProperty.SetScalarOpacity(alphaChannelFunc) volumeProperty.ShadeOn() volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) return dataImporter, colorFunc, volume, volumeMapper
def volumeRender(self, img, tf=[], spacing=[1.0, 1.0, 1.0]): importer = self.numpy2VTK(img, spacing) # Transfer Functions opacity_tf = vtk.vtkPiecewiseFunction() color_tf = vtk.vtkColorTransferFunction() if len(tf) == 0: tf.append([img.min(), 0, 0, 0, 0]) tf.append([img.max(), 1, 1, 1, 1]) for p in tf: color_tf.AddRGBPoint(p[0], p[1], p[2], p[3]) opacity_tf.AddPoint(p[0], p[4]) # working on the GPU volMapper = vtk.vtkGPUVolumeRayCastMapper() volMapper.SetInputConnection(importer.GetOutputPort()) # The property describes how the data will look volProperty = vtk.vtkVolumeProperty() volProperty.SetColor(color_tf) volProperty.SetScalarOpacity(opacity_tf) volProperty.ShadeOn() volProperty.SetInterpolationTypeToLinear() vol = vtk.vtkVolume() vol.SetMapper(volMapper) vol.SetProperty(volProperty) return [vol] # if __name__ == "__main__": # app = QApplication(sys.argv) # # window = dicomWidget() # print(window.getInformation()) # # sys.exit(app.exec_())
def createVlume(polyData, colorFunc, alphaChannelFunc, volumGradientOpacity, spacings, position): data_matrix = polyData data_matrix = np.rot90(data_matrix, 1) data_matrix = data_matrix.astype(np.uint8) xSize, ySize, zSize = data_matrix.shape dataImporter = vtk.vtkImageImport() data_string = data_matrix.tostring() dataImporter.CopyImportVoidPointer(data_string, len(data_string)) dataImporter.SetDataScalarTypeToUnsignedChar() dataImporter.SetNumberOfScalarComponents(1) dataImporter.SetDataExtent(0, xSize - 1, 0, ySize - 1, 0, zSize - 1) dataImporter.SetWholeExtent(0, xSize - 1, 0, ySize - 1, 0, zSize - 1) dataImporter.SetDataExtentToWholeExtent() volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(colorFunc) volumeProperty.SetScalarOpacity(alphaChannelFunc) volumeProperty.SetGradientOpacity(volumGradientOpacity) volumeProperty.ShadeOn() volumeProperty.SetAmbient(0.4) volumeProperty.SetDiffuse(0.6) volumeProperty.SetSpecular(0.2) volumeMapper = vtk.vtkGPUVolumeRayCastMapper() volumeMapper.SetInputConnection(dataImporter.GetOutputPort()) volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) transform = vtk.vtkTransform() transform.Scale(spacings) transform.Translate(position) volume.SetUserTransform(transform) return volume
def __init__(self, data_dir, opacityL, opacityH): # Read the data filename = "inclusions_all.vti" vSource = vtk.vtkXMLImageDataReader() vSource.SetFileName(filename) vSource.Update() #Create a mapper and actor opacityTransferFunction = vtk.vtkPiecewiseFunction() opacityTransferFunction.AddPoint(opacityL, 0.0) opacityTransferFunction.AddPoint(opacityH, 0.8) colorTransferFunction = vtk.vtkColorTransferFunction() colorTransferFunction.AddRGBPoint(0.0, 0.0, 0.0, 0.0) colorTransferFunction.AddRGBPoint(64.0, 1.0, 0.2, 0.4) colorTransferFunction.AddRGBPoint(128.0, 0.0, 0.0, 1.0) colorTransferFunction.AddRGBPoint(192.0, 0.0, 1.0, 0.0) volumeProperty = vtk.vtkVolumeProperty() #volumeProperty.SetColor(colorTransferFunction) #volumeProperty.SetGradientOpacity(gradientTransferFunction) volumeProperty.SetScalarOpacity(opacityTransferFunction) #volumeProperty.ShadeOn() volumeProperty.SetInterpolationTypeToLinear() volumeProperty.SetAmbient(1.0) volumeProperty.SetDiffuse(0.7) volumeProperty.SetSpecular(0.5) volumeMapper = vtk.vtkSmartVolumeMapper() volumeMapper.SetInputConnection(vSource.GetOutputPort()) #volumeMapper.CroppingOn() volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) volume.Update() #renderer.AddVolume(volume) #self.b0 = b0 self.volume = volume self.vSource = vSource
def loadImage(self, image_data): r = image_data.GetScalarRange() n = image_data.GetNumberOfScalarComponents() print(r) print(n) # Create transfer mapping scalar value to opacity. opacityTransferFunction = vtk.vtkPiecewiseFunction() opacityTransferFunction.AddPoint(0, 0.0) opacityTransferFunction.AddPoint(255, 1.0) # Create transfer mapping scalar value to color. colorTransferFunction = vtk.vtkColorTransferFunction() colorTransferFunction.AddRGBPoint(0.0, 0.0, 0.0, 0.0) colorTransferFunction.AddRGBPoint(10.0, 0.1, 0.1, 0.1) colorTransferFunction.AddRGBPoint(255.0, 1.0, 1.0, 1.0) # The property describes how the data will look. volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(colorTransferFunction) volumeProperty.SetScalarOpacity(opacityTransferFunction) volumeProperty.ShadeOn() volumeProperty.SetInterpolationTypeToLinear() # The mapper / ray cast function know how to render the data. volumeMapper = vtk.vtkGPUVolumeRayCastMapper() volumeMapper.SetInputData(image_data) volumeMapper.SetBlendModeToComposite() volumeMapper.Update() # 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) self.ren.AddVolume(volume) self.ren.ResetCameraClippingRange() self.ren.ResetCamera() self.renWin().Render()
def __init__(self, cmData, reslice=None): self.cmData = cmData self._min = 0 self._max = 255 self.dataImport = vtk.vtkImageImport() self.dataImport.SetDataScalarTypeToUnsignedChar() self.dataImport.SetNumberOfScalarComponents(1) self.alphaFunc = vtk.vtkPiecewiseFunction() self.colorFunc = vtk.vtkColorTransferFunction() self.setupColorFunc() self.prop = vtk.vtkVolumeProperty() self.prop.SetColor(self.colorFunc) self.prop.SetScalarOpacity(self.alphaFunc) self.mapper = vtk.vtkSmartVolumeMapper() self.mapper.SetBlendModeToMaximumIntensity() if reslice is not None: reslice.SetInputConnection(self.dataImport.GetOutputPort()) self.mapper.SetInputConnection(reslice.GetOutputPort()) else: self.mapper.SetInputConnection(self.dataImport.GetOutputPort()) self.volume = vtk.vtkVolume() self.volume.SetMapper(self.mapper) self.volume.SetProperty(self.prop)