def volume(vol,voxsz=(1.0,1.0,1.0),affine=None,center_origin=1,info=1,maptype=0,trilinear=1,iso=0,iso_thr=100,opacitymap=None,colormap=None): ''' Create a volume and return a volumetric actor using volumetric rendering. This function has many different interesting capabilities. The maptype, opacitymap and colormap are the most crucial parameters here. Parameters: ---------------- vol : array, shape (N, M, K), dtype uint8 an array representing the volumetric dataset that we want to visualize using volumetric rendering voxsz : sequence of 3 floats default (1., 1., 1.) affine : array, shape (4,4), default None as given by volumeimages center_origin : int {0,1}, default 1 it considers that the center of the volume is the point (-vol.shape[0]/2.0+0.5,-vol.shape[1]/2.0+0.5,-vol.shape[2]/2.0+0.5) info : int {0,1}, default 1 if 1 it prints out some info about the volume, the method and the dataset. trilinear: int {0,1}, default 1 Use trilinear interpolation, default 1, gives smoother rendering. If you want faster interpolation use 0 (Nearest). maptype : int {0,1}, default 0, The maptype is a very important parameter which affects the raycasting algorithm in use for the rendering. The options are: If 0 then vtkVolumeTextureMapper2D is used. If 1 then vtkVolumeRayCastFunction is used. iso : int {0,1} default 0, If iso is 1 and maptype is 1 then we use vtkVolumeRayCastIsosurfaceFunction which generates an isosurface at the predefined iso_thr value. If iso is 0 and maptype is 1 vtkVolumeRayCastCompositeFunction is used. iso_thr : int, default 100, if iso is 1 then then this threshold in the volume defines the value which will be used to create the isosurface. opacitymap : array, shape (N,2), default None. The opacity map assigns a transparency coefficient to every point in the volume. The default value uses the histogram of the volume to calculate the opacitymap. colormap : array, shape (N,4), default None. The color map assigns a color value to every point in the volume. When None from the histogram it uses a red-blue colormap. Returns: ---------- vtkVolume Notes: -------- What is the difference between TextureMapper2D and RayCastFunction? Coming soon... See VTK user's guide [book] & The Visualization Toolkit [book] and VTK's online documentation & online docs. What is the difference between RayCastIsosurfaceFunction and RayCastCompositeFunction? Coming soon... See VTK user's guide [book] & The Visualization Toolkit [book] and VTK's online documentation & online docs. What about trilinear interpolation? Coming soon... well when time permits really ... :-) Examples: ------------ First example random points >>> from dipy.viz import fos >>> import numpy as np >>> vol=100*np.random.rand(100,100,100) >>> vol=vol.astype('uint8') >>> print vol.min(), vol.max() >>> r = fos.ren() >>> v = fos.volume(vol) >>> fos.add(r,v) >>> fos.show(r) Second example with a more complicated function >>> from dipy.viz import fos >>> import numpy as np >>> x, y, z = np.ogrid[-10:10:20j, -10:10:20j, -10:10:20j] >>> s = np.sin(x*y*z)/(x*y*z) >>> r = fos.ren() >>> v = fos.volume(s) >>> fos.add(r,v) >>> fos.show(r) If you find this function too complicated you can always use mayavi. Please do not forget to use the -wthread switch in ipython if you are running mayavi. >>> from enthought.mayavi import mlab >>> import numpy as np >>> x, y, z = np.ogrid[-10:10:20j, -10:10:20j, -10:10:20j] >>> s = np.sin(x*y*z)/(x*y*z) >>> mlab.pipeline.volume(mlab.pipeline.scalar_field(s)) >>> mlab.show() More mayavi demos are available here: http://code.enthought.com/projects/mayavi/docs/development/html/mayavi/mlab.html ''' if vol.ndim!=3: raise ValueError('3d numpy arrays only please') if info : print('Datatype',vol.dtype,'converted to uint8' ) vol=np.interp(vol,[vol.min(),vol.max()],[0,255]) vol=vol.astype('uint8') if opacitymap==None: bin,res=np.histogram(vol.ravel()) res2=np.interp(res,[vol.min(),vol.max()],[0,1]) opacitymap=np.vstack((res,res2)).T opacitymap=opacitymap.astype('float32') ''' opacitymap=np.array([[ 0.0, 0.0], [50.0, 0.9]]) ''' if info: print 'opacitymap', opacitymap if colormap==None: bin,res=np.histogram(vol.ravel()) res2=np.interp(res,[vol.min(),vol.max()],[0,1]) zer=np.zeros(res2.shape) colormap=np.vstack((res,res2,zer,res2[::-1])).T colormap=colormap.astype('float32') ''' colormap=np.array([[0.0, 0.5, 0.0, 0.0], [64.0, 1.0, 0.5, 0.5], [128.0, 0.9, 0.2, 0.3], [196.0, 0.81, 0.27, 0.1], [255.0, 0.5, 0.5, 0.5]]) ''' if info: print 'colormap', colormap im = vtk.vtkImageData() im.SetScalarTypeToUnsignedChar() im.SetDimensions(vol.shape[0],vol.shape[1],vol.shape[2]) #im.SetOrigin(0,0,0) #im.SetSpacing(voxsz[2],voxsz[0],voxsz[1]) im.AllocateScalars() for i in range(vol.shape[0]): for j in range(vol.shape[1]): for k in range(vol.shape[2]): im.SetScalarComponentFromFloat(i,j,k,0,vol[i,j,k]) if affine != None: aff = vtk.vtkMatrix4x4() aff.DeepCopy((affine[0,0],affine[0,1],affine[0,2],affine[0,3],affine[1,0],affine[1,1],affine[1,2],affine[1,3],affine[2,0],affine[2,1],affine[2,2],affine[2,3],affine[3,0],affine[3,1],affine[3,2],affine[3,3])) #aff.DeepCopy((affine[0,0],affine[0,1],affine[0,2],0,affine[1,0],affine[1,1],affine[1,2],0,affine[2,0],affine[2,1],affine[2,2],0,affine[3,0],affine[3,1],affine[3,2],1)) #aff.DeepCopy((affine[0,0],affine[0,1],affine[0,2],127.5,affine[1,0],affine[1,1],affine[1,2],-127.5,affine[2,0],affine[2,1],affine[2,2],-127.5,affine[3,0],affine[3,1],affine[3,2],1)) reslice = vtk.vtkImageReslice() reslice.SetInput(im) #reslice.SetOutputDimensionality(2) #reslice.SetOutputOrigin(127,-145,147) reslice.SetResliceAxes(aff) #reslice.SetOutputOrigin(-127,-127,-127) #reslice.SetOutputExtent(-127,128,-127,128,-127,128) #reslice.SetResliceAxesOrigin(0,0,0) #print 'Get Reslice Axes Origin ', reslice.GetResliceAxesOrigin() #reslice.SetOutputSpacing(1.0,1.0,1.0) reslice.SetInterpolationModeToLinear() #reslice.UpdateWholeExtent() #print 'reslice GetOutputOrigin', reslice.GetOutputOrigin() #print 'reslice GetOutputExtent',reslice.GetOutputExtent() #print 'reslice GetOutputSpacing',reslice.GetOutputSpacing() changeFilter=vtk.vtkImageChangeInformation() changeFilter.SetInput(reslice.GetOutput()) #changeFilter.SetInput(im) if center_origin: changeFilter.SetOutputOrigin(-vol.shape[0]/2.0+0.5,-vol.shape[1]/2.0+0.5,-vol.shape[2]/2.0+0.5) print 'ChangeFilter ', changeFilter.GetOutputOrigin() opacity = vtk.vtkPiecewiseFunction() for i in range(opacitymap.shape[0]): opacity.AddPoint(opacitymap[i,0],opacitymap[i,1]) color = vtk.vtkColorTransferFunction() for i in range(colormap.shape[0]): color.AddRGBPoint(colormap[i,0],colormap[i,1],colormap[i,2],colormap[i,3]) if(maptype==0): property = vtk.vtkVolumeProperty() property.SetColor(color) property.SetScalarOpacity(opacity) if trilinear: property.SetInterpolationTypeToLinear() else: prop.SetInterpolationTypeToNearest() if info: print('mapper VolumeTextureMapper2D') mapper = vtk.vtkVolumeTextureMapper2D() if affine == None: mapper.SetInput(im) else: #mapper.SetInput(reslice.GetOutput()) mapper.SetInput(changeFilter.GetOutput()) if (maptype==1): property = vtk.vtkVolumeProperty() property.SetColor(color) property.SetScalarOpacity(opacity) property.ShadeOn() if trilinear: property.SetInterpolationTypeToLinear() else: prop.SetInterpolationTypeToNearest() if iso: isofunc=vtk.vtkVolumeRayCastIsosurfaceFunction() isofunc.SetIsoValue(iso_thr) else: compositeFunction = vtk.vtkVolumeRayCastCompositeFunction() if info: print('mapper VolumeRayCastMapper') mapper = vtk.vtkVolumeRayCastMapper() if iso: mapper.SetVolumeRayCastFunction(isofunc) if info: print('Isosurface') else: mapper.SetVolumeRayCastFunction(compositeFunction) #mapper.SetMinimumImageSampleDistance(0.2) if info: print('Composite') if affine == None: mapper.SetInput(im) else: #mapper.SetInput(reslice.GetOutput()) mapper.SetInput(changeFilter.GetOutput()) #Return mid position in world space #im2=reslice.GetOutput() #index=im2.FindPoint(vol.shape[0]/2.0,vol.shape[1]/2.0,vol.shape[2]/2.0) #print 'Image Getpoint ' , im2.GetPoint(index) volum = vtk.vtkVolume() volum.SetMapper(mapper) volum.SetProperty(property) if info : print 'Origin', volum.GetOrigin() print 'Orientation', volum.GetOrientation() print 'OrientationW', volum.GetOrientationWXYZ() print 'Position', volum.GetPosition() print 'Center', volum.GetCenter() print 'Get XRange', volum.GetXRange() print 'Get YRange', volum.GetYRange() print 'Get ZRange', volum.GetZRange() print 'Volume data type', vol.dtype return volum
def WriteImageToDisk(self, filename): """Writes thumbnail to disk""" ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) ren.SetBackground(1.0, 1.0, 1.0) renWin.SetSize(200, 200) renWin.OffScreenRenderingOn() # determine image range self._image.Update() r = self._image.GetScalarRange() t = self._threshold # determine image spacing sp = self._image.GetSpacing() # cast image to unsigned char typ = self._image.GetScalarType() if ((typ != 3) or (typ != 5)): cast = vtk.vtkImageShiftScale() cast.SetInput(self._image) cast.SetOutputScalarTypeToUnsignedChar() cast.SetShift(-r[0]) if r[1] == r[0]: cast.SetScale(255.0 / (r[1] - r[0] + 1)) t = (self._threshold - r[0]) * (255.0 / (r[1] - r[0] + 1)) else: cast.SetScale(255.0 / (r[1] - r[0])) t = (self._threshold - r[0]) * (255.0 / (r[1] - r[0])) r = [0, 255.0] o = cast.GetOutput() else: o = self._image.GetOutput() # build a LUT tfun = vtk.vtkPiecewiseFunction() tfun.AddPoint(r[0], 0.0) tfun.AddPoint(t - (r[1] - r[0]) / 1024., 0.0) tfun.AddPoint(t, 0.2) tfun.AddPoint(r[1], 0.2) ctfun = vtk.vtkColorTransferFunction() ctfun.AddRGBPoint(r[0], 1, 1, 1) ctfun.AddRGBPoint(r[1], 1, 1, 1) function = vtk.vtkVolumeRayCastIsosurfaceFunction() # tunable function.SetIsoValue(t) volumeMapper = vtk.vtkVolumeRayCastMapper() volumeMapper.SetInput(o) volumeMapper.SetVolumeRayCastFunction(function) volumeMapper.SetSampleDistance(max(sp) * 1.0) # tunable volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(ctfun) volumeProperty.SetScalarOpacity(tfun) volumeProperty.SetInterpolationTypeToLinear() # tunable volumeProperty.ShadeOn() newvol = vtk.vtkVolume() newvol.SetMapper(volumeMapper) newvol.SetProperty(volumeProperty) # Add volume to renderer ren.AddVolume(newvol) # set up inital camera camera = ren.GetActiveCamera() camera.Elevation(-60.0) camera.SetViewAngle(20) # grab image renWin.Render() windowToimage = vtk.vtkWindowToImageFilter() windowToimage.SetInput(renWin) # save image writer = vtk.vtkJPEGWriter() writer.SetInput(windowToimage.GetOutput()) writer.SetFileName(filename) writer.SetQuality(85) writer.Write()
def updateRendering(self): """ Update the Rendering of this module """ method = self.parameters["Method"] self.setMethod(method) if self.volumeModule: self.volumeModule.function = vtk.vtkVolumeRayCastIsosurfaceFunction() self.volumeModule.function.SetIsoValue(self.parameters["IsoValue"]) self.volumeModule.showTimepoint(self.timepoint) return if not self.init: self.init = 1 self.mapper.ColorByArrayComponent(0, 0) self.mapper.AddObserver("ProgressEvent", lib.messenger.send) lib.messenger.connect(self.mapper, "ProgressEvent", self.updateProgress) dataUnit = self.getInputDataUnit(1) if not dataUnit: dataUnit = self.dataUnit dataCtf = dataUnit.getColorTransferFunction() if self.parameters["SolidColor"]: minval, maxval = dataCtf.GetRange() ctf = vtk.vtkColorTransferFunction() ctf.AddRGBPoint(int(minval), 0, 0, 0) r, g, b = dataCtf.GetColor(maxval) ctf.AddRGBPoint(int(minval) + 1, r, g, b) ctf.AddRGBPoint(maxval, r, g, b) else: ctf = dataCtf self.mapper.SetLookupTable(ctf) self.mapper.ScalarVisibilityOn() minVal, maxVal = self.data.GetScalarRange() self.setScalarRange(minVal, maxVal) self.mapper.SetScalarRange(minVal, maxVal) self.mapper.SetColorModeToMapScalars() opacity = self.parameters["Transparency"] opacity = (100 - opacity) / 100.0 Logging.info("Using opacity ", opacity, kw="visualizer") if opacity != 1: cullers = self.parent.getRenderer().GetCullers() cullers.InitTraversal() culler = cullers.GetNextItem() culler.SetSortingStyleToBackToFront() # print cullers, culler # self.parent.getRenderer().GetRenderWindow().SetAlphaBitPlanes(1) # self.parent.getRenderer().GetRenderWindow().SetMultiSamples(0) # self.parent.getRenderer().SetUseDepthPeeling(1) # self.parent.getRenderer().SetMaximumNumberOfPeels(100) # self.parent.getRenderer().SetOcclusionRatio(1.0) # print self.parent.getRenderer().GetLastRenderingUsedDepthPeeling() self.actor.GetProperty().SetOpacity(opacity) polyinput = self.getPolyDataInput(1) if polyinput: Logging.info("Using polydata input", kw="visualizer") self.mapper.SetInput(polyinput) VisualizationModule.updateRendering(self, polyinput) self.parent.Render() return x, y, z = self.dataUnit.getDimensions() input = self.getInput(1) input = optimize.optimize(image=input, updateExtent=(0, x - 1, 0, y - 1, 0, z - 1)) if self.parameters["Gaussian"]: Logging.info("Doing gaussian smoothing", kw="visualizer") if not self.smooth: self.smooth = vtk.vtkImageGaussianSmooth() self.smooth.SetInput(input) input = self.smooth.GetOutput() self.contour.SetInput(input) input = self.contour.GetOutput() multi = self.parameters["MultipleSurfaces"] if not multi: Logging.info("Using single isovalue=%d" % int(self.parameters["IsoValue"]), kw="visualizer") self.contour.SetValue(0, self.parameters["IsoValue"]) else: begin = self.parameters["SurfaceRangeBegin"] end = self.parameters["SurfaceRangeEnd"] n = self.parameters["SurfaceAmnt"] Logging.info("Generating %d values in range %d-%d" % (n, begin, end), kw="visualizer") self.contour.GenerateValues(n, begin, end) n = self.contour.GetNumberOfContours() for i in range(0, n): self.contour.SetValue(i, int(self.contour.GetValue(i))) # print self.contour # TODO: should decimateLevel and preserveTopology be instance variables? decimateLevel = self.parameters["Simplify"] preserveTopology = self.parameters["PreserveTopology"] if decimateLevel != 0: self.decimate.SetPreserveTopology(preserveTopology) if not preserveTopology: self.decimate.SplittingOn() self.decimate.BoundaryVertexDeletionOn() else: self.decimate.SplittingOff() self.decimate.BoundaryVertexDeletionOff() self.decimate.SetTargetReduction(decimateLevel / 100.0) Logging.info( "Decimating %.2f%%, preserve topology: %s" % (decimateLevel, preserveTopology), kw="visualizer" ) self.decimate.SetInput(input) input = self.decimate.GetOutput() if self.parameters["Normals"]: angle = self.parameters["FeatureAngle"] Logging.info("Generating normals at angle", angle, kw="visualizer") self.normals.SetFeatureAngle(angle) self.normals.SetInput(input) input = self.normals.GetOutput() self.mapper.SetInput(input) VisualizationModule.updateRendering(self, input) self.parent.Render()
def updateRendering(self): """ Update the Rendering of this module """ method = self.parameters["Method"] self.setMethod(method) if self.volumeModule: self.volumeModule.function = vtk.vtkVolumeRayCastIsosurfaceFunction( ) self.volumeModule.function.SetIsoValue(self.parameters["IsoValue"]) self.volumeModule.showTimepoint(self.timepoint) return if not self.init: self.init = 1 self.mapper.ColorByArrayComponent(0, 0) self.mapper.AddObserver("ProgressEvent", lib.messenger.send) lib.messenger.connect(self.mapper, 'ProgressEvent', self.updateProgress) dataUnit = self.getInputDataUnit(1) if not dataUnit: dataUnit = self.dataUnit dataCtf = dataUnit.getColorTransferFunction() if self.parameters["SolidColor"]: minval, maxval = dataCtf.GetRange() ctf = vtk.vtkColorTransferFunction() ctf.AddRGBPoint(int(minval), 0, 0, 0) r, g, b = dataCtf.GetColor(maxval) ctf.AddRGBPoint(int(minval) + 1, r, g, b) ctf.AddRGBPoint(maxval, r, g, b) else: ctf = dataCtf self.mapper.SetLookupTable(ctf) self.mapper.ScalarVisibilityOn() minVal, maxVal = self.data.GetScalarRange() self.setScalarRange(minVal, maxVal) self.mapper.SetScalarRange(minVal, maxVal) self.mapper.SetColorModeToMapScalars() opacity = self.parameters["Transparency"] opacity = (100 - opacity) / 100.0 Logging.info("Using opacity ", opacity, kw="visualizer") if opacity != 1: cullers = self.parent.getRenderer().GetCullers() cullers.InitTraversal() culler = cullers.GetNextItem() culler.SetSortingStyleToBackToFront() #print cullers, culler #self.parent.getRenderer().GetRenderWindow().SetAlphaBitPlanes(1) #self.parent.getRenderer().GetRenderWindow().SetMultiSamples(0) #self.parent.getRenderer().SetUseDepthPeeling(1) #self.parent.getRenderer().SetMaximumNumberOfPeels(100) #self.parent.getRenderer().SetOcclusionRatio(1.0) #print self.parent.getRenderer().GetLastRenderingUsedDepthPeeling() self.actor.GetProperty().SetOpacity(opacity) polyinput = self.getPolyDataInput(1) if polyinput: Logging.info("Using polydata input", kw="visualizer") self.mapper.SetInput(polyinput) VisualizationModule.updateRendering(self, polyinput) self.parent.Render() return x, y, z = self.dataUnit.getDimensions() input = self.getInput(1) input = optimize.optimize(image=input, updateExtent=(0, x - 1, 0, y - 1, 0, z - 1)) if self.parameters["Gaussian"]: Logging.info("Doing gaussian smoothing", kw="visualizer") if not self.smooth: self.smooth = vtk.vtkImageGaussianSmooth() self.smooth.SetInput(input) input = self.smooth.GetOutput() self.contour.SetInput(input) input = self.contour.GetOutput() multi = self.parameters["MultipleSurfaces"] if not multi: Logging.info("Using single isovalue=%d" % int(self.parameters["IsoValue"]), kw="visualizer") self.contour.SetValue(0, self.parameters["IsoValue"]) else: begin = self.parameters["SurfaceRangeBegin"] end = self.parameters["SurfaceRangeEnd"] n = self.parameters["SurfaceAmnt"] Logging.info("Generating %d values in range %d-%d" % (n, begin, end), kw="visualizer") self.contour.GenerateValues(n, begin, end) n = self.contour.GetNumberOfContours() for i in range(0, n): self.contour.SetValue(i, int(self.contour.GetValue(i))) #print self.contour #TODO: should decimateLevel and preserveTopology be instance variables? decimateLevel = self.parameters["Simplify"] preserveTopology = self.parameters["PreserveTopology"] if decimateLevel != 0: self.decimate.SetPreserveTopology(preserveTopology) if not preserveTopology: self.decimate.SplittingOn() self.decimate.BoundaryVertexDeletionOn() else: self.decimate.SplittingOff() self.decimate.BoundaryVertexDeletionOff() self.decimate.SetTargetReduction(decimateLevel / 100.0) Logging.info("Decimating %.2f%%, preserve topology: %s" \ % (decimateLevel, preserveTopology), kw = "visualizer") self.decimate.SetInput(input) input = self.decimate.GetOutput() if self.parameters["Normals"]: angle = self.parameters["FeatureAngle"] Logging.info("Generating normals at angle", angle, kw="visualizer") self.normals.SetFeatureAngle(angle) self.normals.SetInput(input) input = self.normals.GetOutput() self.mapper.SetInput(input) VisualizationModule.updateRendering(self, input) self.parent.Render()
def RenderCubeInVTK(filename = 'test.cube', mindatum = 0.0, maxdatum = 0.0): global renWin ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) ####################### # Read in Gaussian cube ####################### CubeData = vtk.vtkGaussianCubeReader() CubeData.SetFileName(filename) CubeData.Update() #Get intrinsic scale from data scale = sum([x**2 for x in CubeData.GetTransform().GetScale()]) CubeData.SetHBScale(scale) #scaling factor to compute bonds with hydrogens CubeData.SetBScale(scale) #scaling factor for other bonds CubeData.Update() ################### #Calculate scalings #VTK only knows how to render integer data in the interval [0,255] or [0,65535] #Here, we calculate scaling factors to map the cube data to the interval. if mindatum == maxdatum == 0.0: if DEBUG: print "Autodetecting range" mindatum, maxdatum = CubeData.GetGridOutput().GetPointData().GetScalars().GetRange() # Find the remapped value that corresponds to zero zeropoint = int(2**ColorDepth*(-mindatum)/(maxdatum-mindatum)) absmaxdatum = max(-mindatum, maxdatum) maxnegativeintensity = min(1.0, 1.0 - (absmaxdatum - abs(mindatum))/absmaxdatum) minnegativeintensity = 0.0 if zeropoint < 0: minpositiveintensity = - zeropoint/(2**ColorDepth*absmaxdatum) else: minpositiveintensity = 0.0 maxpositiveintensity = min(1.0, 1.0 - (absmaxdatum - abs(maxdatum))/absmaxdatum) if DEBUG: print "Range plotted = [%f,%f]" % (mindatum, maxdatum) print "Negative colors = [0,%d)" % max(0,zeropoint) print "Negative intensities = [%f,%f]" % (maxnegativeintensity,minnegativeintensity) print "Positive colors = (%d,%d)" % (max(0,zeropoint), 2**ColorDepth) print "Positive intensities = [%f,%f]" % (minpositiveintensity,maxpositiveintensity) print "On this scale, zero = %d" % zeropoint ################################ # Calculate opacity transfer map #The code here differentiates between two cases: #1. the scalar data are all positive, so it's just a simple linear ramp #2. the scalar data are signed, so do two linear ramps opacityTransferFunction = vtk.vtkPiecewiseFunction() if zeropoint < 0: opacityTransferFunction.AddPoint( 0, minpositiveintensity) else: opacityTransferFunction.AddPoint( 0, maxnegativeintensity) opacityTransferFunction.AddPoint(zeropoint, 0.0) opacityTransferFunction.AddPoint(2**ColorDepth-1, maxpositiveintensity) opacityTransferFunction.ClampingOn() ########################### # Create color transfer map colorTransferFunction = vtk.vtkColorTransferFunction() r1, g1, b1 = NegativeColor r2, g2, b2 = PositiveColor r0, g0, b0 = BackgroundColor if zeropoint < 0: colorTransferFunction.AddRGBPoint( 0, r1, g1, b1) else: colorTransferFunction.AddRGBPoint( 0, r1, g1, b1) colorTransferFunction.AddRGBPoint(zeropoint-1, r1, g1, b1) colorTransferFunction.AddRGBPoint(zeropoint , r0, g0, b0) colorTransferFunction.AddRGBPoint(zeropoint+1, r2, g2, b2) colorTransferFunction.AddRGBPoint(2**ColorDepth-1, r2, g2, b2) ######################## # Now apply the scalings ScaledData = vtk.vtkImageShiftScale() ScaledData.SetInput(CubeData.GetGridOutput()) ScaledData.SetShift(-mindatum) ScaledData.SetScale((2**ColorDepth-1)/(maxdatum-mindatum)) if ColorDepth == 16: ScaledData.SetOutputScalarTypeToUnsignedShort() elif ColorDepth == 8: ScaledData.SetOutputScalarTypeToUnsignedChar() else: print print "Error! Unsupported color depth given" print print "valid values are 8 or 16" print raise ValueError ############################### # Form combined coloring scheme volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(colorTransferFunction) volumeProperty.SetScalarOpacity(opacityTransferFunction) volumeProperty.SetInterpolationTypeToLinear() volumeProperty.ShadeOn() # The mapper / ray cast function know how to render the data compositeFunction = vtk.vtkVolumeRayCastCompositeFunction() volumeMapper = vtk.vtkVolumeRayCastMapper() volumeMapper.SetVolumeRayCastFunction(compositeFunction) volumeMapper.SetInput(ScaledData.GetOutput()) #Create a coarse representation #Actually a fake - won't display anything compositeFunction2 = vtk.vtkVolumeRayCastIsosurfaceFunction() compositeFunction2.SetIsoValue(2**ColorDepth-1) volumeMapperCoarse = vtk.vtkVolumeRayCastMapper() volumeMapperCoarse.SetVolumeRayCastFunction(compositeFunction2) volumeMapperCoarse.SetInput(ScaledData.GetOutput()) # Create volumetric object to be rendered # Use level of detail prop so that it won't take forever to look around volume = vtk.vtkLODProp3D() id1 = volume.AddLOD(volumeMapper, volumeProperty, 0.) volume.SetLODProperty(id1, volumeProperty) id2 = volume.AddLOD(volumeMapperCoarse, volumeProperty, 0.) volume.SetLODProperty(id2, volumeProperty) # At this point, we can position and orient the volume ################################# # End of volumetric data pipeline ################################# ######### #Contours ######### contour = vtk.vtkContourFilter() contour.SetInput(CubeData.GetGridOutput()) contour.SetNumberOfContours(1) contour.SetValue(0, 0.0) contourMapper = vtk.vtkPolyDataMapper() contourMapper.SetInput(contour.GetOutput()) contourMapper.SetScalarRange(0,0) contourMapper.GetLookupTable().SetNumberOfTableValues(1) r0, g0, b0 = NodeColor contourMapper.GetLookupTable().SetTableValue(0, r0, g0, b0, NodeAlpha) contourActor = vtk.vtkLODActor() contourActor.SetMapper(contourMapper) contourActor.GetProperty().SetOpacity(NodeAlpha) ########################################## # Create a wireframe outline of the volume ########################################## frame = vtk.vtkOutlineFilter() frame.SetInput(CubeData.GetGridOutput()) frameMapper = vtk.vtkPolyDataMapper() frameMapper.SetInput(frame.GetOutput()) frameActor = vtk.vtkLODActor() frameActor.SetMapper(frameMapper) frameActor.GetProperty().SetColor(FrameColor) frameActor.GetProperty().SetOpacity(FrameAlpha) ###################### # Draw balls for atoms ###################### Sphere = vtk.vtkSphereSource() Sphere.SetThetaResolution(16) Sphere.SetPhiResolution(16) Sphere.SetRadius(0.4) Glyph = vtk.vtkGlyph3D() Glyph.SetInput(CubeData.GetOutput()) Glyph.SetColorMode(1) Glyph.SetColorModeToColorByScalar() Glyph.SetScaleModeToScaleByVectorComponents() Glyph.SetSource(Sphere.GetOutput()) AtomsMapper = vtk.vtkPolyDataMapper() AtomsMapper.SetInput(Glyph.GetOutput()) AtomsMapper.SetImmediateModeRendering(1) AtomsMapper.UseLookupTableScalarRangeOff() AtomsMapper.SetScalarVisibility(1) AtomsMapper.SetScalarModeToDefault() Atoms = vtk.vtkLODActor() Atoms.SetMapper(AtomsMapper) ############ # Draw bonds ############ Tube = vtk.vtkTubeFilter() Tube.SetInput(CubeData.GetOutput()) BondsMapper = vtk.vtkPolyDataMapper() BondsMapper.SetInput(Tube.GetOutput()) Bonds = vtk.vtkLODActor() Bonds.SetMapper(BondsMapper) ####################### # Now compose the image ####################### if DrawVolume: ren.AddVolume(volume) if DrawNodes: ren.AddActor(contourActor) if DrawFrame: ren.AddActor(frameActor) if DrawAtoms: ren.AddActor(Atoms) if DrawBonds: ren.AddActor(Bonds) ren.SetBackground(BackgroundColor) renWin.SetSize(OutputHeight, OutputWidth) ###################################### # Let VTK do its magic and render away ###################################### renWin.Render() ################################### # Now allow user to play with image ################################### def Keypress(obj, event): #This function handles keyboard interaction key = obj.GetKeySym() if key == 'd' or key == 'F13': WriteToPNG() elif key == 'h' or key == 'question' or key =='?': PrintHelp() elif key == 'c': camera = ren.GetActiveCamera() print "Camera info:" print "------------" print "Position is: ", camera.GetPosition() print "Focal point is:", camera.GetFocalPoint() print "Orientation is:", ren.GetActiveCamera().GetOrientation() print "WXYZ", ren.GetActiveCamera().GetOrientationWXYZ() print "View up direction is:", camera.GetViewUp() print "Direction of projection is:", camera.GetDirectionOfProjection() else: if DEBUG: print 'User pressed key:', key if Interactive: iren.SetDesiredUpdateRate(25.0) #25 fps when camera is moving around iren.SetStillUpdateRate(0.0) #0 fps when camera is not moving iren.Initialize() #The default interaction style is joystick, which seems unnatural style = vtk.vtkInteractorStyleTrackballCamera() iren.SetInteractorStyle(style) iren.AddObserver("KeyPressEvent", Keypress) iren.Start() else: WriteToPNG()
def __init__(self, master): global _vtk_lib_present if not _vtk_lib_present: raise ValueError("no VTK") # Window creation tk.Frame.__init__(self, master) self.columnconfigure(0, weight=1) self.rowconfigure(0, weight=1) # Renderer and associated widget self.im_ref = None self._renWidget = vtkTkRenderWidget(self) self._ren = vtk.vtkRenderer() self._renWidget.GetRenderWindow().AddRenderer(self._ren) self._renWidget.grid(row=0, column=0, sticky=tk.E+tk.W+tk.N+tk.S) # Transfer functions and volume display options and properties self.vtk_im = vtkImageImport() self.vtk_im.SetDataScalarType(VTK_UNSIGNED_CHAR) self.im_flipy = vtk.vtkImageFlip() self.im_flipy.SetFilteredAxis(1) self.im_flipy.SetInputConnection(self.vtk_im.GetOutputPort()); self.im_flipz = vtk.vtkImageFlip() self.im_flipz.SetFilteredAxis(2) self.im_flipz.SetInputConnection(self.im_flipy.GetOutputPort()); self.opaTF = vtk.vtkPiecewiseFunction() self.colTF = vtk.vtkColorTransferFunction() self.volProp = vtk.vtkVolumeProperty() self.volProp.SetColor(self.colTF) self.volProp.SetScalarOpacity(self.opaTF) self.volProp.ShadeOn() self.volProp.SetInterpolationTypeToLinear() self.compoFun = vtk.vtkVolumeRayCastCompositeFunction() self.isosfFun = vtk.vtkVolumeRayCastIsosurfaceFunction() self.isosfFun.SetIsoValue(0) self.mipFun = vtk.vtkVolumeRayCastMIPFunction() self.volMap = vtk.vtkVolumeRayCastMapper() self.volMap.SetVolumeRayCastFunction(self.compoFun) self.volMap.SetInputConnection(self.im_flipz.GetOutputPort()) self.volume = vtk.vtkVolume() self.volume.SetMapper(self.volMap) self.volume.SetProperty(self.volProp) self.outlineData = vtk.vtkOutlineFilter() self.outlineData.SetInputConnection(self.im_flipz.GetOutputPort()) self.mapOutline = vtk.vtkPolyDataMapper() self.mapOutline.SetInputConnection(self.outlineData.GetOutputPort()) self.outline = vtk.vtkActor() self.outline.SetMapper(self.mapOutline) self.outline.GetProperty().SetColor(1, 1, 1) self._ren.AddVolume(self.volume) self._ren.AddActor(self.outline) self._ren.SetBackground(116/255.0,214/255.0,220/255.0) # Control widget self.controlbar = ttk.Frame(self) self.controlbar.grid(row=0, column=1, sticky=tk.E+tk.W+tk.N+tk.S) self.drawControlBar() self.controlbar.grid_remove() self.controlbar.state = "hidden" self.master = master # Creates the info status bar. statusbar = ttk.Frame(self) statusbar.columnconfigure(0, weight=1) statusbar.grid(row=1, column=0, columnspan=2, sticky=tk.E+tk.W) self.infos = [] for i in range(3): v = tk.StringVar(self) ttk.Label(statusbar, anchor=tk.W, textvariable=v).grid(row=0, column=i, sticky=tk.E+tk.W) self.infos.append(v) self.infos[2].set("Hit Tab for control <-") # Events bindings master.bind("<KeyPress-Tab>", self.displayControlEvent)
def RenderCubeInVTK(filename='test.cube', mindatum=0.0, maxdatum=0.0): global renWin ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) ####################### # Read in Gaussian cube ####################### CubeData = vtk.vtkGaussianCubeReader() CubeData.SetFileName(filename) CubeData.Update() #Get intrinsic scale from data scale = sum([x**2 for x in CubeData.GetTransform().GetScale()]) CubeData.SetHBScale(scale) #scaling factor to compute bonds with hydrogens CubeData.SetBScale(scale) #scaling factor for other bonds CubeData.Update() ################### #Calculate scalings #VTK only knows how to render integer data in the interval [0,255] or [0,65535] #Here, we calculate scaling factors to map the cube data to the interval. if mindatum == maxdatum == 0.0: if DEBUG: print "Autodetecting range" mindatum, maxdatum = CubeData.GetGridOutput().GetPointData( ).GetScalars().GetRange() # Find the remapped value that corresponds to zero zeropoint = int(2**ColorDepth * (-mindatum) / (maxdatum - mindatum)) absmaxdatum = max(-mindatum, maxdatum) maxnegativeintensity = min( 1.0, 1.0 - (absmaxdatum - abs(mindatum)) / absmaxdatum) minnegativeintensity = 0.0 if zeropoint < 0: minpositiveintensity = -zeropoint / (2**ColorDepth * absmaxdatum) else: minpositiveintensity = 0.0 maxpositiveintensity = min( 1.0, 1.0 - (absmaxdatum - abs(maxdatum)) / absmaxdatum) if DEBUG: print "Range plotted = [%f,%f]" % (mindatum, maxdatum) print "Negative colors = [0,%d)" % max(0, zeropoint) print "Negative intensities = [%f,%f]" % (maxnegativeintensity, minnegativeintensity) print "Positive colors = (%d,%d)" % (max(0, zeropoint), 2**ColorDepth) print "Positive intensities = [%f,%f]" % (minpositiveintensity, maxpositiveintensity) print "On this scale, zero = %d" % zeropoint ################################ # Calculate opacity transfer map #The code here differentiates between two cases: #1. the scalar data are all positive, so it's just a simple linear ramp #2. the scalar data are signed, so do two linear ramps opacityTransferFunction = vtk.vtkPiecewiseFunction() if zeropoint < 0: opacityTransferFunction.AddPoint(0, minpositiveintensity) else: opacityTransferFunction.AddPoint(0, maxnegativeintensity) opacityTransferFunction.AddPoint(zeropoint, 0.0) opacityTransferFunction.AddPoint(2**ColorDepth - 1, maxpositiveintensity) opacityTransferFunction.ClampingOn() ########################### # Create color transfer map colorTransferFunction = vtk.vtkColorTransferFunction() r1, g1, b1 = NegativeColor r2, g2, b2 = PositiveColor r0, g0, b0 = BackgroundColor if zeropoint < 0: colorTransferFunction.AddRGBPoint(0, r1, g1, b1) else: colorTransferFunction.AddRGBPoint(0, r1, g1, b1) colorTransferFunction.AddRGBPoint(zeropoint - 1, r1, g1, b1) colorTransferFunction.AddRGBPoint(zeropoint, r0, g0, b0) colorTransferFunction.AddRGBPoint(zeropoint + 1, r2, g2, b2) colorTransferFunction.AddRGBPoint(2**ColorDepth - 1, r2, g2, b2) ######################## # Now apply the scalings ScaledData = vtk.vtkImageShiftScale() ScaledData.SetInput(CubeData.GetGridOutput()) ScaledData.SetShift(-mindatum) ScaledData.SetScale((2**ColorDepth - 1) / (maxdatum - mindatum)) if ColorDepth == 16: ScaledData.SetOutputScalarTypeToUnsignedShort() elif ColorDepth == 8: ScaledData.SetOutputScalarTypeToUnsignedChar() else: print print "Error! Unsupported color depth given" print print "valid values are 8 or 16" print raise ValueError ############################### # Form combined coloring scheme volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(colorTransferFunction) volumeProperty.SetScalarOpacity(opacityTransferFunction) volumeProperty.SetInterpolationTypeToLinear() volumeProperty.ShadeOn() # The mapper / ray cast function know how to render the data compositeFunction = vtk.vtkVolumeRayCastCompositeFunction() volumeMapper = vtk.vtkVolumeRayCastMapper() volumeMapper.SetVolumeRayCastFunction(compositeFunction) volumeMapper.SetInput(ScaledData.GetOutput()) #Create a coarse representation #Actually a fake - won't display anything compositeFunction2 = vtk.vtkVolumeRayCastIsosurfaceFunction() compositeFunction2.SetIsoValue(2**ColorDepth - 1) volumeMapperCoarse = vtk.vtkVolumeRayCastMapper() volumeMapperCoarse.SetVolumeRayCastFunction(compositeFunction2) volumeMapperCoarse.SetInput(ScaledData.GetOutput()) # Create volumetric object to be rendered # Use level of detail prop so that it won't take forever to look around volume = vtk.vtkLODProp3D() id1 = volume.AddLOD(volumeMapper, volumeProperty, 0.) volume.SetLODProperty(id1, volumeProperty) id2 = volume.AddLOD(volumeMapperCoarse, volumeProperty, 0.) volume.SetLODProperty(id2, volumeProperty) # At this point, we can position and orient the volume ################################# # End of volumetric data pipeline ################################# ######### #Contours ######### contour = vtk.vtkContourFilter() contour.SetInput(CubeData.GetGridOutput()) contour.SetNumberOfContours(1) contour.SetValue(0, 0.0) contourMapper = vtk.vtkPolyDataMapper() contourMapper.SetInput(contour.GetOutput()) contourMapper.SetScalarRange(0, 0) contourMapper.GetLookupTable().SetNumberOfTableValues(1) r0, g0, b0 = NodeColor contourMapper.GetLookupTable().SetTableValue(0, r0, g0, b0, NodeAlpha) contourActor = vtk.vtkLODActor() contourActor.SetMapper(contourMapper) contourActor.GetProperty().SetOpacity(NodeAlpha) ########################################## # Create a wireframe outline of the volume ########################################## frame = vtk.vtkOutlineFilter() frame.SetInput(CubeData.GetGridOutput()) frameMapper = vtk.vtkPolyDataMapper() frameMapper.SetInput(frame.GetOutput()) frameActor = vtk.vtkLODActor() frameActor.SetMapper(frameMapper) frameActor.GetProperty().SetColor(FrameColor) frameActor.GetProperty().SetOpacity(FrameAlpha) ###################### # Draw balls for atoms ###################### Sphere = vtk.vtkSphereSource() Sphere.SetThetaResolution(16) Sphere.SetPhiResolution(16) Sphere.SetRadius(0.4) Glyph = vtk.vtkGlyph3D() Glyph.SetInput(CubeData.GetOutput()) Glyph.SetColorMode(1) Glyph.SetColorModeToColorByScalar() Glyph.SetScaleModeToScaleByVectorComponents() Glyph.SetSource(Sphere.GetOutput()) AtomsMapper = vtk.vtkPolyDataMapper() AtomsMapper.SetInput(Glyph.GetOutput()) AtomsMapper.SetImmediateModeRendering(1) AtomsMapper.UseLookupTableScalarRangeOff() AtomsMapper.SetScalarVisibility(1) AtomsMapper.SetScalarModeToDefault() Atoms = vtk.vtkLODActor() Atoms.SetMapper(AtomsMapper) ############ # Draw bonds ############ Tube = vtk.vtkTubeFilter() Tube.SetInput(CubeData.GetOutput()) BondsMapper = vtk.vtkPolyDataMapper() BondsMapper.SetInput(Tube.GetOutput()) Bonds = vtk.vtkLODActor() Bonds.SetMapper(BondsMapper) ####################### # Now compose the image ####################### if DrawVolume: ren.AddVolume(volume) if DrawNodes: ren.AddActor(contourActor) if DrawFrame: ren.AddActor(frameActor) if DrawAtoms: ren.AddActor(Atoms) if DrawBonds: ren.AddActor(Bonds) ren.SetBackground(BackgroundColor) renWin.SetSize(OutputHeight, OutputWidth) ###################################### # Let VTK do its magic and render away ###################################### renWin.Render() ################################### # Now allow user to play with image ################################### def Keypress(obj, event): #This function handles keyboard interaction key = obj.GetKeySym() if key == 'd' or key == 'F13': WriteToPNG() elif key == 'h' or key == 'question' or key == '?': PrintHelp() elif key == 'c': camera = ren.GetActiveCamera() print "Camera info:" print "------------" print "Position is: ", camera.GetPosition() print "Focal point is:", camera.GetFocalPoint() print "Orientation is:", ren.GetActiveCamera().GetOrientation() print "WXYZ", ren.GetActiveCamera().GetOrientationWXYZ() print "View up direction is:", camera.GetViewUp() print "Direction of projection is:", camera.GetDirectionOfProjection( ) else: if DEBUG: print 'User pressed key:', key if Interactive: iren.SetDesiredUpdateRate(25.0) #25 fps when camera is moving around iren.SetStillUpdateRate(0.0) #0 fps when camera is not moving iren.Initialize() #The default interaction style is joystick, which seems unnatural style = vtk.vtkInteractorStyleTrackballCamera() iren.SetInteractorStyle(style) iren.AddObserver("KeyPressEvent", Keypress) iren.Start() else: WriteToPNG()
def Panoramix(): selectedPlane1 = [0, 0, 0, 0] selectedPlane2 = [0, 0, 0, 0] def updateClippingPlane(obj, event): obj.GetCursorData(selectedPlane1) print("plane1: ", selectedPlane1) # global clippingPlane # Write some codes (ref to what you’ve done in step 2) # no more than two lines clippingPlane.SetOrigin(obj.GetOrigin()) # clippingPlane.SetNormal(obj.GetNormal()) clippingPlane.Modified() def updateClippingPlane2(obj, event): obj.GetCursorData(selectedPlane2) print("plane2: ", selectedPlane2) # global clippingPlane2 # Write some codes (ref to what you’ve done in step 2) # no more than two lines clippingPlane2.SetOrigin(obj.GetOrigin()) # clippingPlane2.SetNormal(obj.GetNormal()) clippingPlane2.Modified() reader = vtk.vtkXMLImageDataReader() reader.SetFileName(r"aneurysm.vti") reader.Update() data = reader.GetOutput() image = vtk.vtkImageMathematics() image.SetInput1Data(data) image.SetConstantC(1024) image.SetOperationToAddConstant() image.Update() output = image.GetOutput() shifter = vtk.vtkImageShiftScale() shifter.SetInputConnection(image.GetOutputPort()) shifter.SetOutputScalarTypeToUnsignedShort() shifter.Update() shifter2 = vtk.vtkImageShiftScale() shifter2.SetInputConnection(image.GetOutputPort()) shifter2.SetOutputScalarTypeToInt() shifter2.Update() otf = vtk.vtkPiecewiseFunction() ctf = vtk.vtkColorTransferFunction() otf.RemoveAllPoints() otf.AddPoint(image.GetOutput().GetScalarRange()[0] + 100, 0.0) otf.AddPoint((image.GetOutput().GetScalarRange()[0] + image.GetOutput().GetScalarRange()[1]) / 2, 0.3) otf.AddPoint(image.GetOutput().GetScalarRange()[1], 1.0) ctf.RemoveAllPoints() ctf.AddRGBPoint(image.GetOutput().GetScalarRange()[0], 1, 1, 0) ctf.AddRGBPoint(1250, 0.65, 0.7, 1.0) ctf.AddRGBPoint(image.GetOutput().GetScalarRange()[1], 0, 0, 1) propVolume = vtk.vtkVolumeProperty() propVolume.ShadeOn() propVolume.SetColor(ctf) propVolume.SetScalarOpacity(otf) propVolume.SetInterpolationTypeToLinear() #rayCast = vtk.vtkVolumeRayCastCompositeFunction() rayCast = vtk.vtkVolumeRayCastIsosurfaceFunction() rayCast.SetIsoValue(1200) #ayCast.SetCompositeMethodToInterpolateFirst() #rayCast.SetCompositeMethodToClassifyFirst() mapperVolume = vtk.vtkVolumeRayCastMapper() mapperVolume.SetVolumeRayCastFunction(rayCast) mapperVolume.SetInputConnection(shifter.GetOutputPort()) planeWidget = vtk.vtkImagePlaneWidget() planeWidget.SetInputConnection(reader.GetOutputPort()) planeWidget.SetPlaneOrientationToZAxes() planeWidget.SetSliceIndex(int(reader.GetOutput().GetDimensions()[2] / 2)) planeWidget.AddObserver("InteractionEvent", updateClippingPlane) planeWidget2 = vtk.vtkImagePlaneWidget() planeWidget2.SetInputConnection(reader.GetOutputPort()) planeWidget2.SetPlaneOrientationToZAxes() planeWidget2.SetSliceIndex( int(reader.GetOutput().GetDimensions()[2] - 15.0)) planeWidget2.AddObserver("InteractionEvent", updateClippingPlane2) clippingPlane = vtk.vtkPlane() clippingPlane.SetOrigin(planeWidget.GetOrigin()) clippingPlane.SetNormal(planeWidget.GetNormal()) clippingPlane2 = vtk.vtkPlane() clippingPlane2.SetOrigin(planeWidget2.GetOrigin()) clippingPlane2.SetNormal([0, 0, -1]) #planeWidget2.GetNormal()) # mapperVolume.AddClippingPlane(clippingPlane) # mapperVolume.AddClippingPlane(clippingPlane2) # plane1: [79.0, 86.0, 59.0, 403.0] # plane2: [123.0, 74.0, 104.0, 334.0] pointOnPlane1 = [79.0, 86.0, 59.0, 403.0] pointOnPlane2 = [123.0, 74.0, 104.0, 334.0] # output = reader.GetOutput() # points = output.GetPoints() # array = output.GetData() # numpy_nodes = vtk_to_numpy(image.GetOutput().GetPointData()) # print(numpy_nodes.shape) # print(output.GetNumberOfPoints()) gtf = vtk.vtkPiecewiseFunction() gtf.RemoveAllPoints() gtf.AddPoint(image.GetOutput().GetScalarRange()[0], 0.0) gtf.AddPoint((image.GetOutput().GetScalarRange()[0] + image.GetOutput().GetScalarRange()[1]) / 2, 0.8) gtf.AddPoint(image.GetOutput().GetScalarRange()[1], 1.0) propVolume.SetGradientOpacity(gtf) actorVolume = vtk.vtkVolume() actorVolume.SetMapper(mapperVolume) actorVolume.SetProperty(propVolume) renderWindow = vtk.vtkRenderWindow() renderer = vtk.vtkRenderer() renderWindow.AddRenderer(renderer) renderer.AddActor(actorVolume) # renderer.SetBackground(1, 1, 1); iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renderWindow) iren.Initialize() planeWidget.SetInteractor( iren) #render window interactor planeWidget.PlaceWidget() planeWidget.On() # enable the interaction planeWidget2.SetInteractor( iren) #render window interactor planeWidget.PlaceWidget() planeWidget2.On() # enable the interaction renderWindow.Render() iren.Start() # Make interactive via callback function # reader.Update() # data = reader.GetOutput() # data_range = data.GetScalarRange() # print("data_range", data_range) # imagemath = vtk.vtkImageMathematics() # imagemath.SetInputConnection(reader.GetOutputPort()) # imagemath.SetConstantC(1024.0) # imagemath.SetOperationToAddConstant() # imagemath.Update() # data = imagemath.GetOutput() # data_range = data.GetScalarRange() # print("data_range", data_range) # #Contour # #contour = vtk.vtkContourFilter() # #contour.SetInputConnection(imagemath.GetOutputPort()) # #contour.SetValue(0, 2000) # #contour.SetValue(1, 800) # #contour.GenerateValues(3,1400, 2000) # otf = vtk.vtkPiecewiseFunction() # ctf = vtk.vtkColorTransferFunction() # otf.RemoveAllPoints() # otf.AddPoint(imagemath.GetOutput().GetScalarRange()[0]+100, 0.0) # otf.AddPoint((imagemath.GetOutput().GetScalarRange()[0]+imagemath.GetOutput().GetScalarRange()[1])/2, 0.3) # otf.AddPoint(imagemath.GetOutput().GetScalarRange()[1], 1.0) # ctf.RemoveAllPoints() # ctf.AddRGBPoint(imagemath.GetOutput().GetScalarRange()[0], 1, 1, 0) # ctf.AddRGBPoint(1250, 0.65, 0.7, 1.0) # ctf.AddRGBPoint(imagemath.GetOutput().GetScalarRange()[1], 0, 0, 1) # propVolume = vtk.vtkVolumeProperty() # propVolume.ShadeOn() # propVolume.SetColor(ctf) # propVolume.SetScalarOpacity(otf) # propVolume.SetInterpolationTypeToLinear() # #rayCast = vtk.vtkVolumeRayCastMIPFunction() # rayCast = vtk.vtkVolumeRayCastIsosurfaceFunction() # rayCast.SetIsoValue(1200) # #rayCast = vtk.vtkVolumeRayCastCompositeFunction() # #rayCast.SetCompositeMethodToInterpolateFirst() # #rayCast.SetCompositeMethodToClassifyFirst() # #We will need a mapper and an actor, let`s use the vtkPolyDataMapper and the vtkActor classes. # #mapper = vtk.vtkPolyDataMapper() # #mapper.SetInputConnection(contour.GetOutputPort()) # #mapper.ScalarVisibilityOff() # shift = vtk.vtkImageShiftScale() # shift.SetInputConnection(imagemath.GetOutputPort()) # shift.SetOutputScalarTypeToUnsignedShort() # mapperVolume = vtk.vtkVolumeRayCastMapper() # mapperVolume.SetVolumeRayCastFunction(rayCast) # mapperVolume.SetInputConnection(shift.GetOutputPort()) # actorVolume = vtk.vtkVolume() # actorVolume.SetMapper(mapperVolume) # actorVolume.SetProperty(propVolume) # gtf = vtk.vtkPiecewiseFunction() # gtf.RemoveAllPoints() # gtf.AddPoint(imagemath.GetOutput().GetScalarRange()[0], 0.0) # gtf.AddPoint((imagemath .GetOutput().GetScalarRange()[0]+ imagemath.GetOutput().GetScalarRange()[1])/2, 0.8) # gtf.AddPoint(imagemath.GetOutput().GetScalarRange()[1], 1.0) # propVolume.SetGradientOpacity(gtf) # # Define FIRST plane and clipping Plane # planeWidget = vtk.vtkImagePlaneWidget() # planeWidget.SetInputConnection(reader.GetOutputPort()) # planeWidget.SetPlaneOrientationToZAxes() # #print("slice pos", planeWidget.GetSlicePosition()) # #print("go to ", planeWidget.GetSlicePosition()+410.0) # #planeWidget.SetOrigin([-192.00000375, -318.00000375, -300.5]) # #print("slice pos", planeWidget.GetSlicePosition()) # #planeWidget.SetSliceIndex(0) #int(reader.GetOutput().GetDimensions()[2]/2)) # clippingPlane = vtk.vtkPlane() # # print(planeWidget.GetOrigin()) # #clippingPlane.SetOrigin(planeWidget.GetOrigin()) # origin = [-192.00000375, -318.00000375, -300.5] # clippingPlane.SetOrigin(origin) # normal = [planeWidget.GetNormal()[0],planeWidget.GetNormal()[1],planeWidget.GetNormal()[2]] # print("normal", normal) # clippingPlane.SetNormal(normal) # def updateClippingPlane(obj, event): # print(obj.GetCurrentImageValue()) # #clippingPlane.SetOrigin(obj.GetOrigin()) # #lippingPlane.Modified() # planeWidget.AddObserver("InteractionEvent", updateClippingPlane) # # Define SECOND plane and clipping Plane # ## planeWidget2 = vtk.vtkImagePlaneWidget() # ## planeWidget2.SetInputConnection(reader.GetOutputPort()) # ## planeWidget2.SetPlaneOrientationToZAxes() # ## planeWidget2.SetSliceIndex(int(reader.GetOutput().GetDimensions()[2])) # ## print("normal:", planeWidget2.GetNormal()) # ## clippingPlane2 = vtk.vtkPlane() # ## clippingPlane2.SetOrigin(planeWidget2.GetOrigin()) # ## normal = [planeWidget2.GetNormal()[0],planeWidget2.GetNormal()[1],-planeWidget2.GetNormal()[2]] # ## print("normal mod:", normal) # ## clippingPlane2.SetNormal(normal) # ## def updateClippingPlane2(obj, event): # ## clippingPlane2.SetOrigin(obj.GetOrigin()) # ## clippingPlane2.Modified() # #planeWidget2.AddObserver("InteractionEvent", updateClippingPlane2) # # Add planes to Mapper # planes = vtk.vtkPlaneCollection() # planes.AddItem(clippingPlane) # ## planes.AddItem(clippingPlane2) # mapperVolume.SetClippingPlanes(planes) # #Let`s add our render window and an interactor: # renderWindow = vtk.vtkRenderWindow() # renderer = vtk.vtkRenderer() # renderWindow.AddRenderer(renderer) # renderer.AddActor(actorVolume) # iren = vtk.vtkRenderWindowInteractor() # iren.SetRenderWindow(renderWindow) # iren.Initialize() # ## planeWidget2.SetInteractor(iren)# render window interactor # ## planeWidget2.PlaceWidget() # ## planeWidget2.On() # enable the interaction # planeWidget.SetInteractor(iren)# render window interactor # planeWidget.PlaceWidget() # planeWidget.On() # enable the interaction # renderWindow.Render() # iren.Start()
def volume_render(field, outfile, maxopacity=1.0, cmap='bone', size=600, elevation=45, azimuth=45, bkg=(0.0, 0.0, 0.0), opacitycut=0.35, offscreen=False, rayfunction='smart'): """ Uses vtk to make render an image of a field, with control over the camera angle and colormap. Input Parameters ---------------- field : np.ndarray 3D array of the field to render. outfile : string The save name of the image. maxopacity : Float Default is 1.0 cmap : matplotlib colormap string Passed to cmap2colorfunc. Default is bone. size : 2-element list-like of ints or Int The size of the final rendered image. elevation : Numeric The elevation of the camera angle, in degrees. Default is 45 azimuth : Numeric The azimuth of the camera angle, in degrees. Default is 45 bkg : Tuple of floats 3-element tuple of floats on [0,1] of the background image color. Default is (0., 0., 0.). """ sh = field.shape dataImporter = vtk.vtkImageImport() dataImporter.SetDataScalarTypeToUnsignedChar() data_string = field.tostring() dataImporter.SetNumberOfScalarComponents(1) dataImporter.CopyImportVoidPointer(data_string, len(data_string)) dataImporter.SetDataExtent(0, sh[2] - 1, 0, sh[1] - 1, 0, sh[0] - 1) dataImporter.SetWholeExtent(0, sh[2] - 1, 0, sh[1] - 1, 0, sh[0] - 1) alphaChannelFunc = vtk.vtkPiecewiseFunction() alphaChannelFunc.AddPoint(0, 0.0) alphaChannelFunc.AddPoint(int(255 * opacitycut), maxopacity) volumeProperty = vtk.vtkVolumeProperty() colorFunc = cmap2colorfunc(cmap) volumeProperty.SetColor(colorFunc) volumeProperty.SetScalarOpacity(alphaChannelFunc) volumeMapper = vtk.vtkVolumeRayCastMapper() if rayfunction == 'mip': comp = vtk.vtkVolumeRayCastMIPFunction() comp.SetMaximizeMethodToOpacity() elif rayfunction == 'avg': comp = vtk.vtkVolumeRayCastCompositeFunction() elif rayfunction == 'iso': comp = vtk.vtkVolumeRayCastIsosurfaceFunction() comp.SetIsoValue(maxopacity / 2) else: comp = vtk.vtkVolumeRayCastIsosurfaceFunction() volumeMapper.SetSampleDistance(0.1) volumeMapper.SetVolumeRayCastFunction(comp) if rayfunction == 'smart': volumeMapper = vtk.vtkSmartVolumeMapper() volumeMapper.SetInputConnection(dataImporter.GetOutputPort()) volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) light = vtk.vtkLight() light.SetLightType(vtk.VTK_LIGHT_TYPE_HEADLIGHT) light.SetIntensity(5.5) light.SwitchOn() renderer = vtk.vtkRenderer() renderWin = vtk.vtkRenderWindow() renderWin.AddRenderer(renderer) renderWin.SetOffScreenRendering(1) if not hasattr(size, '__iter__'): size = (size, size) renderer.AddVolume(volume) renderer.AddLight(light) renderer.SetBackground(*bkg) renderWin.SetSize(*size) if offscreen: renderWin.SetOffScreenRendering(1) def exitCheck(obj, event): if obj.GetEventPending() != 0: obj.SetAbortRender(1) renderWin.AddObserver("AbortCheckEvent", exitCheck) renderInteractor = vtk.vtkRenderWindowInteractor() renderInteractor.Initialize() renderWin.Render() renderInteractor.Start() #writer = vtk.vtkFFMPEGWriter() #writer.SetQuality(2) #writer.SetRate(24) #w2i = vtk.vtkWindowToImageFilter() #w2i.SetInput(renderWin) #writer.SetInputConnection(w2i.GetOutputPort()) #writer.SetFileName('movie.avi') #writer.Start() #writer.End() writer = vtk.vtkPNGWriter() w2i = vtk.vtkWindowToImageFilter() w2i.SetInput(renderWin) writer.SetInputConnection(w2i.GetOutputPort()) renderWin.Render() ac = renderer.GetActiveCamera() ac.Elevation(elevation) ac.Azimuth(azimuth) renderer.ResetCameraClippingRange() renderWin.Render() w2i.Modified() writer.SetFileName(outfile) writer.Write()