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 test(): reader = vtk.vtkXMLImageDataReader() reader.SetFileName("C:/Users/Asus/Dropbox/2017-18/ScientificCompAndVisualization/Semana2/SS_2017-master/SS_2017-master/data/wind_image.vti") volume = vtk.vtkVolume() #mapper = vtk.vtkFixedPointVolumeRayCastMapper() mapper = vtk.vtkGPUVolumeRayCastMapper() mapper.SetBlendModeToMinimumIntensity(); mapper.SetSampleDistance(0.1) mapper.SetAutoAdjustSampleDistances(0) ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() iRen = vtk.vtkRenderWindowInteractor() # Set connections mapper.SetInputConnection(reader.GetOutputPort()); volume.SetMapper(mapper) ren.AddViewProp(volume) renWin.AddRenderer(ren) iRen.SetRenderWindow(renWin) # Define opacity transfer function and color functions opacityTransferFunction = vtk.vtkPiecewiseFunction() opacityTransferFunction.AddPoint(0.1, 1.0) opacityTransferFunction.AddPoint(14, 0.5) # Create transfer mapping scalar value to color colorTransferFunction = vtk.vtkColorTransferFunction() colorTransferFunction.AddRGBPoint(1.5, 1.0, 1.0, 0.0) colorTransferFunction.AddRGBPoint(0.5, 1.0, 0.0, 0.0) colorTransferFunction.AddRGBPoint(3.0, 0.0, 1.0, 0.0) colorTransferFunction.AddRGBPoint(6.0, 0.0, 1.0, 1.0) colorTransferFunction.AddRGBPoint(14.0, 0.0, 0.0, 1.0) # Now set the opacity and the color volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(colorTransferFunction) volumeProperty.SetScalarOpacity(opacityTransferFunction) volumeProperty.ShadeOff() volumeProperty.SetInterpolationTypeToLinear() volume.SetProperty(volumeProperty) renderer = vtk.vtkRenderer() renderer.SetBackground(0.5, 0.5, 0.5) renderer.AddVolume(volume) renderer.ResetCamera() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renderWindow.SetSize(500, 500) renderWindow.Render() iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renderWindow) iren.Start()
def reader(self,filename,r,g,b): self.reader_src = vtk.vtkNIFTIImageReader() self.reader_src.SetFileName(filename) self.vol_map = vtk.vtkGPUVolumeRayCastMapper() self.vol_map.SetInputConnection(self.reader_src.GetOutputPort()) # transfer functions for color and opacity self.funColor = vtk.vtkColorTransferFunction() self.funColor.AddRGBPoint(0, 0., 0., 0.) self.funColor.AddRGBPoint(1, r, g, b) # for the T1 if filename == self.filename1: self.funAlpha = vtk.vtkPiecewiseFunction() self.funAlpha.AddPoint(0, 0.) self.funAlpha.AddPoint(256, .003) # for the masks else: self.funAlpha = vtk.vtkPiecewiseFunction() self.funAlpha.AddPoint(0, 0.) self.funAlpha.AddPoint(1, 0.00003) self.volProp = vtk.vtkVolumeProperty() self.volProp.SetColor(0, self.funColor) self.volProp.SetScalarOpacity(0, self.funAlpha) self.volProp.SetInterpolationTypeToLinear() self.actor = vtk.vtkVolume() self.actor.SetMapper(self.vol_map) self.actor.SetProperty(self.volProp) return self.actor
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 read_images(self, filename, r, g, b, t1=0): # 2 set up the source self.reader_src = vtk.vtkNIFTIImageReader() self.reader_src.SetFileName(filename) # 3 set up the volume mapper self.vol_map = vtk.vtkGPUVolumeRayCastMapper() self.vol_map.SetInputConnection(self.reader_src.GetOutputPort()) # 4 transfer functions for color and opacity self.funColor = vtk.vtkColorTransferFunction() self.funColor.AddRGBPoint(0, 0., 0., 0.) self.funColor.AddRGBPoint(1, r, g, b) # 5 assign also an alpha (opacity) gradient to the values if t1 == 1: self.funAlpha = vtk.vtkPiecewiseFunction() self.funAlpha.AddPoint(0, 0.) self.funAlpha.AddPoint(256, 0.01) else: self.funAlpha = vtk.vtkPiecewiseFunction() self.funAlpha.AddPoint(0, 0.) self.funAlpha.AddPoint(0.01, 0.01) self.volProp = vtk.vtkVolumeProperty() self.volProp.SetColor(0, self.funColor) self.volProp.SetScalarOpacity(0, self.funAlpha) self.volProp.SetInterpolationTypeToLinear() self.volActor = vtk.vtkVolume() self.volActor.SetMapper(self.vol_map) self.volActor.SetProperty(self.volProp) return self.volActor, self.funAlpha
def __init__(self): VolumeFactory.VolumeFactory.__init__(self) # # Dabble with GPU # self._GPUVolumeRayCastMapper = vtk.vtkGPUVolumeRayCastMapper()
def __init__(self, source): # 3 set up the volume mapper volume_mapper = vtk.vtkGPUVolumeRayCastMapper() volume_mapper.SetInputConnection(source.GetOutputPort()) # 4 transfer functions for color and opacity self.color_transfer = vtk.vtkColorTransferFunction() self.alpha_transfer = vtk.vtkPiecewiseFunction() self.c_map_name = 'copper' self.c_map = cm.get_cmap(self.c_map_name) self.init_opacity_points() self.set_color_transfer() # Fill color transfer function # 6 set up the volume properties self.volume_properties = vtk.vtkVolumeProperty() self.volume_properties.SetColor(0, self.color_transfer) self.volume_properties.SetScalarOpacity(0, self.alpha_transfer) self.volume_properties.SetInterpolationTypeToLinear() self.volume_properties.ShadeOn() self.volume_properties.SetAmbient(1.0) self.volume_properties.SetDiffuse(0.7) self.volume_properties.SetSpecular(0.5) # 7 set up the actor self.actor = vtk.vtkVolume() self.actor.SetMapper(volume_mapper) self.actor.SetProperty(self.volume_properties)
def volumeRender(self, img, tf=[], spacing=[1.0, 1.0, 1.0]): importer = dicomShow.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]
def viz_VisualizeDICOM(self, path): volume = vtk.vtkVolume() dc_img_reader = vtk.vtkDICOMImageReader() dc_img_reader.SetDirectoryName(path) dc_img_reader.Update() dc_color_func = vtk.vtkColorTransferFunction() dc_color_func.AddRGBPoint(-3024, 0.0, 0.0, 0.0) dc_color_func.AddRGBPoint(-77, 0.55, 0.25, 0.15) dc_color_func.AddRGBPoint(94, 0.88, 0.60, 0.29) dc_color_func.AddRGBPoint(179, 1.0, 0.94, 0.95) dc_color_func.AddRGBPoint(260, 0.62, 0.0, 0.0) dc_color_func.AddRGBPoint(3071, 0.82, 0.66, 1.0) dc_alpha_func = vtk.vtkPiecewiseFunction() dc_alpha_func.AddPoint(-3024, 0.0) dc_alpha_func.AddPoint(-77, 0.0) dc_alpha_func.AddPoint(94, 0.29) dc_alpha_func.AddPoint(179, 0.55) dc_alpha_func.AddPoint(260, 0.84) dc_alpha_func.AddPoint(3071, 0.875) volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(dc_color_func) volumeProperty.SetScalarOpacity(dc_alpha_func) volumeProperty.ShadeOn() volumeProperty.SetInterpolationTypeToLinear() volumeMapper = vtk.vtkGPUVolumeRayCastMapper() volumeMapper.SetInputConnection(dc_img_reader.GetOutputPort()) volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) self.__ren.AddVolume(volume)
def load_file(self, fileName): # Cleanup the last loaded dataset if self.imageData is not None: self.renderer.RemoveViewProp(self.volume) # Read image data dataReader = DataReader() imageData = dataReader.get_image_data(fileName) # Resize the image data self.imageResizer = DataResizer() self.imageData = self.imageResizer.ResizeData(imageData, maximum=28000000) # Find max and min self.minimum, self.maximum = self.imageData.GetScalarRange() self.lowerBound = self.minimum self.mipMin = self.minimum self.mipMax = self.maximum self.volume = vtkVolume() self.mapper = vtkGPUVolumeRayCastMapper() self.mapper.SetBlendModeToComposite() self.mapper.SetInputData(self.imageData) if self.renderType is None: self.set_render_type(RenderTypeSimple) self.renderType = RenderTypeSimple else: # this might not be needed self.set_render_type(self.renderType) self.volume.SetMapper(self.mapper) self.renderer.AddViewProp(self.volume) self.renderer.ResetCamera()
def __init__(self, default = '', color = [1.0, 0.766, 0.336], singleview = True): # Create the importer and load a volume (gets things warmed up) self.dataImporter = vtk.vtkImageImport() if len(default) == 0: # a dataset's config.yaml will specify the name of the default volume and it'll be included default = '/Users/cam/data/dSpaceX/latest/nanoparticles_volume/unprocessed_data/shape_representations/Images.0002.nrrd' self.loadNewVolume(default) # colors colors = vtk.vtkNamedColors() # volume properties volumeProperty = vtk.vtkVolumeProperty() alphaChannelFunc = vtk.vtkPiecewiseFunction() alphaChannelFunc.AddPoint(0, 0.0) alphaChannelFunc.AddPoint(228, 0.0) alphaChannelFunc.AddPoint(255, 0.25) colorFunc = vtk.vtkColorTransferFunction() colorFunc.AddRGBPoint(0, color[0]/2.0, color[1]/2.0, color[2]/2.0) colorFunc.AddRGBPoint(255, color[0], color[1], color[2]) volumeProperty.SetColor(colorFunc) volumeProperty.SetScalarOpacity(alphaChannelFunc) volumeProperty.ShadeOn() volumeProperty.SetInterpolationTypeToLinear() volumeProperty.SetDiffuse(2.0) volumeProperty.SetSpecular(1.5) volumeProperty.SetSpecularPower(15) # volume volumeMapper = vtk.vtkGPUVolumeRayCastMapper() volumeMapper.SetInputConnection(self.dataImporter.GetOutputPort()) self.volume = vtk.vtkVolume() self.volume.SetMapper(volumeMapper) self.volume.SetProperty(volumeProperty) # renderer self.ren = vtk.vtkRenderer() self.renWin = vtk.vtkRenderWindow() self.renWin.AddRenderer(self.ren) self.renWin.OffScreenRenderingOn() # ***** don't open a window ***** # add volume, set background and size self.ren.AddVolume(self.volume) self.ren.SetBackground(colors.GetColor3d("Wheat")) # camera self.resetCamera() self.renWin.SetWindowName('TwistyTurnyNanoparticle') # screenshot filter self.w2if = vtk.vtkWindowToImageFilter() self.w2if.SetInput(self.renWin) self.w2if.SetInputBufferTypeToRGB() self.w2if.ReadFrontBufferOff()
def create_volume(self, time_step): # Get data npdatauchar = list() vtk_volume_prop = vtk.vtkVolumeProperty() vtk_volume_prop.IndependentComponentsOn() vtk_volume_prop.SetInterpolationTypeToLinear() for i, volume in enumerate(self.volume_list): npdatauchar.append(volume.get_data(time_step, 200, 300, 0.5)) vtk_volume_prop.SetColor(i, volume.vtk_color) vtk_volume_prop.SetScalarOpacity(i, volume.vtk_opacity) vtk_volume_prop.ShadeOff(i) npdatamulti = np.concatenate( [aux[..., np.newaxis] for aux in npdatauchar], axis=3) axes = self.volume_list[0].get_axes(time_step) axes_spacing = self.volume_list[0].get_axes_spacing( time_step, 200, 300, 0.5) # Normalize spacing. Too small values lead to ghost volumes. max_sp = max(axes_spacing["x"], axes_spacing["y"], axes_spacing["z"]) # Too big cells turn opaque, too small become transparent. # max_cell_size normalizes the cell size max_cell_size = 0.1 norm_factor = max_cell_size / max_sp axes_spacing["x"] = axes_spacing["x"] * norm_factor axes_spacing["y"] = axes_spacing["y"] * norm_factor axes_spacing["z"] = axes_spacing["z"] * norm_factor # Put data in VTK format vtk_data_import = vtk.vtkImageImport() vtk_data_import.SetImportVoidPointer(npdatamulti) vtk_data_import.SetDataScalarTypeToUnsignedChar() vtk_data_import.SetNumberOfScalarComponents(len(self.volume_list)) vtk_data_import.SetDataExtent(0, npdatamulti.shape[2] - 1, 0, npdatamulti.shape[1] - 1, 0, npdatamulti.shape[0] - 1) vtk_data_import.SetWholeExtent(0, npdatamulti.shape[2] - 1, 0, npdatamulti.shape[1] - 1, 0, npdatamulti.shape[0] - 1) vtk_data_import.SetDataSpacing(axes_spacing["x"], axes_spacing["y"], axes_spacing["z"]) # data origin is also changed by the normalization vtk_data_import.SetDataOrigin(axes["x"][0] * norm_factor, axes["y"][0] * norm_factor, axes["z"][0] * norm_factor) vtk_data_import.Update() # Create the mapper vtk_volume_mapper = vtk.vtkGPUVolumeRayCastMapper() vtk_volume_mapper.SetInputConnection(vtk_data_import.GetOutputPort()) vtk_volume_mapper.Update() # Add to volume self.vtk_volume.SetMapper(vtk_volume_mapper) self.vtk_volume.SetProperty(vtk_volume_prop) # Set visualization parameters self.set_render_quality(self.render_quality) self.set_color_level(self.volume_color_level) self.set_color_window(self.volume_color_window) # Add to render self.renderer.AddVolume(self.vtk_volume) self.renderer.ResetCamera() self.interactor.Render()
def __init__(self, volume_data, genren): self.volume_data = volume_data self.genren = genren self.vtk_renderer = vtk.vtkRenderer() self.vtk_renderer.SetBackground(0.310999694819562063,0.3400015259021897,0.4299992370489052) self.renWin = vtk.vtkRenderWindow() self.renWin.SetSize(256,256) self.renWin.AddRenderer(self.vtk_renderer) self.renWin.SetWindowName('VTK Renderer') self.iren = vtk.vtkRenderWindowInteractor() self.iren.SetRenderWindow(self.renWin) # compute volume center volume_spacing = np.array(self.volume_data.GetSpacing()) volume_origin = np.array(self.volume_data.GetOrigin()) volume_dimensions = np.array(self.volume_data.GetDimensions()) volume_max = volume_origin+volume_spacing*volume_dimensions volume_center = 0.5*(volume_origin+volume_max) volume_diag = volume_max-volume_origin #offset_scale = 2.25 offset_scale = 2.0 # camera self.camera = self.vtk_renderer.MakeCamera() self.camera.SetClippingRange(0.01,offset_scale*2.0*np.linalg.norm(volume_diag)) self.camera.SetPosition(volume_center[0],volume_center[1],volume_center[2]+offset_scale*np.linalg.norm(volume_diag)) self.camera.SetFocalPoint(volume_center[0],volume_center[1],volume_center[2]) self.camera.Elevation(-85) self.vtk_renderer.SetActiveCamera(self.camera) # color map, opacity map self.vtk_color_map = vtk.vtkColorTransferFunction() for color_val in self.genren.color_tf: self.vtk_color_map.AddRGBPoint(color_val[0],color_val[1],color_val[2],color_val[3]) vtk_opacity_map = vtk.vtkPiecewiseFunction() for op_val in self.genren.opacity_tf: vtk_opacity_map.AddPoint(op_val[0],op_val[1]) # volume properties self.prop_volume = vtk.vtkVolumeProperty() self.prop_volume.ShadeOff() self.prop_volume.SetColor(self.vtk_color_map) self.prop_volume.SetScalarOpacity(vtk_opacity_map) self.prop_volume.SetInterpolationTypeToLinear() # vtk volume render self.mapperVolume = vtk.vtkSmartVolumeMapper() self.mapperVolume = vtk.vtkGPUVolumeRayCastMapper() self.mapperVolume.SetBlendModeToComposite() self.mapperVolume.SetInputData(self.volume_data) self.actorVolume = vtk.vtkVolume() self.actorVolume.SetMapper(self.mapperVolume) self.actorVolume.SetProperty(self.prop_volume) self.vtk_renderer.AddActor(self.actorVolume) self.iren.Initialize()
def _setup_for_gpu_raycasting(self): """This doesn't seem to work. After processing is complete, it stalls on actually rendering the volume. No idea. """ self._volume_mapper = vtk.vtkGPUVolumeRayCastMapper() self._volume_mapper.SetBlendModeToComposite() #self._volume_mapper.SetBlendModeToMaximumIntensity() module_utils.setup_vtk_object_progress(self, self._volume_mapper, 'Preparing render.')
def update_mapper(self): if self._gpu: mapper = vtk.vtkGPUVolumeRayCastMapper() else: mapper = vtk.vtkFixedPointVolumeRayCastMapper() mapper.SetInputData(self._volume) mapper.SetBlendModeToComposite() self._mapper = mapper
def __init__(self): self.volumecolorTransferFunction = vtk.vtkColorTransferFunction() self.isocolorTransferFunction = vtk.vtkColorTransferFunction() self.opacityTransferFunction = vtk.vtkPiecewiseFunction() self.isocolor = vtk.vtkColorTransferFunction() self.volumeProperty = vtk.vtkVolumeProperty() self.volume = vtk.vtkVolume() self.volumeMapper = vtk.vtkGPUVolumeRayCastMapper() self.actor = vtk.vtkActor() self.isomapperlist = []
def __init__(self): QtGui.QMainWindow.__init__(self) # Set up the user interface (.ui) generated by Qt Creator self.ui = uic.loadUi("./ui/mainwindow.ui", self) self.vtkWidget = QVTKRenderWindowInteractor(self.ui.centralWidget) self.ui.verticalLayout.addWidget(self.vtkWidget) self.ren = vtk.vtkRenderer() self.renWin = self.vtkWidget.GetRenderWindow() self.vtkWidget.GetRenderWindow().AddRenderer(self.ren) self.iren = self.vtkWidget.GetRenderWindow().GetInteractor() volume_filename = get_volume_filename("../data/nucleon.mhd") tf_filename = get_transfer_function_filename("../transferfuncs/nucleon.tfi") 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.AddVolume(volume) self.ren.SetBackground(1, 1, 1) #self.renWin.SetSize(600, 600) #self.renWin.Render() self.iren.Initialize() #self.iren.Start() check_gl_version_supported(self.renWin) self.ui.show()
def viz_visualize(self): volume = vtk.vtkVolume() volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(self.__colorFunc) volumeProperty.SetScalarOpacity(self.__alphaChannelFunc) volumeProperty.ShadeOn() volumeProperty.SetInterpolationTypeToLinear() volumeMapper = vtk.vtkGPUVolumeRayCastMapper() volumeMapper.SetInputConnection(self.__dataImporter.GetOutputPort()) volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) self.__ren.AddVolume(volume)
def __init__(self, data_dir, reader): tfun = vtk.vtkPiecewiseFunction() tfun.AddPoint(2440.0, 0.0) tfun.AddPoint(2800.0, 0.85) ctfun = vtk.vtkColorTransferFunction() ctfun.AddRGBPoint(0.0, 0.5, 0.0, 0.0) ctfun.AddRGBPoint(600.0, 1.0, 0.5, 0.5) ctfun.AddRGBPoint(1280.0, 0.9, 0.2, 0.3) ctfun.AddRGBPoint(1960.0, 0.81, 0.27, 0.1) ctfun.AddRGBPoint(4095.0, 0.5, 0.5, 0.5) volumeMapper = vtk.vtkGPUVolumeRayCastMapper() volumeMapper.SetInputConnection(reader.GetOutputPort()) volumeMapper.SetBlendModeToComposite() volumeProperty = vtk.vtkVolumeProperty() #volumeProperty.SetColor(ctfun) volumeProperty.SetScalarOpacity(tfun) volumeProperty.SetInterpolationTypeToLinear() #volumeProperty.ShadeOn() newvol = vtk.vtkVolume() newvol.SetMapper(volumeMapper) newvol.SetProperty(volumeProperty) # The SetInteractor method is how 3D widgets are associated with the # render window interactor. Internally, SetInteractor sets up a bunch # of callbacks using the Command/Observer mechanism (AddObserver()). boxWidget = vtk.vtkBoxWidget() #boxWidget.SetInteractor(iren) boxWidget.SetPlaceFactor(1.0) # The implicit function vtkPlanes is used in conjunction with the # volume ray cast mapper to limit which portion of the volume is # volume rendered. planes = vtk.vtkPlanes() self.planes = planes def ClipVolumeRender(obj, event): #global self.planes, volumeMapper obj.GetPlanes(self.planes) volumeMapper.SetClippingPlanes(self.planes) # Place the interactor initially. The output of the reader is used to # place the box widget. boxWidget.SetInputConnection(reader.GetOutputPort()) boxWidget.PlaceWidget() boxWidget.InsideOutOn() boxWidget.AddObserver("InteractionEvent", ClipVolumeRender) self.boxWidget = boxWidget
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 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 __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 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 volumeRender(img, tf=[],spacing=[1.0,1.0,1.0], box=False): 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() # compositeFunction = vtk.vtkVolumeRayCastCompositeFunction() # compositeFunction.SetCompositeMethodToInterpolateFirst() # volMapper.SetVolumeRayCastFunction(compositeFunction) # pix_diag = 5.0 # volMapper.SetSampleDistance(pix_diag / 5.0) 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() #volProperty.SetScalarOpacityUnitDistance(pix_diag) vol = vtk.vtkVolume() vol.SetMapper(volMapper) vol.SetProperty(volProperty) if not box: return [vol] else: bbox = outline(importer) return [vol,bbox]
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 __setup_default_volume_parameters(self, image_reader): volume_mapper = vtk.vtkGPUVolumeRayCastMapper() volume_mapper.SetInputConnection(image_reader.GetOutputPort()) volumeGradientOpacity = vtk.vtkPiecewiseFunction() volumeGradientOpacity.AddPoint(0, 0.0) volumeGradientOpacity.AddPoint(90, 0.5) volumeGradientOpacity.AddPoint(100, 1.0) volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetInterpolationTypeToLinear() volumeProperty.SetGradientOpacity(volumeGradientOpacity) volumeProperty.SetAmbient(0.4) volumeProperty.SetDiffuse(0.6) volumeProperty.SetSpecular(0.2) self.volume.SetMapper(volume_mapper) self.volume.SetProperty(volumeProperty) self.__set_colors() self.__set_scalar_opacity() self.__set_gradient_opacity() self.__set_shading()
def __get_volumedata_actor(self): # Create the reader for the data reader = vtk.vtkStructuredPointsReader() file_path = os.path.join(const.RC_FILE_DIR, "ironProt.vtk") reader.SetFileName(file_path) # Create transfer mapping scalar value to opacity opacityTransferFunction = vtk.vtkPiecewiseFunction() opacityTransferFunction.AddPoint(20, 0.0) opacityTransferFunction.AddPoint(255, 0.2) # Create transfer mapping scalar value to color colorTransferFunction = vtk.vtkColorTransferFunction() colorTransferFunction.AddRGBPoint(0.0, 0.0, 0.0, 0.0) colorTransferFunction.AddRGBPoint(64.0, 1.0, 0.0, 0.0) colorTransferFunction.AddRGBPoint(128.0, 0.0, 0.0, 1.0) colorTransferFunction.AddRGBPoint(192.0, 0.0, 1.0, 0.0) colorTransferFunction.AddRGBPoint(255.0, 0.0, 0.2, 0.0) # The property describes how the data will look volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(colorTransferFunction) volumeProperty.SetScalarOpacity(opacityTransferFunction) volumeProperty.ShadeOn() volumeProperty.SetInterpolationTypeToLinear() # The mapper / ray cast function know how to render the data volumeMapper = vtk.vtkGPUVolumeRayCastMapper() # volumeMapper = vtk.vtkFixedPointVolumeRayCastMapper() volumeMapper.SetBlendModeToComposite() 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) return volume
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 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 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
ctf.AddRGBPoint(0, 0.0, 0.0, 0.0) ctf.AddRGBPoint(510, 0.4, 0.4, 1.0) ctf.AddRGBPoint(640, 1.0, 1.0, 1.0) ctf.AddRGBPoint(range[1], 0.9, 0.1, 0.1) pf = vtk.vtkPiecewiseFunction() pf.AddPoint(0, 0.00) pf.AddPoint(510, 0.00) pf.AddPoint(640, 0.5) pf.AddPoint(range[1], 0.4) volumeProperty.SetScalarOpacity(pf) volumeProperty.SetColor(ctf) volumeProperty.SetShade(1) mapper = vtk.vtkGPUVolumeRayCastMapper() mapper.SetInputConnection(reader.GetOutputPort()) mapper.SetUseJittering(1) # Modify the shader to color based on the depth of the translucent voxel mapper.AddShaderReplacement( vtk.vtkShader.Fragment, # Replace in the fragment shader "//VTK::Base::Dec", # Source string to replace True, # before the standard replacements "//VTK::Base::Dec" # We still want the default "\n bool l_updateDepth;" "\n vec3 l_opaqueFragPos;", False # only do it once i.e. only replace the first match ) mapper.AddShaderReplacement( vtk.vtkShader.Fragment, "//VTK::Base::Init", True, "//VTK::Base::Init\n"
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.vtkGPUVolumeRayCastMapper() compositeFunction = vtk.vtkVolumeRayCastCompositeFunction() compositeFunction.SetCompositeMethodToInterpolateFirst() #compositeFunction.SetCompositeMethodToClassifyFirst() #volMapper.SetVolumeRayCastFunction(compositeFunction) #volMapper.SetSampleDistance(pix_diag / 5.0) volMapper.SetImageSampleDistance( .5 ) volMapper.SetSampleDistance(1.0) volMapper.SetInputConnection( img.GetOutputPort() ) volMapper.SetBlendModeToComposite() # 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, parent=None): QtWidgets.QMainWindow.__init__(self, parent) self.frame = QtWidgets.QFrame() self.vl = QtWidgets.QVBoxLayout() self.vtkWidget = QVTKRenderWindowInteractor(self.frame) self.vl.addWidget(self.vtkWidget) self.ren = vtk.vtkRenderer() self.renWin= self.vtkWidget.GetRenderWindow() self.renWin.AddRenderer(self.ren) self.iren = self.renWin.GetInteractor() self.iren.SetRenderWindow(self.renWin) dicomReader = vtk.vtk.vtkDICOMImageReader() dicomReader.SetDirectoryName(r'G:\PythonTrainFaile\SE2')#G:\PythonTrainFaile\SE2 F:\sliver_07\segmentation-0.nii dicomReader.Update() srange = dicomReader.GetOutput().GetScalarRange() print(dicomReader.GetOutput().GetDimensions()) min = srange[0] max = srange[1] diff = max - min slope = 4000 / diff inter = -slope * min shift = inter / slope shifter = vtk.vtkImageShiftScale() # 对偏移和比例参数来对图像数据进行操作 数据转换 shifter.SetShift(shift) shifter.SetScale(slope) shifter.SetOutputScalarTypeToUnsignedShort() shifter.SetInputData(dicomReader.GetOutput()) shifter.ReleaseDataFlagOff() shifter.Update() print(min, max, slope, inter, shift) tfun = vtk.vtkPiecewiseFunction() # 梯度不透明度函数 tfun.AddPoint(2000, 0) tfun.AddPoint(2300.0, 0.3) tfun.AddPoint(2501.0, 1) tfun.AddPoint(2600.0, 1) tfun.AddPoint(2700.0, 1) tfun.AddPoint(2900.0, 1) tfun.AddPoint(3024.0, 1) ctfun = vtk.vtkColorTransferFunction() # 颜色传输函数 ctfun.AddRGBPoint(0.0, 0.5, 0.0, 0.0) ctfun.AddRGBPoint(600.0, 1.0, 0.5, 0.5) ctfun.AddRGBPoint(1280.0, 0.9, 0.2, 0.3) ctfun.AddRGBPoint(1960.0, 0.81, 0.27, 0.1) ctfun.AddRGBPoint(2200.0, 0.9, 0.2, 0.3) ctfun.AddRGBPoint(2500.0, 1, 0.5, 0.5) ctfun.AddRGBPoint(3024.0, 0.5, 0.5, 0.5) self.volumeMapper = vtk.vtkGPUVolumeRayCastMapper() self.volumeMapper.SetInputConnection(shifter.GetOutputPort()) volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(ctfun) volumeProperty.SetScalarOpacity(tfun) volumeProperty.SetInterpolationTypeToLinear() volumeProperty.ShadeOn() newvol = vtk.vtkVolume() newvol.SetMapper(self.volumeMapper) newvol.SetProperty(volumeProperty) outline = vtk.vtkOutlineFilter() outline.SetInputConnection(shifter.GetOutputPort()) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInputConnection(outline.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(outlineMapper) # Create an actor boxWidget = vtk.vtkBoxWidget() boxWidget.SetInteractor(self.iren) boxWidget.SetPlaceFactor(1.0) # Add the actors to the renderer, set the background and size self.ren.AddActor(outlineActor) self.ren.AddVolume(newvol) self.ren.SetBackground(0, 0, 0) self.renWin.SetSize(600, 600) self.planes = vtk.vtkPlanes() boxWidget.PlaceWidget() boxWidget.InsideOutOn() boxWidget.AddObserver("StartInteractionEvent", self.StartInteraction) boxWidget.AddObserver("InteractionEvent", self.ClipVolumeRender) boxWidget.AddObserver("EndInteractionEvent", self.EndInteraction) outlineProperty = boxWidget.GetOutlineProperty() outlineProperty.SetRepresentationToWireframe() outlineProperty.SetAmbient(1.0) outlineProperty.SetAmbientColor(1, 1, 1) outlineProperty.SetLineWidth(9) selectedOutlineProperty = boxWidget.GetSelectedOutlineProperty() selectedOutlineProperty.SetRepresentationToWireframe() selectedOutlineProperty.SetAmbient(1.0) selectedOutlineProperty.SetAmbientColor(1, 0, 0) selectedOutlineProperty.SetLineWidth(3) self.ren.ResetCamera() self.frame.setLayout(self.vl) self.setCentralWidget(self.frame) self.show() self.iren.Initialize() self.renWin.Render() self.iren.Start()
ctf.AddRGBPoint(0, 0.0, 0.0, 0.0) ctf.AddRGBPoint(510, 0.4, 0.4, 1.0) ctf.AddRGBPoint(640, 1.0, 1.0, 1.0) ctf.AddRGBPoint(range[1], 0.9, 0.1, 0.1) pf = vtk.vtkPiecewiseFunction() pf.AddPoint(0, 0.00) pf.AddPoint(510, 0.00) pf.AddPoint(640, 0.5) pf.AddPoint(range[1], 0.4) volumeProperty.SetScalarOpacity(pf) volumeProperty.SetColor(ctf) volumeProperty.SetShade(1) mapper = vtk.vtkGPUVolumeRayCastMapper() mapper.SetInputConnection(reader.GetOutputPort()) mapper.SetUseJittering(1) # Modify the shader to color based on the depth of the translucent voxel mapper.AddShaderReplacement( vtk.vtkShader.Fragment, # Replace in the fragment shader "//VTK::Base::Dec", # Source string to replace True, # before the standard replacements "//VTK::Base::Dec" # We still want the default "\n bool l_updateDepth;" "\n vec3 l_opaqueFragPos;", False # only do it once i.e. only replace the first match ) mapper.AddShaderReplacement( vtk.vtkShader.Fragment,
def VolumeRenderingGPURayCast(volumereader, scale=None, lowerThreshold=0, upperThreshold=None): """ Ray cast function using GPU general for most volume readers. :param volumereader: vtk file reader for 3D images :param scale: scale [x, y, z] of the slice/voxel spacing to real. Default = [ volumereader.GetNIFTIHeader().GetPixDim(i) for i in xrange(3)] :param lowerThreshold: lower Threshold for raycast. Default = 0 :param upperThreshold: upper Threshold for raycast. Default = volumereader.GetOutput().GetScalarRange()[1] :return: Note: This function requires your version of VTK being compiled with the use of GPU-proprietary libGL.so. The cmake option is OPEN_gl_LIBRARY for VTK 6.3.0. This is more trickier in Linux and is potentially more unstable. For your reference this program is entirely build against nVidia-352 Linux driver. """ reader = volumereader reader.Update() header = reader.GetNIFTIHeader() # Insert Default value if none provided if scale == None: scale = [abs(header.GetPixDim(i)) for i in xrange(3)] # Insert Default value if none provided if scale == None: scale = [abs(header.GetPixDim(i)) for i in xrange(3)] if upperThreshold == None: upperThreshold = reader.GetOutput().GetScalarRange()[1] # Error check if lowerThreshold >= upperThreshold: raise ValueError("UpperThreshold cannot be smaller than lowerThreshold") # Set some default color points centerThreshold = (upperThreshold - lowerThreshold) / 2.0 + lowerThreshold lowerQuardThreshold = (centerThreshold - lowerThreshold) / 2.0 + lowerThreshold upperQuardThreshold = (upperThreshold - centerThreshold) / 2.0 + centerThreshold # Set some default alpha map alphaChannelFunc = vtk.vtkPiecewiseFunction() alphaChannelFunc.AddPoint(lowerThreshold, 0) alphaChannelFunc.AddPoint(lowerQuardThreshold, 0.05) alphaChannelFunc.AddPoint(centerThreshold, 0.4) alphaChannelFunc.AddPoint(upperQuardThreshold, 0.05) alphaChannelFunc.AddPoint(upperThreshold, 0) colorFunc = vtk.vtkColorTransferFunction() colorFunc.AddRGBPoint(lowerThreshold, 0, 0, 0) colorFunc.AddRGBPoint(centerThreshold, 0.5, 0.5, 0.5) colorFunc.AddRGBPoint(upperThreshold, 0.8, 0.8, 0.8) volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(colorFunc) volumeProperty.SetScalarOpacity(alphaChannelFunc) volumeMapper = vtk.vtkGPUVolumeRayCastMapper() volumeMapper.SetInputConnection(reader.GetOutputPort()) volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) volume.SetScale(scale) return volume
def test(self): dataRoot = vtkGetDataRoot() reader = vtk.vtkXMLImageDataReader() reader.SetFileName("" + str(dataRoot) + "/Data/vase_4comp.vti") volume = vtk.vtkVolume() #mapper = vtk.vtkFixedPointVolumeRayCastMapper() mapper = vtk.vtkGPUVolumeRayCastMapper() mapper.SetSampleDistance(0.1) mapper.SetAutoAdjustSampleDistances(0) ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() iRen = vtk.vtkRenderWindowInteractor() # Set connections mapper.SetInputConnection(reader.GetOutputPort()); volume.SetMapper(mapper) ren.AddViewProp(volume) renWin.AddRenderer(ren) iRen.SetRenderWindow(renWin) # Define opacity transfer function and color functions opacityFunc1 = vtk.vtkPiecewiseFunction() opacityFunc1.AddPoint(0.0, 0.0); opacityFunc1.AddPoint(60.0, 0.1); opacityFunc1.AddPoint(255.0, 0.0); opacityFunc2 = vtk.vtkPiecewiseFunction() opacityFunc2.AddPoint(0.0, 0.0); opacityFunc2.AddPoint(60.0, 0.0); opacityFunc2.AddPoint(120.0, 0.1); opacityFunc1.AddPoint(255.0, 0.0); opacityFunc3 = vtk.vtkPiecewiseFunction() opacityFunc3.AddPoint(0.0, 0.0); opacityFunc3.AddPoint(120.0, 0.0); opacityFunc3.AddPoint(180.0, 0.1); opacityFunc3.AddPoint(255.0, 0.0); opacityFunc4 = vtk.vtkPiecewiseFunction() opacityFunc4.AddPoint(0.0, 0.0); opacityFunc4.AddPoint(180.0, 0.0); opacityFunc4.AddPoint(255.0, 0.1); # Color transfer functions color1 = vtk.vtkColorTransferFunction() color1.AddRGBPoint(0.0, 1.0, 0.0, 0.0); color1.AddRGBPoint(60.0, 1.0, 0.0, 0.0); color2 = vtk.vtkColorTransferFunction() color2.AddRGBPoint(60.0, 0.0, 0.0, 1.0); color2.AddRGBPoint(120.0, 0.0, 0.0, 1.0); color3 = vtk.vtkColorTransferFunction() color3.AddRGBPoint(120.0, 0.0, 1.0, 0.0); color3.AddRGBPoint(180.0, 0.0, 1.0, 0.0); color4 = vtk.vtkColorTransferFunction() color4.AddRGBPoint(180.0, 0.0, 0.0, 0.0); color4.AddRGBPoint(239.0, 0.0, 0.0, 0.0); # Now set the opacity and the color volumeProperty = volume.GetProperty() volumeProperty.SetIndependentComponents(1) volumeProperty.SetScalarOpacity(0, opacityFunc1) volumeProperty.SetScalarOpacity(1, opacityFunc2) volumeProperty.SetScalarOpacity(2, opacityFunc3) volumeProperty.SetScalarOpacity(3, opacityFunc4) volumeProperty.SetColor(0, color1) volumeProperty.SetColor(1, color2) volumeProperty.SetColor(2, color3) volumeProperty.SetColor(3, color4) iRen.Initialize(); ren.SetBackground(0.1,0.4,0.2) ren.ResetCamera() renWin.Render() img_file = "TestGPURayCastIndependentComponent.png" vtk.test.Testing.compareImage( iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=10) vtk.test.Testing.interact()
def VolumeRenderingGPUDICOMLoader(dicomreader): """ Recieve a vtkDICOMImageReader and return the volume actor. Reader can be created in the following manner: reader = vtk.vtkDICOMImageReader() reader.SetDirectoryName(path) reader.SetDataSpacing(3.2,3.2,1.5) # Set slice spacing reader.SetDataOrigin(0,0,0) :param dicomreader: vtkDICOMImageReader() :return: vtkVolume() """ imcast = vtk.vtkImageCast() imcast.SetInputConnection(dicomreader.GetOutputPort()) imcast.SetOutputScalarTypeToUnsignedShort() imcast.ClampOverflowOn() opacityTransferFunction = vtk.vtkPiecewiseFunction() opacityTransferFunction.AddPoint(-2048, 0, 0.5, 0) opacityTransferFunction.AddPoint(142.677, 0, 0.5, 0) opacityTransferFunction.AddPoint(145.016, 0.116071, 0.5, 0.26) opacityTransferFunction.AddPoint(192.174, 0.5625, 0.469638, 0.39) opacityTransferFunction.AddPoint(217.24, 0.776786, 0.666667, 0.41) opacityTransferFunction.AddPoint(384.347, 0.830357, 0.5, 0) opacityTransferFunction.AddPoint(3661, 0.830357, 0.5, 0) colorTransferFunction = vtk.vtkColorTransferFunction() colorTransferFunction.AddRGBPoint(-2048, 0, 0, 0, 0.5, 0) colorTransferFunction.AddRGBPoint(142.667, 0, 0, 0, 0.5, 0) colorTransferFunction.AddRGBPoint(145.016, 0.615686, 0, 0.156863, 0.5, 0.26) colorTransferFunction.AddRGBPoint(192.174, 0.909804, 0.454902, 0, 0.469638, 0.39) colorTransferFunction.AddRGBPoint(217.24, 0.972549, 0.807843, 0.611765, 0.666667, 0.41) colorTransferFunction.AddRGBPoint(384.347, 0.909804, 0.909804, 1, 0.5, 0) colorTransferFunction.AddRGBPoint(3661, 1, 1, 1, 0.5, 0) colorTransferFunction.ClampingOn() colorTransferFunction.SetColorSpace(1) volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetAmbient(0.2) volumeProperty.SetDiffuse(1) volumeProperty.SetSpecular(0) volumeProperty.SetSpecularPower(1) volumeProperty.DisableGradientOpacityOn() volumeProperty.SetComponentWeight(1, 1) volumeProperty.SetScalarOpacityUnitDistance(0.48117) volumeProperty.SetColor(colorTransferFunction) volumeProperty.ShadeOn() volumeProperty.SetScalarOpacity(opacityTransferFunction) volumeProperty.SetInterpolationTypeToLinear() # raycast = vtk.vtkVolumeRayCastCompositeFunction() volumeMapper = vtk.vtkGPUVolumeRayCastMapper() volumeMapper.SetInputConnection(imcast.GetOutputPort()) volumeMapper.SetBlendModeToComposite() volumeMapper.SetSampleDistance(0.1) volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) # === DEBUG TEST === # renderer = vtk.vtkRenderer() # renderer.AddVolume(volume) # # # print "writing" # ImageWriter(renderer, outFileName="tmp1") # print "write finish" # camera = renderer.GetActiveCamera() # camera.Zoom(1.3) # camera.Azimuth(40) # ImageWriter(renderer, camera=camera, outFileName="tmp2", AAFrames=0) # print "write cam1" # camera.Zoom(1.3) # camera.Azimuth(40) # ImageWriter(renderer, camera=camera, outFileName="tmp3", AAFrames=0) # print "write cam2" # camera.Zoom(1.3) # camera.Azimuth(40) # ImageWriter(renderer, camera=camera, outFileName="tmp4", AAFrames=0) # print "write cam3" # renderer.ResetCameraClippingRange() # === DEBUG TEST === return volume