def put_img_on_canvas(self,filename,zoom=1,xOffset=0,yOffset=0,*args,**kargs): readerFactory = vtk.vtkImageReader2Factory() reader = readerFactory.CreateImageReader2(filename) reader.SetFileName(filename) reader.Update() imageData = reader.GetOutput() a = vtk.vtkImageActor() a.GetMapper().SetInputConnection(reader.GetOutputPort()) origin = imageData.GetOrigin() spc = imageData.GetSpacing() ext = imageData.GetExtent() ren = vtk.vtkRenderer() r,g,b = self.canvas.backgroundcolor ren.SetBackground(r/255.0, g/255.0, b/255.0) cam = ren.GetActiveCamera() cam.ParallelProjectionOn() width = (ext[1]-ext[0])*spc[0] height = (ext[3]-ext[2])*spc[1] xoff = width*xOffset/zoom/200. yoff = height*yOffset/zoom/200. xc = origin[0] + .5*(ext[0]+ext[1])*spc[0] yc = origin[1] + .5*(ext[2]+ext[3])*spc[1] yd = (ext[3]-ext[2])*spc[1] d = cam.GetDistance() cam.SetParallelScale(.5*yd/zoom) cam.SetFocalPoint(xc+xoff,yc+yoff,0.) cam.SetPosition(xc+xoff,yc+yoff,d) ren.AddActor(a) self.renWin.AddRenderer(ren) self.renWin.Render() return
def put_img_on_canvas(self,filename,zoom=1,xOffset=0,yOffset=0,*args,**kargs): self.hideGUI() readerFactory = vtk.vtkImageReader2Factory() reader = readerFactory.CreateImageReader2(filename) reader.SetFileName(filename) reader.Update() imageData = reader.GetOutput() a = vtk.vtkImageActor() a.GetMapper().SetInputConnection(reader.GetOutputPort()) origin = imageData.GetOrigin() spc = imageData.GetSpacing() ext = imageData.GetExtent() ren = self.createRenderer() cam = ren.GetActiveCamera() cam.ParallelProjectionOn() width = (ext[1]-ext[0])*spc[0] height = (ext[3]-ext[2])*spc[1] xoff = width*xOffset/zoom/200. yoff = height*yOffset/zoom/200. xc = origin[0] + .5*(ext[0]+ext[1])*spc[0] yc = origin[1] + .5*(ext[2]+ext[3])*spc[1] yd = (ext[3]-ext[2])*spc[1] d = cam.GetDistance() cam.SetParallelScale(.5*yd/zoom) cam.SetFocalPoint(xc+xoff,yc+yoff,0.) cam.SetPosition(xc+xoff,yc+yoff,d) ren.AddActor(a) layer = max(self.renWin.GetNumberOfLayers() - 2, 0) ren.SetLayer(layer) self.renWin.AddRenderer(ren) self.showGUI(render=False) self.renWin.Render() return
def ExtractComponent():
# Read the image
InputDir = 'C:\\Users\\chenjiaxing\\Desktop\\CT-Data\\png\\WU_Coronal\\'
OutputDir = 'C:\\Users\\chenjiaxing\\Desktop\\CT-Data\\png\\WU_Coronal_Ext\\'
filetype = '.png'
filelist = os.listdir(InputDir)
for files in filelist:
InputFileName = os.path.join(InputDir, files) #输入的的文件路径
if os.path.isdir(InputFileName): #如果是文件夹则跳过
continue
fileExt = os.path.splitext(files)[1] #获取原文件的后缀
if fileExt != '.png': #文件的后缀不是png则跳过, 不能用is not
print(fileExt)
continue
#读取图像
readerFactory = vtk.vtkImageReader2Factory()
reader = readerFactory.CreateImageReader2(InputFileName)
reader.SetFileName(InputFileName)
reader.Update()
#提取红色通道的数据
extractRedFilter = vtk.vtkImageExtractComponents()
extractRedFilter.SetInputConnection(reader.GetOutputPort())
extractRedFilter.SetComponents(0)
extractRedFilter.Update()
#输入图像
OutputFileName = os.path.join(OutputDir,
files) #新的文件路径,因为是随机访问的，使用文件原来的名字以保持对应
writer = vtk.vtkPNGWriter()
writer.SetFileName(OutputFileName)
writer.SetInputData(extractRedFilter.GetOutput())
writer.Write()
def GetTexture(file_name):
"""
Read an image and convert it to a texture
:param file_name: The image path.
:return: The texture.
"""
# Read the image which will be the texture
path, extension = os.path.splitext(file_name)
extension = extension.lower()
# Make the extension lowercase
extension = extension.lower()
validExtensions = ['.jpg', '.png', '.bmp', '.tiff', '.pnm', '.pgm', '.ppm']
texture = vtk.vtkTexture()
if not os.path.isfile(file_name):
print('Nonexistent texture file:', file_name)
return texture
if extension not in validExtensions:
print('Unable to read the texture file:', file_name)
return texture
# Read the images
readerFactory = vtk.vtkImageReader2Factory()
imgReader = readerFactory.CreateImageReader2(file_name)
imgReader.SetFileName(file_name)
texture.SetInputConnection(imgReader.GetOutputPort())
texture.Update()
texture.InterpolateOn()
texture.MipmapOn()
return texture
def GetTexture(image_path):
"""
Read an image and convert it to a texture
:param image_path: The image path.
:return: The texture.
"""
# Read the image which will be the texture
path = Path(image_path)
if not path.is_file():
print('Nonexistent texture file:', path)
return None
extension = path.suffix.lower()
validExtensions = ['.jpg', '.png', '.bmp', '.tiff', '.pnm', '.pgm', '.ppm']
if extension not in validExtensions:
print('Unable to read the texture file (wrong extension):', path)
return None
texture = vtk.vtkTexture()
# Read the images
readerFactory = vtk.vtkImageReader2Factory()
imgReader = readerFactory.CreateImageReader2(str(path))
imgReader.SetFileName(str(path))
texture.SetInputConnection(imgReader.GetOutputPort())
texture.Update()
return texture
def main():
img_name = ""
readerFactory = vtk.vtkImageReader2Factory()
imgReader = readerFactory.CreateImageReader2(img_name)
imgReader.SetFileName(img_name)
imgReader.Update()
image = imgReader.GetOutput()
center = [0,0]
center[0] = (image.GetExtent()[1] + image.GetExtent()[0])/2
center[1] = (image.GetExtent()[3] + image.GetExtent()[2])/2
radius = image.GetExtent()[3]*2/5if image.GetExtent()[1]>image.GetExtent()[3]else image.GetExtent()[1]*2/5
drawing = vtk.vtkImageCanvasSource2D()
# draw circle
drawing.SetNumberOfScalarComponents(3)
drawing.SetScalarTypeToUnsignedChar()
drawing.SetExtent(image.GetExent())
drawing.SetDrawColor(0,0,0)
drawing.FillBox(image.GetExent()[0],image.GetExent()[1],
image.GetExent()[2],image.GetExtent()[3])
drawing.SetDrawColor(255,255,255)
drawing.DrawCircle(center[0],center[1],radius)
def put_img_on_canvas(self,filename,zoom=1,xOffset=0,yOffset=0,*args,**kargs): self.hideGUI() readerFactory = vtk.vtkImageReader2Factory() reader = readerFactory.CreateImageReader2(filename) reader.SetFileName(filename) reader.Update() imageData = reader.GetOutput() a = vtk.vtkImageActor() a.GetMapper().SetInputConnection(reader.GetOutputPort()) origin = imageData.GetOrigin() spc = imageData.GetSpacing() ext = imageData.GetExtent() ren = self.createRenderer() cam = ren.GetActiveCamera() cam.ParallelProjectionOn() width = (ext[1]-ext[0])*spc[0] height = (ext[3]-ext[2])*spc[1] xoff = width*xOffset/zoom/200. yoff = height*yOffset/zoom/200. xc = origin[0] + .5*(ext[0]+ext[1])*spc[0] yc = origin[1] + .5*(ext[2]+ext[3])*spc[1] yd = (ext[3]-ext[2])*spc[1] d = cam.GetDistance() cam.SetParallelScale(.5*yd/zoom) cam.SetFocalPoint(xc+xoff,yc+yoff,0.) cam.SetPosition(xc+xoff,yc+yoff,d) ren.AddActor(a) layer = max(self.renWin.GetNumberOfLayers() - 2, 0) ren.SetLayer(layer) self.renWin.AddRenderer(ren) self.showGUI(render=False) self.renWin.Render() return
def main(argv):
colors = vtk.vtkNamedColors()
if (len(argv) < 2):
print("Usage: " + argv[0] + " texture(.png/.ppm) e.g. earth.ppm" +
" [translate]")
sys.exit(-1)
translate = [0.0, 0.0, 0.0]
if len(argv) > 2:
translate[0] = float(argv[2])
else:
translate[0] = 0.0
translate[1] = 0.0
translate[2] = 0.0
print("%f, %f, %f" % (translate[0], translate[1], translate[2]))
# Create a sphere with texture coordinates
source = vtk.vtkTexturedSphereSource()
source.SetThetaResolution(100)
source.SetPhiResolution(100)
# Read texture file
readerFactory = vtk.vtkImageReader2Factory()
# imageReader = vtk.vtkImageReader2()
imageReader = readerFactory.CreateImageReader2(argv[1])
imageReader.SetFileName(argv[1])
# Create texture
texture = vtk.vtkTexture()
texture.SetInputConnection(imageReader.GetOutputPort())
transformTexture = vtk.vtkTransformTextureCoords()
transformTexture.SetInputConnection(source.GetOutputPort())
transformTexture.SetPosition(translate)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(transformTexture.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.SetTexture(texture)
renderer = vtk.vtkRenderer()
renderer.AddActor(actor)
renderer.SetBackground(colors.GetColor3d("Black"))
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindow.SetWindowName("TexturedSphere")
renWinInteractor = vtk.vtkRenderWindowInteractor()
renWinInteractor.SetRenderWindow(renderWindow)
renderWindow.Render()
renWinInteractor.Start()
def main():
fileName = get_program_parameters()
colors = vtk.vtkNamedColors()
# Load in the texture map. A texture is any unsigned char image. If it
# is not of this type, you will have to map it through a lookup table
# or by using vtkImageShiftScale.
#
readerFactory = vtk.vtkImageReader2Factory()
textureFile = readerFactory.CreateImageReader2(fileName)
textureFile.SetFileName(fileName)
textureFile.Update()
atext = vtk.vtkTexture()
atext.SetInputConnection(textureFile.GetOutputPort())
atext.InterpolateOn()
# Create a plane source and actor. The vtkPlanesSource generates
# texture coordinates.
#
plane = vtk.vtkPlaneSource()
planeMapper = vtk.vtkPolyDataMapper()
planeMapper.SetInputConnection(plane.GetOutputPort())
planeActor = vtk.vtkActor()
planeActor.SetMapper(planeMapper)
planeActor.SetTexture(atext)
# Create the RenderWindow, Renderer and Interactor.
renderer = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(renderer)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Add the actors to the renderer, set the background and size.
renderer.AddActor(planeActor)
renderer.SetBackground(colors.GetColor3d('DarkSlateGray'))
renWin.SetSize(640, 480)
renWin.SetWindowName('TexturePlane')
# render the image
renWin.Render()
renderer.ResetCamera()
renderer.GetActiveCamera().Elevation(-30)
renderer.GetActiveCamera().Roll(-20)
renderer.ResetCameraClippingRange()
renWin.Render()
iren.Start()
def get_source(filename):
#print 'sourceVTK2: creating Reader for ', filename #code prior version 0.0.1
logging.debug(u'sourceVTK2: creating Reader for '+unicode(filename))
# aqui para no importarlo siempre
import vtk
filenameencoded = filename.encode(sys.getfilesystemencoding()) # necesario en Windows por lo menos
if filename.lower().endswith('.pvd'):
times = FilePVD.read(filename)
type = 'pvd'
src = [type,filenameencoded,times]
# fileinitime = times[0].get('file')
# filenameencoded = fileinitime.encode(sys.getfilesystemencoding())
# if fileinitime.lower().endswith('.vtk'):
# type = 'vtk'
# src = vtk.vtkUnstructuredGridReader()
# src.ReadAllScalarsOn()
# src.ReadAllVectorsOn()
# src.SetFileName(filenameencoded)
# elif fileinitime.lower().endswith('.vtu'):
# type = 'vtu'
# src = vtk.vtkXMLUnstructuredGridReader()
# src.SetFileName(filenameencoded)
else:
if filename.lower().endswith('.vtk'):
type = 'vtk'
src = vtk.vtkUnstructuredGridReader()
src.ReadAllScalarsOn()
src.ReadAllVectorsOn()
src.SetFileName(filenameencoded)
elif filename.lower().endswith('.vtu'):
type = 'vtu'
src = vtk.vtkXMLUnstructuredGridReader()
src.SetFileName(filenameencoded)
elif filename.lower().endswith(vtkimagefileformats):
createReader = vtk.vtkImageReader2Factory()
src = createReader.CreateImageReader2(filename)
src.SetFileName(filename)
else:
return 'sourceVTK2: file extension of \''+filename+'\' not recognized'
try:
src.Update()
except Exception, x:
return 'sourceVTK2: unable to read '+ type +' file: \''+filename+'\': ' + repr(x)
unselect_source(src)
def load_image(path_to_image):
file_ext = fu.get_file_extension(path_to_image)
if (file_ext == "vti"):
print("Opening as '.vti' file.")
image_reader = vtk.vtkXMLImageDataReader()
elif (file_ext == "nii"):
print("Opening as '.nii' file.")
image_reader = vtk.vtkNIFTIImageReader()
else:
print("Attempting to load as other vtk image.")
reader_factory = vtk.vtkImageReader2Factory()
image_reader = reader_factory.CreateImageReader2(path_to_image)
image_reader.SetFileName(path_to_image)
image_reader.Update()
image = image_reader.GetOutput()
return image
def ReadCubeMap(folderRoot, fileRoot, ext, key):
"""
Read the cube map.
:param folderRoot: The folder where the cube maps are stored.
:param fileRoot: The root of the individual cube map file names.
:param ext: The extension of the cube map files.
:param key: The key to data used to build the full file name.
:return: The cubemap texture.
"""
# A map of cube map naming conventions and the corresponding file name
# components.
fileNames = {
0: ['right', 'left', 'top', 'bottom', 'front', 'back'],
1: ['posx', 'negx', 'posy', 'negy', 'posz', 'negz'],
2: ['-px', '-nx', '-py', '-ny', '-pz', '-nz'],
3: ['0', '1', '2', '3', '4', '5']
}
if key in fileNames:
fns = fileNames[key]
else:
print('ReadCubeMap(): invalid key, unable to continue.')
sys.exit()
texture = vtk.vtkTexture()
texture.CubeMapOn()
# Build the file names.
for i in range(0, len(fns)):
fns[i] = Path(str(folderRoot) + fileRoot + fns[i]).with_suffix(ext)
if not fns[i].is_file():
print('Nonexistent texture file:', fns[i])
return texture
i = 0
for fn in fns:
# Read the images
readerFactory = vtk.vtkImageReader2Factory()
imgReader = readerFactory.CreateImageReader2(str(fn))
imgReader.SetFileName(str(fn))
flip = vtk.vtkImageFlip()
flip.SetInputConnection(imgReader.GetOutputPort())
flip.SetFilteredAxis(1) # flip y axis
texture.SetInputConnection(i, flip.GetOutputPort(0))
i += 1
texture.MipmapOn()
texture.InterpolateOn()
return texture
def main(argv):
colors = vtk.vtkNamedColors()
# Parse input arguments
if len(argv) != 3:
print("Usage: %s Input1Filename Input2Filename e.g. Ox.jpg Gourds2.jpg" % (argv[0]))
return
# Read the images
readerFactory = vtk.vtkImageReader2Factory()
imgReader1 = vtk.vtkImageReader2()
imgReader1 = readerFactory.CreateImageReader2(argv[1])
imgReader1.SetFileName(argv[1])
imgReader2 = vtk.vtkImageReader2()
# imgReader2.TakeReference(readerFactory.CreateImageReader2(argv[2]))
imgReader2 = readerFactory.CreateImageReader2(argv[2])
imgReader2.SetFileName(argv[2])
# Combine the images (blend takes multiple connections on the 0th input port)
blend = vtk.vtkImageBlend()
blend.AddInputConnection(imgReader1.GetOutputPort())
blend.AddInputConnection(imgReader2.GetOutputPort())
blend.SetOpacity(0, 0.5)
blend.SetOpacity(1, 0.5)
# Display the result
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
imageViewer = vtk.vtkImageViewer2()
imageViewer.SetInputConnection(blend.GetOutputPort())
imageViewer.SetupInteractor(renderWindowInteractor)
imageViewer.GetRenderer().ResetCamera()
imageViewer.GetRenderer().SetBackground(colors.GetColor3d("Peru"))
imageViewer.GetRenderWindow().SetWindowName("CombineImages")
imageViewer.GetRenderer().Render()
renderWindowInteractor.Initialize()
renderWindowInteractor.Start()
return 0
def read_file(file_name):
import os
if(file_name):
path, extension = os.path.splitext(file_name)
extension = extension.lower()
if extension == ".vti":
reader = vtk.vtkXMLImageDataReader()
reader.SetFileName(file_name)
elif extension == ".vtp":
reader = vtk.vtkXMLPolyDataReader()
reader.SetFileName(file_name)
elif extension == ".jpg":
readerFactory = vtk.vtkImageReader2Factory()
img_file = readerFactory.CreateImageReader2(file_name)
img_file.SetFileName(file_name)
img_file.Update()
reader = img_file
else:
# the file provided doesn't match the accepted extenstions
reader = None
else:
reader = None
return reader
#!/usr/bin/env python
import vtk
from vtk.test import Testing
from vtk.util.misc import vtkGetDataRoot
VTK_DATA_ROOT = vtkGetDataRoot()
# Image pipeline
createReader = vtk.vtkImageReader2Factory()
reader = createReader.CreateImageReader2("" + str(VTK_DATA_ROOT) +
"/Data/beach.jpg")
reader.SetFileName("" + str(VTK_DATA_ROOT) + "/Data/beach.jpg")
viewer = vtk.vtkImageViewer()
viewer.SetInputConnection(reader.GetOutputPort())
viewer.SetColorWindow(256)
viewer.SetColorLevel(127.5)
#make interface
viewer.Render()
reader.UnRegister(viewer) # not needed in python
# --- end of script --
def main():
colors = vtk.vtkNamedColors()
fileName = get_program_parameters()
# Read the image.
readerFactory = vtk.vtkImageReader2Factory()
reader = readerFactory.CreateImageReader2(fileName)
reader.SetFileName(fileName)
reader.Update()
cast = vtk.vtkImageCast()
cast.SetInputConnection(reader.GetOutputPort())
cast.SetOutputScalarTypeToDouble()
# Get rid of the discrete scalars.
smooth = vtk.vtkImageGaussianSmooth()
smooth.SetInputConnection(cast.GetOutputPort())
smooth.SetStandardDeviations(0.8, 0.8, 0)
m1 = vtk.vtkSphere()
m1.SetCenter(310, 130, 0)
m1.SetRadius(0)
m2 = vtk.vtkSampleFunction()
m2.SetImplicitFunction(m1)
m2.SetModelBounds(0, 264, 0, 264, 0, 1)
m2.SetSampleDimensions(264, 264, 1)
m3 = vtk.vtkImageShiftScale()
m3.SetInputConnection(m2.GetOutputPort())
m3.SetScale(0.000095)
div = vtk.vtkImageMathematics()
div.SetInputConnection(0, smooth.GetOutputPort())
div.SetInputConnection(1, m3.GetOutputPort())
div.SetOperationToMultiply()
# Create the actors.
colorWindow = 256.0
colorLevel = 127.5
originalActor = vtk.vtkImageActor()
originalActor.GetMapper().SetInputConnection(cast.GetOutputPort())
originalActor.GetProperty().SetColorWindow(colorWindow)
originalActor.GetProperty().SetColorLevel(colorLevel)
filteredActor = vtk.vtkImageActor()
filteredActor.GetMapper().SetInputConnection(div.GetOutputPort())
# Define the viewport ranges.
# (xmin, ymin, xmax, ymax)
originalViewport = [0.0, 0.0, 0.5, 1.0]
filteredViewport = [0.5, 0.0, 1.0, 1.0]
# Setup the renderers.
originalRenderer = vtk.vtkRenderer()
originalRenderer.SetViewport(originalViewport)
originalRenderer.AddActor(originalActor)
originalRenderer.ResetCamera()
originalRenderer.SetBackground(colors.GetColor3d("SlateGray"))
filteredRenderer = vtk.vtkRenderer()
filteredRenderer.SetViewport(filteredViewport)
filteredRenderer.AddActor(filteredActor)
filteredRenderer.ResetCamera()
filteredRenderer.SetBackground(colors.GetColor3d("LightSlateGray"))
renderWindow = vtk.vtkRenderWindow()
renderWindow.SetSize(600, 300)
renderWindow.AddRenderer(originalRenderer)
renderWindow.AddRenderer(filteredRenderer)
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
style = vtk.vtkInteractorStyleImage()
renderWindowInteractor.SetInteractorStyle(style)
renderWindowInteractor.SetRenderWindow(renderWindow)
renderWindowInteractor.Initialize()
renderWindowInteractor.Start()
def main():
# Read the image
fileName = 'C:\\Users\\chenjiaxing\\Pictures\\12.png'
OutPut = 'C:\\Users\\chenjiaxing\\Pictures\\12R.png'
readerFactory = vtk.vtkImageReader2Factory()
reader = readerFactory.CreateImageReader2(fileName)
reader.SetFileName(fileName)
reader.Update()
extractRedFilter = vtk.vtkImageExtractComponents()
extractRedFilter.SetInputConnection(reader.GetOutputPort())
extractRedFilter.SetComponents(0)
extractRedFilter.Update()
extractGreenFilter = vtk.vtkImageExtractComponents()
extractGreenFilter.SetInputConnection(reader.GetOutputPort())
extractGreenFilter.SetComponents(1)
extractGreenFilter.Update()
extractBlueFilter = vtk.vtkImageExtractComponents()
extractBlueFilter.SetInputConnection(reader.GetOutputPort())
extractBlueFilter.SetComponents(2)
extractBlueFilter.Update()
# Create actors
inputActor = vtk.vtkImageActor()
inputActor.GetMapper().SetInputConnection(reader.GetOutputPort())
redActor = vtk.vtkImageActor()
redActor.GetMapper().SetInputConnection(extractRedFilter.GetOutputPort())
greenActor = vtk.vtkImageActor()
greenActor.GetMapper().SetInputConnection(extractGreenFilter.GetOutputPort())
blueActor = vtk.vtkImageActor()
blueActor.GetMapper().SetInputConnection(extractBlueFilter.GetOutputPort())
# Define viewport ranges
# (xmin, ymin, xmax, ymax)
inputViewport = [0.0, 0.0, 0.25, 1.0]
redViewport = [0.25, 0.0, 0.5, 1.0]
greenViewport = [0.5, 0.0, 0.75, 1.0]
blueViewport = [0.75, 0.0, 1.0, 1.0]
colors = vtk.vtkNamedColors()
# Setup renderers
inputRenderer = vtk.vtkRenderer()
inputRenderer.SetViewport(inputViewport)
inputRenderer.AddActor(inputActor)
inputRenderer.ResetCamera()
inputRenderer.SetBackground(colors.GetColor3d("Snow"))
redRenderer = vtk.vtkRenderer()
redRenderer.SetViewport(redViewport)
redRenderer.AddActor(redActor)
redRenderer.ResetCamera()
redRenderer.SetBackground(colors.GetColor3d("Tomato"))
greenRenderer = vtk.vtkRenderer()
greenRenderer.SetViewport(greenViewport)
greenRenderer.AddActor(greenActor)
greenRenderer.ResetCamera()
greenRenderer.SetBackground(colors.GetColor3d("Mint"))
blueRenderer = vtk.vtkRenderer()
blueRenderer.SetViewport(blueViewport)
blueRenderer.AddActor(blueActor)
blueRenderer.ResetCamera()
blueRenderer.SetBackground(colors.GetColor3d("Peacock"))
# Setup render window
renderWindow = vtk.vtkRenderWindow()
renderWindow.SetSize(1000, 250)
renderWindow.AddRenderer(inputRenderer)
renderWindow.AddRenderer(redRenderer)
renderWindow.AddRenderer(greenRenderer)
renderWindow.AddRenderer(blueRenderer)
# Setup render window interactor
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
style = vtk.vtkInteractorStyleImage()
renderWindowInteractor.SetInteractorStyle(style)
# Render and start interaction
renderWindowInteractor.SetRenderWindow(renderWindow)
renderWindow.Render()
renderWindowInteractor.Initialize()
renderWindowInteractor.Start()
writer = vtk.vtkPNGWriter()
writer.SetFileName(OutPut)
writer.SetInputData(extractGreenFilter.GetOutput())
writer.Write()
def main():
colors = vtk.vtkNamedColors()
fileName = get_program_parameters()
# Read the image.
readerFactory = vtk.vtkImageReader2Factory()
reader = readerFactory.CreateImageReader2(fileName)
reader.SetFileName(fileName)
reader.Update()
# Pipelines
constantPad = vtk.vtkImageConstantPad()
constantPad.SetInputConnection(reader.GetOutputPort())
constantPad.SetConstant(800)
constantPad.SetOutputWholeExtent(-127, 383, -127, 383, 22, 22)
mirrorPad = vtk.vtkImageMirrorPad()
mirrorPad.SetInputConnection(reader.GetOutputPort())
mirrorPad.SetOutputWholeExtent(constantPad.GetOutputWholeExtent())
# Create actors
constantPadColor = vtk.vtkImageMapToWindowLevelColors()
constantPadColor.SetWindow(2000)
constantPadColor.SetLevel(1000)
constantPadColor.SetInputConnection(constantPad.GetOutputPort())
constantPadActor = vtk.vtkImageActor()
constantPadActor.GetMapper().SetInputConnection(
constantPadColor.GetOutputPort())
constantPadActor.GetProperty().SetInterpolationTypeToNearest()
mirrorPadColor = vtk.vtkImageMapToWindowLevelColors()
mirrorPadColor.SetWindow(2000)
mirrorPadColor.SetLevel(1000)
mirrorPadColor.SetInputConnection(mirrorPad.GetOutputPort())
mirrorPadActor = vtk.vtkImageActor()
mirrorPadActor.GetMapper().SetInputConnection(
mirrorPadColor.GetOutputPort())
mirrorPadActor.GetProperty().SetInterpolationTypeToNearest()
# Setup the renderers.
constantPadRenderer = vtk.vtkRenderer()
constantPadRenderer.SetViewport(0.0, 0.0, 0.5, 1.0)
constantPadRenderer.AddActor(constantPadActor)
constantPadRenderer.ResetCamera()
constantPadRenderer.SetBackground(colors.GetColor3d("SlateGray"))
mirrorPadRenderer = vtk.vtkRenderer()
mirrorPadRenderer.SetViewport(0.5, 0.0, 1.0, 1.0)
mirrorPadRenderer.AddActor(mirrorPadActor)
mirrorPadRenderer.SetActiveCamera(constantPadRenderer.GetActiveCamera())
mirrorPadRenderer.SetBackground(colors.GetColor3d("LightSlateGray"))
renderWindow = vtk.vtkRenderWindow()
renderWindow.SetSize(600, 300)
renderWindow.SetWindowName('Pad')
renderWindow.AddRenderer(constantPadRenderer)
renderWindow.AddRenderer(mirrorPadRenderer)
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
style = vtk.vtkInteractorStyleImage()
renderWindowInteractor.SetInteractorStyle(style)
renderWindowInteractor.SetRenderWindow(renderWindow)
constantPadRenderer.GetActiveCamera().Dolly(1.2)
constantPadRenderer.ResetCameraClippingRange()
renderWindowInteractor.Initialize()
renderWindowInteractor.Start()
def main():
# colors = vtk.vtkNamedColors()
fileName = get_program_parameters()
# Read the image.
readerFactory = vtk.vtkImageReader2Factory()
reader = readerFactory.CreateImageReader2(fileName)
reader.SetFileName(fileName)
reader.Update()
scalarRange = [0] * 2
scalarRange[0] = reader.GetOutput().GetPointData().GetScalars().GetRange()[0]
scalarRange[1] = reader.GetOutput().GetPointData().GetScalars().GetRange()[1]
print("Range:", scalarRange)
middleSlice = 22
# Work with triple images.
cast = vtk.vtkImageCast()
cast.SetInputConnection(reader.GetOutputPort())
cast.SetOutputScalarTypeToDouble()
cast.Update()
laplacian = vtk.vtkImageLaplacian()
laplacian.SetInputConnection(cast.GetOutputPort())
laplacian.SetDimensionality(3)
enhance = vtk.vtkImageMathematics()
enhance.SetInputConnection(0, cast.GetOutputPort())
enhance.SetInputConnection(1, laplacian.GetOutputPort())
enhance.SetOperationToSubtract()
colorWindow = (scalarRange[1] - scalarRange[0])
colorLevel = colorWindow / 2
# Map the image through the lookup table.
originalColor = vtk.vtkImageMapToWindowLevelColors()
originalColor.SetWindow(colorWindow)
originalColor.SetLevel(colorLevel)
originalColor.SetInputConnection(reader.GetOutputPort())
originalActor = vtk.vtkImageActor()
originalActor.GetMapper().SetInputConnection(originalColor.GetOutputPort())
originalActor.GetProperty().SetInterpolationTypeToNearest()
originalActor.SetDisplayExtent(
reader.GetDataExtent()[0], reader.GetDataExtent()[1],
reader.GetDataExtent()[2], reader.GetDataExtent()[3],
middleSlice, middleSlice)
laplacianColor = vtk.vtkImageMapToWindowLevelColors()
laplacianColor.SetWindow(1000)
laplacianColor.SetLevel(0)
laplacianColor.SetInputConnection(laplacian.GetOutputPort())
laplacianActor = vtk.vtkImageActor()
laplacianActor.GetMapper().SetInputConnection(laplacianColor.GetOutputPort())
laplacianActor.GetProperty().SetInterpolationTypeToNearest()
laplacianActor.SetDisplayExtent(originalActor.GetDisplayExtent())
enhancedColor = vtk.vtkImageMapToWindowLevelColors()
enhancedColor.SetWindow(colorWindow)
enhancedColor.SetLevel(colorLevel)
enhancedColor.SetInputConnection(enhance.GetOutputPort())
enhancedActor = vtk.vtkImageActor()
enhancedActor.GetMapper().SetInputConnection(enhancedColor.GetOutputPort())
enhancedActor.GetProperty().SetInterpolationTypeToNearest()
enhancedActor.SetDisplayExtent(originalActor.GetDisplayExtent())
# Setup the renderers.
originalRenderer = vtk.vtkRenderer()
originalRenderer.AddActor(originalActor)
laplacianRenderer = vtk.vtkRenderer()
laplacianRenderer.AddActor(laplacianActor)
enhancedRenderer = vtk.vtkRenderer()
enhancedRenderer.AddActor(enhancedActor)
renderers = list()
renderers.append(originalRenderer)
renderers.append(laplacianRenderer)
renderers.append(enhancedRenderer)
# Setup viewports for the renderers.
rendererSize = 400
xGridDimensions = 3
yGridDimensions = 1
renderWindow = vtk.vtkRenderWindow()
renderWindow.SetSize(rendererSize * xGridDimensions, rendererSize * yGridDimensions)
for row in range(0, yGridDimensions):
for col in range(xGridDimensions):
index = row * xGridDimensions + col
# (xmin, ymin, xmax, ymax)
viewport = [float(col) / xGridDimensions, float(yGridDimensions - (row + 1)) / yGridDimensions,
float(col + 1) / xGridDimensions, float(yGridDimensions - row) / yGridDimensions]
renderers[index].SetViewport(viewport)
renderWindow.AddRenderer(renderers[index])
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
style = vtk.vtkInteractorStyleImage()
renderWindowInteractor.SetInteractorStyle(style)
renderWindowInteractor.SetRenderWindow(renderWindow)
# Renderers share one camera.
renderWindow.Render()
renderers[0].GetActiveCamera().Dolly(1.5)
renderers[0].ResetCameraClippingRange()
for r in range(1, len(renderers)):
renderers[r].SetActiveCamera(renderers[0].GetActiveCamera())
renderWindowInteractor.Initialize()
renderWindowInteractor.Start()
def main(argv):
if len(argv) < 3:
print("Usage: " + argv[0] + " polydata texture")
return 0
polyData = ReadPolyData(argv[1])
readerFactory = vtk.vtkImageReader2Factory()
textureFile = readerFactory.CreateImageReader2(argv[2])
textureFile.SetFileName(argv[2])
textureFile.Update()
colors = vtk.vtkNamedColors()
center = polyData.GetCenter()
print("Center: %f, %f, %f" % (center[0], center[1], center[2]))
camera = vtk.vtkCamera()
camera.SetPosition(center[0], center[1] + .0375, center[2] + .5)
camera.SetFocalPoint(center[0], center[1] + .0375, center[2])
camera.Azimuth(-45)
camera.Roll(-90)
camera.SetClippingRange(.5, .6)
planesArray = 24 * [1.0]
camera.GetFrustumPlanes(1.0, planesArray)
# Settings for vtkProjectedTexture
aspect = [1.0, 1.0, 1.0]
aspect[1] = (
1.0 /
(vtk.vtkMath.RadiansFromDegrees(math.tan(camera.GetViewAngle()))))
aspect[2] = 2.0
print("Aspect: %f, %f, %f" % (aspect[0], aspect[1], aspect[2]))
projectedTexture = vtk.vtkProjectedTexture()
projectedTexture.SetAspectRatio(aspect)
projectedTexture.SetPosition(camera.GetPosition())
projectedTexture.SetFocalPoint(camera.GetFocalPoint())
projectedTexture.SetUp(camera.GetViewUp()[0],
camera.GetViewUp()[1],
camera.GetViewUp()[2])
projectedTexture.SetInputData(polyData)
projectedTexture.Update()
# Map Texture on Surface
polyData.GetPointData().SetTCoords(
projectedTexture.GetOutput().GetPointData().GetTCoords())
texture = vtk.vtkTexture()
texture.SetInputData(textureFile.GetOutput())
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputData(polyData)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.SetTexture(texture)
planes = vtk.vtkPlanes()
planes.SetFrustumPlanes(planesArray)
frustumSource = vtk.vtkFrustumSource()
frustumSource.ShowLinesOff()
frustumSource.SetPlanes(planes)
frustumSource.Update()
frustumMapper = vtk.vtkPolyDataMapper()
frustumMapper.SetInputConnection(frustumSource.GetOutputPort())
frustumActor = vtk.vtkActor()
frustumActor.SetMapper(frustumMapper)
frustumActor.GetProperty().EdgeVisibilityOn()
frustumActor.GetProperty().SetColor(colors.GetColor3d("Banana"))
frustumActor.GetProperty().SetOpacity(.5)
frustumActor.GetProperty().SetRepresentationToWireframe()
renderer = vtk.vtkRenderer()
renderer.AddActor(actor)
renderer.AddActor(frustumActor)
renderer.SetBackground(colors.GetColor3d("SlateGray"))
renderer.SetActiveCamera(camera)
camera.Azimuth(180)
camera.Roll(-90)
renderer.ResetCameraClippingRange()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindow.SetWindowName("ProjectedTexture")
renWinInteractor = vtk.vtkRenderWindowInteractor()
renWinInteractor.SetRenderWindow(renderWindow)
renderWindow.Render()
renWinInteractor.Start()
def main():
colors = vtk.vtkNamedColors()
fileName = get_program_parameters()
# Read the image.
readerFactory = vtk.vtkImageReader2Factory()
reader = readerFactory.CreateImageReader2(fileName)
reader.SetFileName(fileName)
reader.Update()
# Process the image.
cast = vtk.vtkImageCast()
cast.SetInputConnection(reader.GetOutputPort())
cast.SetOutputScalarTypeToFloat()
smoothing_filter = vtk.vtkImageGaussianSmooth()
smoothing_filter.SetDimensionality(2)
smoothing_filter.SetInputConnection(cast.GetOutputPort())
smoothing_filter.SetStandardDeviations(4.0, 4.0)
smoothing_filter.SetRadiusFactors(2.0, 2.0)
# Create the actors.
originalActor = vtk.vtkImageActor()
originalActor.GetMapper().SetInputConnection(reader.GetOutputPort())
filteredActor = vtk.vtkImageActor()
filteredActor.GetMapper().SetInputConnection(
smoothing_filter.GetOutputPort())
# Define the viewport ranges.
# (xmin, ymin, xmax, ymax)
originalViewport = [0.0, 0.0, 0.5, 1.0]
filteredViewport = [0.5, 0.0, 1.0, 1.0]
# Setup the renderers.
originalRenderer = vtk.vtkRenderer()
originalRenderer.SetViewport(originalViewport)
originalRenderer.AddActor(originalActor)
originalRenderer.ResetCamera()
originalRenderer.SetBackground(colors.GetColor3d("SlateGray"))
filteredRenderer = vtk.vtkRenderer()
filteredRenderer.SetViewport(filteredViewport)
filteredRenderer.AddActor(filteredActor)
filteredRenderer.ResetCamera()
filteredRenderer.SetBackground(colors.GetColor3d("LightSlateGray"))
renderWindow = vtk.vtkRenderWindow()
renderWindow.SetSize(600, 300)
renderWindow.SetWindowName('GaussianSmooth')
renderWindow.AddRenderer(originalRenderer)
renderWindow.AddRenderer(filteredRenderer)
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
style = vtk.vtkInteractorStyleImage()
renderWindowInteractor.SetInteractorStyle(style)
renderWindowInteractor.SetRenderWindow(renderWindow)
renderWindowInteractor.Initialize()
renderWindowInteractor.Start()
def main(argv):
colors = vtk.vtkNamedColors()
imageData = None
# Verify input arguments
if len(argv) > 1:
# Read the image
readerFactory = vtk.vtkImageReader2Factory()
imageReader = readerFactory.CreateImageReader2(argv[1])
imageReader.SetFileName(argv[1])
imageReader.Update()
imageData = imageReader.GetOutput()
else:
drawColor1 = 4 * [255]
drawColor2 = 4 * [255]
drawColor3 = 4 * [255]
color1 = colors.GetColor3ub("warm_grey")
color2 = colors.GetColor3ub("DarkCyan")
color3 = colors.GetColor3ub("LightCoral")
for i in range(3):
drawColor1[i] = color1[i]
drawColor2[i] = color2[i]
drawColor3[i] = color3[i]
canvasSource = vtk.vtkImageCanvasSource2D()
canvasSource.SetExtent(0, 100, 0, 100, 0, 0)
canvasSource.SetScalarTypeToUnsignedChar()
canvasSource.SetNumberOfScalarComponents(3)
canvasSource.SetDrawColor(drawColor1)
canvasSource.FillBox(0, 100, 0, 100)
canvasSource.SetDrawColor(drawColor2)
canvasSource.FillTriangle(10, 10, 25, 10, 25, 25)
canvasSource.SetDrawColor(drawColor3)
canvasSource.FillTube(75, 75, 0, 75, 5.0)
canvasSource.Update()
imageData = canvasSource.GetOutput()
# Create an image actor to display the image
imageActor = vtk.vtkImageActor()
imageActor.SetInputData(imageData)
# Create a renderer to display the image in the background
backgroundRenderer = vtk.vtkRenderer()
# Create a superquadric
superquadricSource = vtk.vtkSuperquadricSource()
superquadricSource.SetPhiRoundness(1.1)
superquadricSource.SetThetaRoundness(.2)
# Create a mapper and actor
superquadricMapper = vtk.vtkPolyDataMapper()
superquadricMapper.SetInputConnection(superquadricSource.GetOutputPort())
superquadricActor = vtk.vtkActor()
superquadricActor.SetMapper(superquadricMapper)
superquadricActor.GetProperty().SetColor(colors.GetColor3d("NavajoWhite"))
sceneRenderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
# Set up the render window and renderers such that there is
# a background layer and a foreground layer
backgroundRenderer.SetLayer(0)
backgroundRenderer.InteractiveOff()
sceneRenderer.SetLayer(1)
renderWindow.SetNumberOfLayers(2)
renderWindow.AddRenderer(backgroundRenderer)
renderWindow.AddRenderer(sceneRenderer)
renderWindow.SetWindowName("BackgroundImage")
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
# Add actors to the renderers
sceneRenderer.AddActor(superquadricActor)
backgroundRenderer.AddActor(imageActor)
# Render once to figure out where the background camera will be
renderWindow.Render()
# Set up the background camera to fill the renderer with the image
origin = imageData.GetOrigin()
spacing = imageData.GetSpacing()
extent = imageData.GetExtent()
camera = backgroundRenderer.GetActiveCamera()
camera.ParallelProjectionOn()
xc = origin[0] + 0.5 * (extent[0] + extent[1]) * spacing[0]
yc = origin[1] + 0.5 * (extent[2] + extent[3]) * spacing[1]
yd = (extent[3] - extent[2] + 1) * spacing[1]
d = camera.GetDistance()
camera.SetParallelScale(0.5 * yd)
camera.SetFocalPoint(xc, yc, 0.0)
camera.SetPosition(xc, yc, d)
# Render again to set the correct view
renderWindow.Render()
# Interact with the window
renderWindowInteractor.Start()
def main():
colors = vtk.vtkNamedColors()
colors.SetColor("ActorColor", [235, 235, 235, 255])
fileName = get_program_parameters()
# Read the image.
readerFactory = vtk.vtkImageReader2Factory()
reader = readerFactory.CreateImageReader2(fileName)
reader.SetFileName(fileName)
reader.Update()
# Smoothed pipeline.
smooth = vtk.vtkImageGaussianSmooth()
smooth.SetDimensionality(3)
smooth.SetInputConnection(reader.GetOutputPort())
smooth.SetStandardDeviations(1.75, 1.75, 0.0)
smooth.SetRadiusFactor(2)
subsampleSmoothed = vtk.vtkImageShrink3D()
subsampleSmoothed.SetInputConnection(smooth.GetOutputPort())
subsampleSmoothed.SetShrinkFactors(4, 4, 1)
isoSmoothed = vtk.vtkImageMarchingCubes()
isoSmoothed.SetInputConnection(smooth.GetOutputPort())
isoSmoothed.SetValue(0, 1150)
isoSmoothedMapper = vtk.vtkPolyDataMapper()
isoSmoothedMapper.SetInputConnection(isoSmoothed.GetOutputPort())
isoSmoothedMapper.ScalarVisibilityOff()
isoSmoothedActor = vtk.vtkActor()
isoSmoothedActor.SetMapper(isoSmoothedMapper)
isoSmoothedActor.GetProperty().SetColor(colors.GetColor3d("ActorColor"))
# Unsmoothed pipeline.
# Sub sample the data.
subsample = vtk.vtkImageShrink3D()
subsample.SetInputConnection(reader.GetOutputPort())
subsample.SetShrinkFactors(4, 4, 1)
iso = vtk.vtkImageMarchingCubes()
iso.SetInputConnection(subsample.GetOutputPort())
iso.SetValue(0, 1150)
isoMapper = vtk.vtkPolyDataMapper()
isoMapper.SetInputConnection(iso.GetOutputPort())
isoMapper.ScalarVisibilityOff()
isoActor = vtk.vtkActor()
isoActor.SetMapper(isoMapper)
isoActor.GetProperty().SetColor(colors.GetColor3d("ActorColor"))
# The rendering Pipeline.
# Setup the render window, renderer, and interactor.
leftViewport = [0.0, 0.0, 0.5, 1.0]
rightViewport = [0.5, 0.0, 1.0, 1.0]
rendererLeft = vtk.vtkRenderer()
rendererLeft.SetViewport(leftViewport)
rendererRight = vtk.vtkRenderer()
rendererRight.SetViewport(rightViewport)
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(rendererLeft)
renderWindow.AddRenderer(rendererRight)
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
rendererLeft.AddActor(isoActor)
rendererRight.AddActor(isoSmoothedActor)
rendererLeft.GetActiveCamera().SetFocalPoint(0.0, 0.0, 0.0)
rendererLeft.GetActiveCamera().SetPosition(0.0, -1.0, 0.0)
rendererLeft.GetActiveCamera().SetViewUp(0.0, 0.0, -1.0)
rendererLeft.ResetCamera()
rendererLeft.GetActiveCamera().Azimuth(-20.0)
rendererLeft.GetActiveCamera().Elevation(20.0)
rendererLeft.ResetCameraClippingRange()
rendererLeft.SetBackground(colors.GetColor3d("SlateGray"))
rendererRight.SetBackground(colors.GetColor3d("LightSlateGray"))
rendererRight.SetActiveCamera(rendererLeft.GetActiveCamera())
renderWindow.SetSize(640, 480)
renderWindow.Render()
renderWindowInteractor.Start()
#!/usr/bin/env python
import vtk
from vtk.test import Testing
from vtk.util.misc import vtkGetDataRoot
VTK_DATA_ROOT = vtkGetDataRoot()
# This script shows the result of an ideal highpass filter in spatial domain
# Image pipeline
createReader = vtk.vtkImageReader2Factory()
reader = createReader.CreateImageReader2("" + str(VTK_DATA_ROOT) + "/Data/fullhead15.png")
reader.SetFileName("" + str(VTK_DATA_ROOT) + "/Data/fullhead15.png")
fft = vtk.vtkImageFFT()
fft.SetInputConnection(reader.GetOutputPort())
highPass = vtk.vtkImageIdealHighPass()
highPass.SetInputConnection(fft.GetOutputPort())
highPass.SetXCutOff(0.1)
highPass.SetYCutOff(0.1)
highPass.ReleaseDataFlagOff()
rfft = vtk.vtkImageRFFT()
rfft.SetInputConnection(highPass.GetOutputPort())
real = vtk.vtkImageExtractComponents()
real.SetInputConnection(rfft.GetOutputPort())
real.SetComponents(0)
viewer = vtk.vtkImageViewer()
viewer.SetInputConnection(real.GetOutputPort())
viewer.SetColorWindow(500)
viewer.SetColorLevel(0)
viewer.Render()
reader.UnRegister(viewer) # not needed in python
# --- end of script --
def main(argv):
colors = vtk.vtkNamedColors()
# Verify input arguments
if (len(argv) != 2):
print("Usage: " + argv[0] + " InputImageFilename e.g. Gourds2.jpg")
return
# Read the image
readerFactory = vtk.vtkImageReader2Factory()
imgReader = readerFactory.CreateImageReader2(argv[1])
imgReader.SetFileName(argv[1])
imgReader.Update()
image = imgReader.GetOutput()
# Find center of image
center = [0, 0]
center[0] = (image.GetExtent()[1] + image.GetExtent()[0]) // 2
center[1] = (image.GetExtent()[3] + image.GetExtent()[2]) // 2
# Pick a radius for the circle
radius = {
True: image.GetExtent()[1] * 2 / 5,
False: image.GetExtent()[3] * 2 / 5
}[(image.GetExtent()[1] < image.GetExtent()[3])]
drawColor1 = [0, 0, 0, 0]
color1 = colors.GetColor3ub("Black")
drawColor2 = [0, 0, 0, 0]
color2 = colors.GetColor3ub("Seashell")
for i in range(3):
drawColor1[i] = color1[i]
drawColor2[i] = color2[i]
# Draw a circle in the center of the image
drawing = vtk.vtkImageCanvasSource2D()
drawing.SetNumberOfScalarComponents(3)
drawing.SetScalarTypeToUnsignedChar()
drawing.SetExtent(image.GetExtent())
drawing.SetDrawColor(drawColor1)
drawing.FillBox(image.GetExtent()[0],
image.GetExtent()[1],
image.GetExtent()[2],
image.GetExtent()[3])
drawing.SetDrawColor(drawColor2)
drawing.DrawCircle(center[0], center[1], radius)
# Combine the images (blend takes multiple connections on the 0th
# input port)
blend = vtk.vtkImageBlend()
blend.AddInputConnection(imgReader.GetOutputPort())
blend.AddInputConnection(drawing.GetOutputPort())
blend.SetOpacity(0, .6)
blend.SetOpacity(1, .4)
# Display the result
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
imageViewer = vtk.vtkImageViewer2()
imageViewer.SetInputConnection(blend.GetOutputPort())
imageViewer.SetSize(640, 512)
imageViewer.SetupInteractor(renderWindowInteractor)
imageViewer.GetRenderer().ResetCamera()
imageViewer.GetRenderer().SetBackground(
colors.GetColor3d("LightSlateGray"))
imageViewer.GetRenderWindow().SetWindowName("DrawOnAnImage")
imageViewer.GetRenderWindow().Render()
renderWindowInteractor.Initialize()
renderWindowInteractor.Start()
return 0
def main():
colors = vtk.vtkNamedColors()
fileName = get_program_parameters()
# Read the image.
readerFactory = vtk.vtkImageReader2Factory()
reader = readerFactory.CreateImageReader2(fileName)
reader.SetFileName(fileName)
reader.Update()
fft = vtk.vtkImageFFT()
fft.SetInputConnection(reader.GetOutputPort())
mag = vtk.vtkImageMagnitude()
mag.SetInputConnection(fft.GetOutputPort())
center = vtk.vtkImageFourierCenter()
center.SetInputConnection(mag.GetOutputPort())
compress = vtk.vtkImageLogarithmicScale()
compress.SetInputConnection(center.GetOutputPort())
compress.SetConstant(15)
compress.Update()
# Create the actors.
originalActor = vtk.vtkImageActor()
originalActor.GetMapper().SetInputConnection(reader.GetOutputPort())
originalActor.GetProperty().SetInterpolationTypeToNearest()
compressedActor = vtk.vtkImageActor()
compressedActor.GetMapper().SetInputConnection(compress.GetOutputPort())
compressedActor.GetProperty().SetInterpolationTypeToNearest()
CreateImageActor(compressedActor, 160, 120)
# Define the viewport ranges.
# (xmin, ymin, xmax, ymax)
originalViewport = [0.0, 0.0, 0.5, 1.0]
compressedViewport = [0.5, 0.0, 1.0, 1.0]
# Setup the renderers.
originalRenderer = vtk.vtkRenderer()
originalRenderer.SetViewport(originalViewport)
originalRenderer.AddActor(originalActor)
originalRenderer.ResetCamera()
originalRenderer.SetBackground(colors.GetColor3d("SlateGray"))
compressedRenderer = vtk.vtkRenderer()
compressedRenderer.SetViewport(compressedViewport)
compressedRenderer.AddActor(compressedActor)
compressedRenderer.ResetCamera()
compressedRenderer.SetBackground(colors.GetColor3d("LightSlateGray"))
renderWindow = vtk.vtkRenderWindow()
renderWindow.SetSize(600, 300)
renderWindow.SetWindowName('VTKSpectrum')
renderWindow.AddRenderer(originalRenderer)
renderWindow.AddRenderer(compressedRenderer)
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
style = vtk.vtkInteractorStyleImage()
renderWindowInteractor.SetInteractorStyle(style)
renderWindowInteractor.SetRenderWindow(renderWindow)
renderWindowInteractor.Initialize()
renderWindowInteractor.Start()
def main():
# colors = vtk.vtkNamedColors()
fileName = get_program_parameters()
# Read the image.
readerFactory = vtk.vtkImageReader2Factory()
reader = readerFactory.CreateImageReader2(fileName)
reader.SetFileName(fileName)
reader.Update()
scalarRange = [0] * 2
scalarRange[0] = reader.GetOutput().GetPointData().GetScalars().GetRange(
)[0]
scalarRange[1] = reader.GetOutput().GetPointData().GetScalars().GetRange(
)[1]
print("Range:", scalarRange)
middleSlice = (reader.GetOutput().GetExtent()[5] -
reader.GetOutput().GetExtent()[4]) // 2
# Work with double images.
cast = vtk.vtkImageCast()
cast.SetInputConnection(reader.GetOutputPort())
cast.SetOutputScalarTypeToDouble()
cast.Update()
originalData = vtk.vtkImageData()
originalData.DeepCopy(cast.GetOutput())
noisyData = vtk.vtkImageData()
AddShotNoise(originalData, noisyData, 2000.0, 0.1,
reader.GetOutput().GetExtent())
median = vtk.vtkImageMedian3D()
median.SetInputData(noisyData)
median.SetKernelSize(5, 5, 1)
hybridMedian1 = vtk.vtkImageHybridMedian2D()
hybridMedian1.SetInputData(noisyData)
hybridMedian = vtk.vtkImageHybridMedian2D()
hybridMedian.SetInputConnection(hybridMedian1.GetOutputPort())
colorWindow = (scalarRange[1] - scalarRange[0]) * 0.8
colorLevel = colorWindow / 2
originalActor = vtk.vtkImageActor()
originalActor.GetMapper().SetInputData(originalData)
originalActor.GetProperty().SetColorWindow(colorWindow)
originalActor.GetProperty().SetColorLevel(colorLevel)
originalActor.GetProperty().SetInterpolationTypeToNearest()
originalActor.SetDisplayExtent(reader.GetDataExtent()[0],
reader.GetDataExtent()[1],
reader.GetDataExtent()[2],
reader.GetDataExtent()[3], middleSlice,
middleSlice)
noisyActor = vtk.vtkImageActor()
noisyActor.GetMapper().SetInputData(noisyData)
noisyActor.GetProperty().SetColorWindow(colorWindow)
noisyActor.GetProperty().SetColorLevel(colorLevel)
noisyActor.GetProperty().SetInterpolationTypeToNearest()
noisyActor.SetDisplayExtent(originalActor.GetDisplayExtent())
hybridMedianActor = vtk.vtkImageActor()
hybridMedianActor.GetMapper().SetInputConnection(
hybridMedian.GetOutputPort())
hybridMedianActor.GetProperty().SetColorWindow(colorWindow)
hybridMedianActor.GetProperty().SetColorLevel(colorLevel)
hybridMedianActor.GetProperty().SetInterpolationTypeToNearest()
hybridMedianActor.SetDisplayExtent(originalActor.GetDisplayExtent())
medianActor = vtk.vtkImageActor()
medianActor.GetMapper().SetInputConnection(median.GetOutputPort())
medianActor.GetProperty().SetColorWindow(colorWindow)
medianActor.GetProperty().SetColorLevel(colorLevel)
medianActor.GetProperty().SetInterpolationTypeToNearest()
# Setup the renderers.
originalRenderer = vtk.vtkRenderer()
originalRenderer.AddActor(originalActor)
noisyRenderer = vtk.vtkRenderer()
noisyRenderer.AddActor(noisyActor)
hybridRenderer = vtk.vtkRenderer()
hybridRenderer.AddActor(hybridMedianActor)
medianRenderer = vtk.vtkRenderer()
medianRenderer.AddActor(medianActor)
renderers = list()
renderers.append(originalRenderer)
renderers.append(noisyRenderer)
renderers.append(hybridRenderer)
renderers.append(medianRenderer)
# Setup viewports for the renderers.
rendererSize = 400
xGridDimensions = 2
yGridDimensions = 2
renderWindow = vtk.vtkRenderWindow()
renderWindow.SetSize(rendererSize * xGridDimensions,
rendererSize * yGridDimensions)
for row in range(0, yGridDimensions):
for col in range(xGridDimensions):
index = row * xGridDimensions + col
# (xmin, ymin, xmax, ymax)
viewport = [
float(col) / xGridDimensions,
float(yGridDimensions - (row + 1)) / yGridDimensions,
float(col + 1) / xGridDimensions,
float(yGridDimensions - row) / yGridDimensions
]
renderers[index].SetViewport(viewport)
renderWindow.AddRenderer(renderers[index])
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
style = vtk.vtkInteractorStyleImage()
renderWindowInteractor.SetInteractorStyle(style)
renderWindowInteractor.SetRenderWindow(renderWindow)
# The renderers share one camera.
renderWindow.Render()
for r in range(1, len(renderers)):
renderers[r].SetActiveCamera(renderers[0].GetActiveCamera())
renderWindowInteractor.Initialize()
renderWindowInteractor.Start()
import vtk
colors = vtk.vtkNamedColors()
meshReader = vtk.vtkXMLPolyDataReader()
meshReader.SetFileName("liverSurfReduced.vtp")
meshReader.Update()
# Read texture file
readerFactory = vtk.vtkImageReader2Factory()
# imageReader = vtk.vtkImageReader2()
textureName = "liver-texture-square.png"
# textureName = "liver-cyrrhosis.png"
imageReader = readerFactory.CreateImageReader2(textureName)
imageReader.SetFileName(textureName)
# Create texture
texture = vtk.vtkTexture()
#texture = vtk.vtkOpenGLTexture()
texture.SetInputConnection(imageReader.GetOutputPort())
texture.SetQuality(32)
# Wrap with sphere
# Delaynay
deln = vtk.vtkDelaunay3D()
deln.SetInputConnection(meshReader.GetOutputPort())
deln.SetTolerance(0.01)
tmapper = vtk.vtkTextureMapToSphere()
#tmapper.SetInputConnection(deln.GetOutputPort())
tmapper.SetInputConnection(meshReader.GetOutputPort())
def main():
# colors = vtk.vtkNamedColors()
fileName = get_program_parameters()
# Read the image.
readerFactory = vtk.vtkImageReader2Factory()
reader = readerFactory.CreateImageReader2(fileName)
reader.SetFileName(fileName)
reader.Update()
# Dilate
dilate = vtk.vtkImageDilateErode3D()
dilate.SetInputConnection(reader.GetOutputPort())
dilate.SetDilateValue(0)
dilate.SetErodeValue(255)
dilate.SetKernelSize(31, 31, 1)
# Erode
erode = vtk.vtkImageDilateErode3D()
erode.SetInputConnection(reader.GetOutputPort())
erode.SetDilateValue(255)
erode.SetErodeValue(0)
erode.SetKernelSize(31, 31, 1)
# Opening - dilate then erode.
dilate1 = vtk.vtkImageDilateErode3D()
dilate1.SetInputConnection(reader.GetOutputPort())
dilate1.SetDilateValue(0)
dilate1.SetErodeValue(255)
dilate1.SetKernelSize(31, 31, 1)
erode1 = vtk.vtkImageDilateErode3D()
erode1.SetInputConnection(dilate1.GetOutputPort())
erode1.SetDilateValue(255)
erode1.SetErodeValue(0)
erode1.SetKernelSize(31, 31, 1)
# Closing - erode then dilate.
erode2 = vtk.vtkImageDilateErode3D()
erode2.SetInputConnection(reader.GetOutputPort())
erode2.SetDilateValue(255)
erode2.SetErodeValue(0)
erode2.SetKernelSize(31, 31, 1)
dilate2 = vtk.vtkImageDilateErode3D()
dilate2.SetInputConnection(erode2.GetOutputPort())
dilate2.SetDilateValue(0)
dilate2.SetErodeValue(255)
dilate2.SetKernelSize(31, 31, 1)
# Connectivity
con = vtk.vtkImageSeedConnectivity()
con.SetInputConnection(reader.GetOutputPort())
con.AddSeed(300, 200)
con.SetInputConnectValue(0)
con.SetOutputConnectedValue(0)
con.SetOutputUnconnectedValue(255)
# Actors
originalActor = vtk.vtkImageActor()
originalActor.GetMapper().SetInputConnection(reader.GetOutputPort())
originalActor.GetProperty().SetInterpolationTypeToNearest()
connectedActor = vtk.vtkImageActor()
connectedActor.GetMapper().SetInputConnection(con.GetOutputPort())
connectedActor.GetProperty().SetInterpolationTypeToNearest()
erodeActor = vtk.vtkImageActor()
erodeActor.GetMapper().SetInputConnection(erode.GetOutputPort())
erodeActor.GetProperty().SetInterpolationTypeToNearest()
dilateActor = vtk.vtkImageActor()
dilateActor.GetMapper().SetInputConnection(dilate.GetOutputPort())
dilateActor.GetProperty().SetInterpolationTypeToNearest()
openingActor = vtk.vtkImageActor()
openingActor.GetMapper().SetInputConnection(dilate2.GetOutputPort())
openingActor.GetProperty().SetInterpolationTypeToNearest()
closingActor = vtk.vtkImageActor()
closingActor.GetMapper().SetInputConnection(erode1.GetOutputPort())
closingActor.GetProperty().SetInterpolationTypeToNearest()
# Setup renderers
originalRenderer = vtk.vtkRenderer()
originalRenderer.AddActor(originalActor)
connectedRenderer = vtk.vtkRenderer()
connectedRenderer.AddActor(connectedActor)
dilateRenderer = vtk.vtkRenderer()
dilateRenderer.AddActor(dilateActor)
erodeRenderer = vtk.vtkRenderer()
erodeRenderer.AddActor(erodeActor)
closingRenderer = vtk.vtkRenderer()
closingRenderer.AddActor(closingActor)
openingRenderer = vtk.vtkRenderer()
openingRenderer.AddActor(openingActor)
renderers = list()
renderers.append(originalRenderer)
renderers.append(connectedRenderer)
renderers.append(erodeRenderer)
renderers.append(dilateRenderer)
renderers.append(openingRenderer)
renderers.append(closingRenderer)
# Setup viewports for the renderers
rendererSize = 300
xGridDimensions = 2
yGridDimensions = 3
renderWindow = vtk.vtkRenderWindow()
renderWindow.SetSize(rendererSize * xGridDimensions,
rendererSize * yGridDimensions)
for row in range(0, yGridDimensions):
for col in range(xGridDimensions):
index = row * xGridDimensions + col
# (xmin, ymin, xmax, ymax)
viewport = [
float(col) / xGridDimensions,
float(yGridDimensions - (row + 1)) / yGridDimensions,
float(col + 1) / xGridDimensions,
float(yGridDimensions - row) / yGridDimensions
]
renderers[index].SetViewport(viewport)
renderWindow.AddRenderer(renderers[index])
renderWindow.SetWindowName('MorphologyComparison')
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
style = vtk.vtkInteractorStyleImage()
renderWindowInteractor.SetInteractorStyle(style)
renderWindowInteractor.SetRenderWindow(renderWindow)
# The renderers share one camera.
renderWindow.Render()
renderers[0].GetActiveCamera().Dolly(1.5)
renderers[0].ResetCameraClippingRange()
for r in range(1, len(renderers)):
renderers[r].SetActiveCamera(renderers[0].GetActiveCamera())
renderWindowInteractor.Initialize()
renderWindowInteractor.Start()
def main():
colors = vtk.vtkNamedColors()
fileName = get_program_parameters()
# Read the image.
readerFactory = vtk.vtkImageReader2Factory()
reader = readerFactory.CreateImageReader2(fileName)
reader.SetFileName(fileName)
reader.Update()
fft = vtk.vtkImageFFT()
fft.SetInputConnection(reader.GetOutputPort())
idealHighPass = vtk.vtkImageIdealHighPass()
idealHighPass.SetInputConnection(fft.GetOutputPort())
idealHighPass.SetXCutOff(0.1)
idealHighPass.SetYCutOff(0.1)
idealRfft = vtk.vtkImageRFFT()
idealRfft.SetInputConnection(idealHighPass.GetOutputPort())
idealReal = vtk.vtkImageExtractComponents()
idealReal.SetInputConnection(idealRfft.GetOutputPort())
idealReal.SetComponents(0)
butterworthHighPass = vtk.vtkImageButterworthHighPass()
butterworthHighPass.SetInputConnection(fft.GetOutputPort())
butterworthHighPass.SetXCutOff(0.1)
butterworthHighPass.SetYCutOff(0.1)
butterworthRfft = vtk.vtkImageRFFT()
butterworthRfft.SetInputConnection(butterworthHighPass.GetOutputPort())
butterworthReal = vtk.vtkImageExtractComponents()
butterworthReal.SetInputConnection(butterworthRfft.GetOutputPort())
butterworthReal.SetComponents(0)
# Create the actors.
idealColor = vtk.vtkImageMapToWindowLevelColors()
idealColor.SetWindow(500)
idealColor.SetLevel(0)
idealColor.SetInputConnection(idealReal.GetOutputPort())
idealActor = vtk.vtkImageActor()
idealActor.GetMapper().SetInputConnection(idealColor.GetOutputPort())
idealActor.GetProperty().SetInterpolationTypeToNearest()
butterworthColor = vtk.vtkImageMapToWindowLevelColors()
butterworthColor.SetWindow(500)
butterworthColor.SetLevel(0)
butterworthColor.SetInputConnection(butterworthReal.GetOutputPort())
butterworthActor = vtk.vtkImageActor()
butterworthActor.GetMapper().SetInputConnection(butterworthColor.GetOutputPort())
butterworthActor.GetProperty().SetInterpolationTypeToNearest()
# Setup the renderers.
idealRenderer = vtk.vtkRenderer()
idealRenderer.SetViewport(0.0, 0.0, 0.5, 1.0)
idealRenderer.AddActor(idealActor)
idealRenderer.ResetCamera()
idealRenderer.SetBackground(colors.GetColor3d("SlateGray"))
butterworthRenderer = vtk.vtkRenderer()
butterworthRenderer.SetViewport(0.5, 0.0, 1.0, 1.0)
butterworthRenderer.AddActor(butterworthActor)
butterworthRenderer.SetActiveCamera(idealRenderer.GetActiveCamera())
butterworthRenderer.SetBackground(colors.GetColor3d("LightSlateGray"))
renderWindow = vtk.vtkRenderWindow()
renderWindow.SetSize(600, 300)
renderWindow.SetWindowName('IdealHighPass')
renderWindow.AddRenderer(idealRenderer)
renderWindow.AddRenderer(butterworthRenderer)
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
style = vtk.vtkInteractorStyleImage()
renderWindowInteractor.SetInteractorStyle(style)
renderWindowInteractor.SetRenderWindow(renderWindow)
idealRenderer.GetActiveCamera().Dolly(1.4)
idealRenderer.ResetCameraClippingRange()
renderWindowInteractor.Initialize()
renderWindowInteractor.Start()
