def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.ui = Ui_Form()
self.ui.setupUi(self)
self.reader = vtk.vtkDICOMImageReader()
#self.viewerL = vtk.vtkImageViewer2()
#self.viewerR = vtk.vtkImageViewer2()
self.renL = vtk.vtkRenderer()
self.ui.leftVtk.GetRenderWindow().AddRenderer(self.renL)
self.renR = vtk.vtkRenderer()
self.ui.rightVtk.GetRenderWindow().AddRenderer(self.renR)
self.mapperL = vtk.vtkImageMapper()
self.mapperL.SetInputConnection(self.reader.GetOutputPort())
self.mapperR = vtk.vtkImageMapper()
self.actorL = vtk.vtkActor2D()
self.actorL.SetMapper(self.mapperL)
self.actorR = vtk.vtkActor2D()
self.actorR.SetMapper(self.mapperR)
self.renL.AddActor2D(self.actorL)
self.renR.AddActor2D(self.actorR)
self.importer = vtk.vtkImageImport()
self.mapperR.SetInputConnection(self.importer.GetOutputPort())
self.loadImage(os.path.join(STARTINGPATH, FILENAME))
self.setWindowingAlg()
def __init__(self):
self.lookupTable = vtk.vtkLookupTable()
self.lookupTable.SetRampToLinear()
self.lookupTable.SetNumberOfTableValues(2)
self.lookupTable.SetTableRange(0, 1)
self.lookupTable.SetTableValue(0, 0, 0, 0, 0)
self.colorMapper = vtk.vtkImageMapToRGBA()
self.colorMapper.SetOutputFormatToRGBA()
self.colorMapper.SetLookupTable(self.lookupTable)
self.thresholdFilter = vtk.vtkImageThreshold()
self.thresholdFilter.SetInValue(1)
self.thresholdFilter.SetOutValue(0)
self.thresholdFilter.SetOutputScalarTypeToUnsignedChar()
# Feedback actor
self.mapper = vtk.vtkImageMapper()
self.dummyImage = vtk.vtkImageData()
self.dummyImage.AllocateScalars(vtk.VTK_UNSIGNED_INT, 1)
self.mapper.SetInputData(self.dummyImage)
self.actor = vtk.vtkActor2D()
self.actor.VisibilityOff()
self.actor.SetMapper(self.mapper)
self.mapper.SetColorWindow(255)
self.mapper.SetColorLevel(128)
# Setup pipeline
self.colorMapper.SetInputConnection(
self.thresholdFilter.GetOutputPort())
self.mapper.SetInputConnection(self.colorMapper.GetOutputPort())
def __init__(self, sliceWidget):
super(ThresholdEffectTool, self).__init__(sliceWidget)
# create a logic instance to do the non-gui work
self.logic = ThresholdEffectLogic(self.sliceWidget.sliceLogic())
self.logic.undoRedo = self.undoRedo
# interaction state variables
self.min = 0
self.max = 0
# class instances
self.lut = None
self.thresh = None
self.map = None
# feedback actor
self.cursorMapper = vtk.vtkImageMapper()
self.cursorDummyImage = vtk.vtkImageData()
self.cursorDummyImage.AllocateScalars(vtk.VTK_UNSIGNED_INT, 1)
self.cursorMapper.SetInputData(self.cursorDummyImage)
self.cursorActor = vtk.vtkActor2D()
self.cursorActor.VisibilityOff()
self.cursorActor.SetMapper(self.cursorMapper)
self.cursorMapper.SetColorWindow(255)
self.cursorMapper.SetColorLevel(128)
self.actors.append(self.cursorActor)
self.renderer.AddActor2D(self.cursorActor)
def __init__(self):
self.interactor = None
self.image_original = None
self.image_threshold = None
self.render = None
self.lut = vtk.vtkLookupTable()
self.lut_original = vtk.vtkLookupTable()
self.image_color = vtk.vtkImageMapToColors()
self.blend = blend = vtk.vtkImageBlend()
self.map = map = vtk.vtkImageMapper()
self.actor = actor = vtk.vtkImageActor()
self.actor2 = actor2 = vtk.vtkImageActor()
self.actor3 = actor3 = vtk.vtkImageActor()
self.image_color_o = vtk.vtkImageMapToColors()
self.operation_type = 0
self.w = None
self.slice = 0
self.clicked = 0
self.orientation = AXIAL
self.w = (200, 1200)
def _init_canvas(self):
w, h = self._size
self._array = np.zeros((h, w, 4), dtype=np.uint8)
self._cv_image = converters.np_rgba_to_vtk(self._array)
self.mapper = vtk.vtkImageMapper()
self.mapper.SetInputData(self._cv_image)
self.mapper.SetColorWindow(255)
self.mapper.SetColorLevel(128)
self.actor = vtk.vtkActor2D()
self.actor.SetPosition(0, 0)
self.actor.SetMapper(self.mapper)
self.actor.GetProperty().SetOpacity(0.99)
self.canvas_renderer.AddActor2D(self.actor)
self.rgb = np.zeros((h, w, 3), dtype=np.uint8)
self.alpha = np.zeros((h, w, 1), dtype=np.uint8)
self.bitmap = wx.EmptyBitmapRGBA(w, h)
try:
self.image = wx.Image(w, h, self.rgb, self.alpha)
except TypeError:
self.image = wx.ImageFromBuffer(w, h, self.rgb, self.alpha)
def __init__(self, sliceWidget):
super(ThresholdEffectTool,self).__init__(sliceWidget)
# create a logic instance to do the non-gui work
self.logic = ThresholdEffectLogic(self.sliceWidget.sliceLogic())
self.logic.undoRedo = self.undoRedo
# interaction state variables
self.min = 0
self.max = 0
# class instances
self.lut = None
self.thresh = None
self.map = None
# feedback actor
self.cursorMapper = vtk.vtkImageMapper()
self.cursorDummyImage = vtk.vtkImageData()
self.cursorDummyImage.AllocateScalars(vtk.VTK_UNSIGNED_INT, 1)
self.cursorMapper.SetInputData( self.cursorDummyImage )
self.cursorActor = vtk.vtkActor2D()
self.cursorActor.VisibilityOff()
self.cursorActor.SetMapper( self.cursorMapper )
self.cursorMapper.SetColorWindow( 255 )
self.cursorMapper.SetColorLevel( 128 )
self.actors.append( self.cursorActor )
self.renderer.AddActor2D( self.cursorActor )
def __init__(self):
self.interactor = None
self.image_original = None
self.image_threshold = None
self.render = None
self.lut = vtk.vtkLookupTable()
self.lut_original = vtk.vtkLookupTable()
self.image_color = vtk.vtkImageMapToColors()
self.blend = blend = vtk.vtkImageBlend()
self.map = map = vtk.vtkImageMapper()
self.actor = actor = vtk.vtkImageActor()
self.actor2 = actor2 = vtk.vtkImageActor()
self.actor3 = actor3 = vtk.vtkImageActor()
self.image_color_o = vtk.vtkImageMapToColors()
self.operation_type = 0
self.w = None
self.slice = 0
self.clicked = 0
self.orientation = AXIAL
self.w = (200, 1200)
def _init_canvas(self):
w, h = self._size
self._array = np.zeros((h, w, 4), dtype=np.uint8)
self._cv_image = converters.np_rgba_to_vtk(self._array)
self.mapper = vtk.vtkImageMapper()
self.mapper.SetInputData(self._cv_image)
self.mapper.SetColorWindow(255)
self.mapper.SetColorLevel(128)
self.actor = vtk.vtkActor2D()
self.actor.SetPosition(0, 0)
self.actor.SetMapper(self.mapper)
self.actor.GetProperty().SetOpacity(0.99)
self.canvas_renderer.AddActor2D(self.actor)
self.rgb = np.zeros((h, w, 3), dtype=np.uint8)
self.alpha = np.zeros((h, w, 1), dtype=np.uint8)
self.bitmap = wx.EmptyBitmapRGBA(w, h)
try:
self.image = wx.Image(w, h, self.rgb, self.alpha)
except TypeError:
self.image = wx.ImageFromBuffer(w, h, self.rgb, self.alpha)
def __init__(self):
self.lookupTable = vtk.vtkLookupTable()
self.lookupTable.SetRampToLinear()
self.lookupTable.SetNumberOfTableValues(2)
self.lookupTable.SetTableRange(0, 1)
self.lookupTable.SetTableValue(0, 0, 0, 0, 0)
self.colorMapper = vtk.vtkImageMapToRGBA()
self.colorMapper.SetOutputFormatToRGBA()
self.colorMapper.SetLookupTable(self.lookupTable)
self.thresholdFilter = vtk.vtkImageThreshold()
self.thresholdFilter.SetInValue(1)
self.thresholdFilter.SetOutValue(0)
self.thresholdFilter.SetOutputScalarTypeToUnsignedChar()
# Feedback actor
self.mapper = vtk.vtkImageMapper()
self.dummyImage = vtk.vtkImageData()
self.dummyImage.AllocateScalars(vtk.VTK_UNSIGNED_INT, 1)
self.mapper.SetInputData(self.dummyImage)
self.actor = vtk.vtkActor2D()
self.actor.VisibilityOff()
self.actor.SetMapper(self.mapper)
self.mapper.SetColorWindow(255)
self.mapper.SetColorLevel(128)
# Setup pipeline
self.colorMapper.SetInputConnection(self.thresholdFilter.GetOutputPort())
self.mapper.SetInputConnection(self.colorMapper.GetOutputPort())
def get2DMapper(self, data, **kwargs):
# Set up mapper according to input arguments
mapper = vtk.vtkImageMapper()
mapper.SetInputData(data.GetOutput())
if 'zslice' in kwargs:
mapper.SetZSlice(kwargs['zslice'])
if 'window' in kwargs:
mapper.SetColorWindow(kwargs['window'])
if 'level' in kwargs:
mapper.SetColorLevel(kwargs['level'])
return mapper
def add_image(self, image):
img_mapper = vtk.vtkImageMapper()
img_actor = vtk.vtkActor2D()
img_data = vtk.vtkImageData()
img_data.SetDimensions(image.shape[0], image.shape[1], 1)
img_data.AllocateScalars(vtk.VTK_UNSIGNED_CHAR, 3)
for x in range(0, image.shape[0]):
for y in range(0, image.shape[1]):
pixel = img_data.GetScalarPointer(x, y, 0)
pixel = np.array(image[x, y, :])
img_mapper.SetInputData(img_data)
img_mapper.SetColorWindow(255)
img_mapper.SetColorLevel(127.5)
img_actor.SetMapper(img_mapper)
self.renderer.AddActor(img_actor)
def __init__(self,
parent=None,
width=400,
height=400,
showWidget=False,
scale=False):
super(LayerReveal, self).__init__()
self.width = width
self.height = height
self.showWidget = showWidget
self.scale = scale
self.renderer = None
# utility Qt instances for use in methods
self.gray = qt.QColor()
self.gray.setRedF(0.5)
self.gray.setGreenF(0.5)
self.gray.setBlueF(0.5)
# a painter to use for various jobs
self.painter = qt.QPainter()
# make a qwidget display
if self.showWidget:
self.frame = qt.QFrame(parent)
mw = slicer.util.mainWindow()
self.frame.setGeometry(mw.x, mw.y, self.width, self.height)
self.frameLayout = qt.QVBoxLayout(self.frame)
self.label = qt.QLabel()
self.frameLayout.addWidget(self.label)
self.frame.show()
# make an image actor in the slice view
self.vtkImage = vtk.vtkImageData()
self.mrmlUtils = slicer.qMRMLUtils()
self.imageMapper = vtk.vtkImageMapper()
self.imageMapper.SetColorLevel(128)
self.imageMapper.SetColorWindow(255)
if vtk.VTK_MAJOR_VERSION <= 5:
self.imageMapper.SetInput(self.vtkImage)
else:
self.imageMapper.SetInputData(self.vtkImage)
self.actor2D = vtk.vtkActor2D()
self.actor2D.SetMapper(self.imageMapper)
def render(im, dim):
#Definition for lookup table required for mapper
ul = 127
ll = 0
lut = vtk.vtkLookupTable()
lut.SetNumberOfColors(256)
lut.SetTableRange(ll, ul)
colorMap = vtk.vtkImageMapToColors()
colorMap.SetInput(im)
colorMap.SetLookupTable(lut)
mapper = vtk.vtkImageMapper()
mapper.SetInput(colorMap.GetOutput())
mapper.SetColorWindow(ul - ll)
mapper.SetColorLevel((ul - ll) / 2)
actor = vtk.vtkActor2D()
actor.SetMapper(mapper)
ren = vtk.vtkRenderer()
ren.AddActor(actor)
#ren.SetBackground(.8,.8,.8)
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
renWin.SetSize(800, 800)
renWin.SetWindowName("Bone Imaging Laboratory")
renWin.SetSize(dim.GetDimension()[0], dim.GetDimension()[1])
renWin.SetPosition(50, 50)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
for i in range(dim.GetDimension()[2]):
mapper.SetZSlice(i)
renWin.Render()
iren.Initialize()
renWin.Render()
iren.Start()
def ImageActor(img):
reader = vtkImageImportFromArray()
reader.SetArray(img)
ImageDataGeometryFilter = vtk.vtkImageDataGeometryFilter()
ImageDataGeometryFilter.SetInputConnection(reader.GetOutputPort())
ImageDataGeometryFilter.Update()
# textureCoordinates = vtk.vtkFloatArray()
# textureCoordinates.SetNumberOfComponents(2)
# textureCoordinates.InsertNextTuple2(0.0, 1.0)
# textureCoordinates.InsertNextTuple2(1.0, 1.0)
# textureCoordinates.InsertNextTuple2(1.0, 0.0)
# textureCoordinates.InsertNextTuple2(0.0, 0.0)
mag = vtk.vtkImageMagnify()
mag.SetMagnificationFactors(512, 512, 1)
mag.InterpolateOff()
mag.SetInputConnection(reader.GetOutputPort())
mapper = vtk.vtkImageMapper()
# mapper.SetInputConnection(reader.GetOutputPort())
# mapper.SetColorWindow(4)
# mapper.SetColorLevel(255)
# mapper.SetZSlice(0)
mapper.SetInputConnection(mag.GetOutputPort())
# mapper.SetColorlevel(1000)
viewer = vtk.vtkImageViewer()
viewer.SetInputConnection(reader.GetOutputPort())
viewer.SetColorWindow(4)
viewer.SetColorLevel(255)
# viewer.SetZSlice(0)
viewer.Render()
actor = vtk.vtkActor2D()
actor.SetMapper(mapper.GetOutputPort())
# actor=vtk.vtkImageActor()
# actor.SetMapper(mapper)
# actor.SetInputData(reader.GetOutput())
return actor, viewer
def __init__(self,parent=None,width=400,height=400,showWidget=False,scale=False):
super(LayerReveal,self).__init__()
self.width = width
self.height = height
self.showWidget = showWidget
self.scale = scale
self.renderer = None
# utility Qt instances for use in methods
self.gray = qt.QColor()
self.gray.setRedF(0.5)
self.gray.setGreenF(0.5)
self.gray.setBlueF(0.5)
# a painter to use for various jobs
self.painter = qt.QPainter()
# make a qwidget display
if self.showWidget:
self.frame = qt.QFrame(parent)
mw = slicer.util.mainWindow()
self.frame.setGeometry(mw.x, mw.y, self.width, self.height)
self.frameLayout = qt.QVBoxLayout(self.frame)
self.label = qt.QLabel()
self.frameLayout.addWidget(self.label)
self.frame.show()
# make an image actor in the slice view
self.vtkImage = vtk.vtkImageData()
self.mrmlUtils = slicer.qMRMLUtils()
self.imageMapper = vtk.vtkImageMapper()
self.imageMapper.SetColorLevel(128)
self.imageMapper.SetColorWindow(255)
if vtk.VTK_MAJOR_VERSION <= 5:
self.imageMapper.SetInput(self.vtkImage)
else:
self.imageMapper.SetInputData(self.vtkImage)
self.actor2D = vtk.vtkActor2D()
self.actor2D.SetMapper(self.imageMapper)
def testWipe(self):
# Image pipeline
renWin = vtk.vtkRenderWindow()
image1 = vtk.vtkImageCanvasSource2D()
image1.SetNumberOfScalarComponents(3)
image1.SetScalarTypeToUnsignedChar()
image1.SetExtent(0, 79, 0, 79, 0, 0)
image1.SetDrawColor(255, 255, 0)
image1.FillBox(0, 79, 0, 79)
image1.Update()
image2 = vtk.vtkImageCanvasSource2D()
image2.SetNumberOfScalarComponents(3)
image2.SetScalarTypeToUnsignedChar()
image2.SetExtent(0, 79, 0, 79, 0, 0)
image2.SetDrawColor(0, 255, 255)
image2.FillBox(0, 79, 0, 79)
image2.Update()
mapper = vtk.vtkImageMapper()
mapper.SetInputConnection(image1.GetOutputPort())
mapper.SetColorWindow(255)
mapper.SetColorLevel(127.5)
actor = vtk.vtkActor2D()
actor.SetMapper(mapper)
imager = vtk.vtkRenderer()
imager.AddActor2D(actor)
renWin.AddRenderer(imager)
wipes = ["Quad", "Horizontal", "Vertical", "LowerLeft", "LowerRight", "UpperLeft", "UpperRight"]
wiper = dict()
mapper = dict()
actor = dict()
imagers = dict()
for wipe in wipes:
wiper.update({wipe:vtk.vtkImageRectilinearWipe()})
wiper[wipe].SetInput1Data(image1.GetOutput())
wiper[wipe].SetInput2Data(image2.GetOutput())
wiper[wipe].SetPosition(20, 20)
eval('wiper[wipe].SetWipeTo' + wipe + '()')
mapper.update({wipe:vtk.vtkImageMapper()})
mapper[wipe].SetInputConnection(wiper[wipe].GetOutputPort())
mapper[wipe].SetColorWindow(255)
mapper[wipe].SetColorLevel(127.5)
actor.update({wipe:vtk.vtkActor2D()})
actor[wipe].SetMapper(mapper[wipe])
imagers.update({wipe:vtk.vtkRenderer()})
imagers[wipe].AddActor2D(actor[wipe])
renWin.AddRenderer(imagers[wipe])
imagers["Quad"].SetViewport(0, .5, .25, 1)
imagers["Horizontal"].SetViewport(.25, .5, .5, 1)
imagers["Vertical"].SetViewport(.5, .5, .75, 1)
imagers["LowerLeft"].SetViewport(.75, .5, 1, 1)
imagers["LowerRight"].SetViewport(0, 0, .25, .5)
imagers["UpperLeft"].SetViewport(.25, 0, .5, .5)
imagers["UpperRight"].SetViewport(.5, 0, .75, .5)
imager.SetViewport(.75, 0, 1, .5)
renWin.SetSize(400, 200)
# render and interact with data
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renWin);
renWin.Render()
img_file = "TestWipe.png"
vtk.test.Testing.compareImage(iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25)
vtk.test.Testing.interact()
def testAllMathematics(self):
# append multiple displaced spheres into an RGB image.
# Image pipeline
renWin = vtk.vtkRenderWindow()
sphere1 = vtk.vtkImageEllipsoidSource()
sphere1.SetCenter(40, 20, 0)
sphere1.SetRadius(30, 30, 0)
sphere1.SetInValue(.75)
sphere1.SetOutValue(.3)
sphere1.SetOutputScalarTypeToFloat()
sphere1.SetWholeExtent(0, 99, 0, 74, 0, 0)
sphere1.Update()
sphere2 = vtk.vtkImageEllipsoidSource()
sphere2.SetCenter(60, 30, 0)
sphere2.SetRadius(20, 20, 20)
sphere2.SetInValue(.2)
sphere2.SetOutValue(.5)
sphere2.SetOutputScalarTypeToFloat()
sphere2.SetWholeExtent(0, 99, 0, 74, 0, 0)
sphere2.Update()
mathematics = [ "Add", "Subtract", "Multiply", "Divide", "Invert", "Sin", "Cos",
"Exp", "Log", "AbsoluteValue", "Square", "SquareRoot", "Min",
"Max", "ATAN", "ATAN2", "MultiplyByK", "ReplaceCByK", "AddConstant"]
mathematic = list()
mapper = list()
actor = list()
imager = list()
for idx, operator in enumerate(mathematics):
mathematic.append(vtk.vtkImageMathematics())
mathematic[idx].SetInput1Data(sphere1.GetOutput())
mathematic[idx].SetInput2Data(sphere2.GetOutput())
eval('mathematic[idx].SetOperationTo' + operator + '()')
mathematic[idx].SetConstantK(.3)
mathematic[idx].SetConstantC(.75)
mapper.append(vtk.vtkImageMapper())
mapper[idx].SetInputConnection(mathematic[idx].GetOutputPort())
mapper[idx].SetColorWindow(2.0)
mapper[idx].SetColorLevel(.75)
actor.append(vtk.vtkActor2D())
actor[idx].SetMapper(mapper[idx])
imager.append(vtk.vtkRenderer())
imager[idx].AddActor2D(actor[idx])
renWin.AddRenderer(imager[idx])
column = 1
row = 1
deltaX = 1.0 / 6.0
deltaY = 1.0 / 4.0
for idx, operator in enumerate(mathematics):
imager[idx].SetViewport((column - 1) * deltaX, (row - 1) * deltaY, column * deltaX, row * deltaY)
column += 1
if column > 6:
column = 1
row += 1
# Make the last operator finish the row
vp = imager[len(mathematics) - 1].GetViewport()
imager[len(mathematics) - 1].SetViewport(vp[0], vp[1], 1, 1)
renWin.SetSize(600, 300)
# render and interact with data
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renWin);
renWin.Render()
img_file = "TestAllMathematics.png"
vtk.test.Testing.compareImage(iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25)
vtk.test.Testing.interact()
def Navigate2D():
print(
"---------------------------Navigating 2D---------------------------")
print("Please, choose the navigation axis")
print("1 Axial")
print("2 Coronal")
print("3 Sagittal")
optionUser = input("?: ")
print("Use up and down arrows to navigate")
global orientation
global zSlice
zSlice = 0
if (optionUser == "1"):
orientation = "axial"
if (optionUser == "2"):
orientation = "coronal"
if (optionUser == "3"):
orientation = "sagittal"
imageNavigate2D = orientImage(dicomImage, orientation)
global mapperNavigate2D
mapperNavigate2D = vtk.vtkImageMapper()
mapperNavigate2D.SetInputData(imageNavigate2D)
mapperNavigate2D.SetZSlice(zSlice)
# window and level have to be adjusted for better visualization
mapperNavigate2D.SetColorWindow(1000)
mapperNavigate2D.SetColorLevel(0)
actorNavigate2D = vtk.vtkActor2D()
actorNavigate2D.SetMapper(mapperNavigate2D)
global renderWindowNavigate2D
rendererNavigate2D = vtk.vtkRenderer()
rendererNavigate2D.AddActor(actorNavigate2D)
renderWindowNavigate2D = vtk.vtkRenderWindow()
renderWindowNavigate2D.AddRenderer(rendererNavigate2D)
if (orientation == "axial"):
renderWindowNavigate2D.SetSize(dicomImage.GetDimensions()[0],
dicomImage.GetDimensions()[1])
if (orientation == "coronal"):
renderWindowNavigate2D.SetSize(dicomImage.GetDimensions()[0],
dicomImage.GetDimensions()[2])
if (orientation == "sagittal"):
renderWindowNavigate2D.SetSize(dicomImage.GetDimensions()[1],
dicomImage.GetDimensions()[2])
windowInteractorN2D = vtk.vtkRenderWindowInteractor()
windowInteractorN2D.SetRenderWindow(renderWindowNavigate2D)
#Note here how the event is added to the observer. The name of the event is fixed, the name
#of the function that handles the event is user defined.
windowInteractorN2D.AddObserver("KeyPressEvent", KeyPressNavigate2D, 1.0)
windowInteractorN2D.Initialize()
renderWindowNavigate2D.Render()
windowInteractorN2D.Start()
del renderWindowNavigate2D, windowInteractorN2D
def testAllLogic(self):
# append multiple displaced spheres into an RGB image.
# Image pipeline
renWin = vtk.vtkRenderWindow()
logics = ["And", "Or", "Xor", "Nand", "Nor", "Not"]
types = ["Float", "Double", "UnsignedInt", "UnsignedLong", "UnsignedShort", "UnsignedChar"]
sphere1 = list()
sphere2 = list()
logic = list()
mapper = list()
actor = list()
imager = list()
for idx, operator in enumerate(logics):
ScalarType = types[idx]
sphere1.append(vtk.vtkImageEllipsoidSource())
sphere1[idx].SetCenter(95, 100, 0)
sphere1[idx].SetRadius(70, 70, 70)
eval('sphere1[idx].SetOutputScalarTypeTo' + ScalarType + '()')
sphere1[idx].Update()
sphere2.append(vtk.vtkImageEllipsoidSource())
sphere2[idx].SetCenter(161, 100, 0)
sphere2[idx].SetRadius(70, 70, 70)
eval('sphere2[idx].SetOutputScalarTypeTo' + ScalarType + '()')
sphere2[idx].Update()
logic.append(vtk.vtkImageLogic())
logic[idx].SetInput1Data(sphere1[idx].GetOutput())
if operator != "Not":
logic[idx].SetInput2Data(sphere2[idx].GetOutput())
logic[idx].SetOutputTrueValue(150)
eval('logic[idx].SetOperationTo' + operator + '()')
mapper.append(vtk.vtkImageMapper())
mapper[idx].SetInputConnection(logic[idx].GetOutputPort())
mapper[idx].SetColorWindow(255)
mapper[idx].SetColorLevel(127.5)
actor.append(vtk.vtkActor2D())
actor[idx].SetMapper(mapper[idx])
imager.append(vtk.vtkRenderer())
imager[idx].AddActor2D(actor[idx])
renWin.AddRenderer(imager[idx])
imager[0].SetViewport(0, .5, .33, 1)
imager[1].SetViewport(.33, .5, .66, 1)
imager[2].SetViewport(.66, .5, 1, 1)
imager[3].SetViewport(0, 0, .33, .5)
imager[4].SetViewport(.33, 0, .66, .5)
imager[5].SetViewport(.66, 0, 1, .5)
renWin.SetSize(768, 512)
# render and interact with data
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renWin);
renWin.Render()
img_file = "TestAllLogic.png"
vtk.test.Testing.compareImage(iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25)
vtk.test.Testing.interact()
def _CreateLabel(self):
borderwidth = self._Config['borderwidth']
width, height = self._DisplaySize
x, y = self._DisplayOrigin
x0, y0 = self._Renderer.GetOrigin()
image = self._Config['bitmap']
# set up the border
self._Points = vtk.vtkPoints()
self._SetPoints()
cells = vtk.vtkCellArray()
cells.InsertNextCell(4)
cells.InsertCellPoint(1)
cells.InsertCellPoint(3)
cells.InsertCellPoint(5)
cells.InsertCellPoint(7)
if borderwidth > 0:
cells.InsertNextCell(4)
cells.InsertCellPoint(0)
cells.InsertCellPoint(1)
cells.InsertCellPoint(3)
cells.InsertCellPoint(2)
cells.InsertNextCell(4)
cells.InsertCellPoint(2)
cells.InsertCellPoint(3)
cells.InsertCellPoint(5)
cells.InsertCellPoint(4)
cells.InsertNextCell(4)
cells.InsertCellPoint(4)
cells.InsertCellPoint(5)
cells.InsertCellPoint(7)
cells.InsertCellPoint(6)
cells.InsertNextCell(4)
cells.InsertCellPoint(6)
cells.InsertCellPoint(7)
cells.InsertCellPoint(1)
cells.InsertCellPoint(0)
try: # for VTK 3.x
scalars = vtk.vtkScalars()
scalars.SetDataTypeToUnsignedChar()
scalars.InsertScalar(0, 0)
scalars.InsertScalar(1, 2)
scalars.InsertScalar(2, 2)
scalars.InsertScalar(3, 3)
scalars.InsertScalar(4, 3)
except (NameError, AttributeError):
scalars = vtk.vtkUnsignedCharArray()
scalars.InsertTuple1(0, 0)
scalars.InsertTuple1(1, 2)
scalars.InsertTuple1(2, 2)
scalars.InsertTuple1(3, 3)
scalars.InsertTuple1(4, 3)
data = vtk.vtkPolyData()
data.SetPoints(self._Points)
data.SetPolys(cells)
data.GetCellData().SetScalars(scalars)
mapper = vtk.vtkPolyDataMapper2D()
mapper.SetInput(data)
mapper.SetLookupTable(self._LookupTable)
mapper.SetColorModeToMapScalars()
mapper.SetScalarRange(0, 3)
actor = vtk.vtkActor2D()
actor.SetMapper(mapper)
actor.SetPosition(x - x0, y - y0)
self._Scalars = scalars
self._Actors.append(actor)
if self._Renderer:
self._Renderer.AddActor2D(actor)
# if there is a bitmap
if image:
image.UpdateInformation()
extent = image.GetWholeExtent()
spacing = image.GetSpacing()
origin = image.GetOrigin()
newextent = (0, width - 1 - borderwidth * 2,
0, height - 1 - borderwidth * 2,
extent[4], extent[5])
newspacing = (spacing[0] * float(extent[1] - extent[0]) /
float(newextent[1] - newextent[0]),
spacing[1] * float(extent[3] - extent[2]) /
float(newextent[3] - newextent[2]),
spacing[2])
neworigin = (origin[0] + extent[0] * spacing[0] -
newextent[0] * newspacing[0],
origin[1] + extent[2] * spacing[1] -
newextent[2] * newspacing[1],
origin[2])
reslice = vtk.vtkImageReslice()
reslice.SetInput(image)
reslice.SetInterpolationModeToCubic()
reslice.SetOutputExtent(newextent)
reslice.SetOutputSpacing(newspacing)
reslice.SetOutputOrigin(neworigin)
self._BitmapReslice = reslice
mapper = vtk.vtkImageMapper()
mapper.SetInput(reslice.GetOutput())
mapper.SetColorWindow(255.0)
mapper.SetColorLevel(127.5)
actor = vtk.vtkActor2D()
actor.SetMapper(mapper)
actor.SetPosition(x - x0, y - y0)
self._Actors.append(actor)
if self._Renderer:
self._Renderer.AddActor2D(actor)
mapper = vtk.vtkTextMapper()
mapper.SetInput(self._Config['text'])
try:
property = mapper.GetTextProperty()
except AttributeError:
property = mapper
property.SetFontSize(self._Config['fontsize'])
if self._Config['font'] in ('courier', 'Courier'):
property.SetFontFamilyToCourier()
elif self._Config['font'] in ('arial', 'Arial'):
property.SetFontFamilyToArial()
elif self._Config['font'] in ('times', 'Times'):
property.SetFontFamilyToTimes()
property.SetJustificationToCentered()
property.SetVerticalJustificationToCentered()
property.BoldOn()
self._TextMapper = mapper
actor = vtk.vtkActor2D()
apply(actor.GetProperty().SetColor, self._Config['foreground'])
actor.SetMapper(mapper)
if "FreeType" in mapper.GetClassName():
actor.SetPosition(x + width / 2 - x0,
y + height / 2 - y0)
else: # not a FreeType font, needs position correction
actor.SetPosition(x + width / 2 - x0 + 1,
y + height / 2 - y0 + 1)
self._Actors.append(actor)
if self._Renderer:
self._Renderer.AddActor2D(actor)
def testImageThresholdConnectivity(self):
# This script is for testing the 3D flood fill filter.
# Image pipeline
renWin = vtk.vtkRenderWindow()
renWin.SetSize(192, 256)
reader = vtk.vtkImageReader()
reader.ReleaseDataFlagOff()
reader.SetDataByteOrderToLittleEndian()
reader.SetDataExtent(0, 63, 0, 63, 2, 5)
reader.SetDataSpacing(3.2, 3.2, 1.5)
reader.SetFilePrefix(VTK_DATA_ROOT + "/Data/headsq/quarter")
reader.SetDataMask(0x7fff)
seeds = vtk.vtkPoints()
seeds.InsertNextPoint(0, 0, 0)
seeds.InsertNextPoint(100.8, 100.8, 0)
replacein = ["ReplaceInOn", "ReplaceInOff"]
replaceout = ["ReplaceOutOn", "ReplaceOutOff"]
thresholds = [
"ThresholdByLower(800)", "ThresholdByUpper(1200)",
"ThresholdBetween(800, 1200)"
]
thresh = list()
map = list()
act = list()
ren = list()
k = 0
for rin in replacein:
for rout in replaceout:
for t in thresholds:
thresh.append(vtk.vtkImageThresholdConnectivity())
thresh[k].SetSeedPoints(seeds)
thresh[k].SetInValue(2000)
thresh[k].SetOutValue(0)
eval('thresh[k].' + rin + '()')
eval('thresh[k].' + rout + '()')
thresh[k].SetInputConnection(reader.GetOutputPort())
eval('thresh[k].' + t)
map.append(vtk.vtkImageMapper())
map[k].SetInputConnection(thresh[k].GetOutputPort())
if k < 3:
map[k].SetColorWindow(255)
map[k].SetColorLevel(127.5)
else:
map[k].SetColorWindow(2000)
map[k].SetColorLevel(1000)
act.append(vtk.vtkActor2D())
act[k].SetMapper(map[k])
ren.append(vtk.vtkRenderer())
ren[k].AddActor2D(act[k])
renWin.AddRenderer(ren[k])
k += 1
ren[0].SetViewport(0, 0, .33333, .25)
ren[1].SetViewport(.33333, 0, .66667, .25)
ren[2].SetViewport(.66667, 0, 1, .25)
ren[3].SetViewport(0, .25, .33333, .5)
ren[4].SetViewport(.33333, .25, .66667, .5)
ren[5].SetViewport(.66667, .25, 1, .5)
ren[6].SetViewport(0, .5, .33333, .75)
ren[7].SetViewport(.33333, .5, .66667, .75)
ren[8].SetViewport(.66667, .5, 1, .75)
ren[9].SetViewport(0, .75, .33333, 1)
ren[10].SetViewport(.33333, .75, .66667, 1)
ren[11].SetViewport(.66667, .75, 1, 1)
# render and interact with data
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renWin)
renWin.Render()
img_file = "TestImageThresholdConnectivity.png"
vtk.test.Testing.compareImage(
iRen.GetRenderWindow(),
vtk.test.Testing.getAbsImagePath(img_file),
threshold=25)
vtk.test.Testing.interact()
def __init__(self,
parent=None,
width=400,
height=400,
showWidget=False,
scale=False):
super(ROIManager, self).__init__()
self.width = width
self.height = height
self.showWidget = showWidget
self.scale = scale
self.renderer = None
self.ROIRadius = 20.0
self.minValueBG = 0
self.maxValueBG = 0
self.minValueFG = 0
self.maxValueFG = 0
self.probeWidget = None
self.drawOverlay = 0
# utility Qt instances for use in methods
self.gray = qt.QColor()
self.gray.setRedF(0.5)
self.gray.setGreenF(0.5)
self.gray.setBlueF(0.5)
# a painter to use for various jobs
self.painter = qt.QPainter()
# make a qwidget display
if self.showWidget:
self.frame = qt.QFrame(parent)
mw = slicer.util.mainWindow()
self.frame.setGeometry(mw.x, mw.y, self.width, self.height)
self.frameLayout = qt.QVBoxLayout(self.frame)
self.label = qt.QLabel()
self.frameLayout.addWidget(self.label)
self.frame.show()
# make an image actor in the slice view
self.vtkImage = vtk.vtkImageData()
self.mrmlUtils = slicer.qMRMLUtils()
self.imageMapper = vtk.vtkImageMapper()
self.imageMapper.SetColorLevel(128)
self.imageMapper.SetColorWindow(255)
if vtk.VTK_MAJOR_VERSION <= 5:
self.imageMapper.SetInput(self.vtkImage)
else:
self.imageMapper.SetInputData(self.vtkImage)
self.actor2D = vtk.vtkActor2D()
self.actor2D.SetMapper(self.imageMapper)
# make a circle actor
self.circle = vtk.vtkRegularPolygonSource()
self.circle.SetNumberOfSides(50)
self.circle.SetRadius(5)
self.circle.SetCenter(0, 0, 0)
self.circle.GeneratePolylineOn()
self.circle.GeneratePolygonOff()
self.circle.Update()
self.mapper = vtk.vtkPolyDataMapper2D()
self.actor = vtk.vtkActor2D()
if vtk.VTK_MAJOR_VERSION <= 5:
self.mapper.SetInput(self.circle.GetOutput())
else:
self.mapper.SetInputConnection(self.circle.GetOutputPort())
self.actor.SetMapper(self.mapper)
property_ = self.actor.GetProperty()
property_.SetColor(1, 1, 0)
property_.SetLineWidth(1)
def __init__(self,
input_file,
gaussian,
radius,
thresh,
zoom,
zSlice,
brightness,
window_size,
*args, **kwargs):
"""MainWindow constructor"""
super().__init__(*args, **kwargs)
# Window setup
self.resize(window_size[0],window_size[1])
self.title = "Qt Viewer for Lesion Augmentation"
self.statusBar().showMessage("Welcome.",8000)
# Capture defaults
self.gaussian = gaussian
self.radius = radius
self.thresh = thresh
self.zoom = zoom
self.brightness = brightness
self.shape_dic = None
self.lesion_dic = {}
self.thresholdArray = None
self.imageArray = None
self.zSlice = 100
self.shape = None
self.crop = None
self.colorWindow = 1000
self.colorLevel = 500
# Initialize the window
self.initUI()
# Set up some VTK pipeline classes
self.reader = None
self.gauss = vtk.vtkImageGaussianSmooth()
self.lesion = vtk.vtkImageData()
self.threshold = vtk.vtkImageThreshold()
self.mapToColors = vtk.vtkImageMapToColors()
self.imageViewer = vtk.vtkImageViewer2()
self.resizeImage = vtk.vtkImageResize()
self.resizeSeg = vtk.vtkImageResize()
self.contourRep = vtk.vtkOrientedGlyphContourRepresentation()
self.contourWidget = vtk.vtkContourWidget()
self.placer = vtk.vtkImageActorPointPlacer()
self.polyData = None
self.origmapper = vtk.vtkImageMapper()#vtkImageSliceMapper()#
self.mapper = vtk.vtkImageMapper()
self.stencilmapper = vtk.vtkPolyDataMapper()
self.origactor = vtk.vtkActor2D() #vtkImageActor()
self.actor = vtk.vtkActor2D()
self.stencilactor = vtk.vtkActor()
# Take inputs from command line. Only use these if there is an input file specified
if (input_file != None):
if (not os.path.exists(input_file)):
qtw.QMessageBox.warning(self, "Error", "Invalid input file.")
return
self.createPipeline(input_file)
self.statusBar().showMessage("Loading file " + input_file,4000)
self.changeSigma(gaussian)
self.changeRadius(radius)
self.changeThreshold(thresh)
self.changeBrightness(brightness)
self.changeSlice(zSlice)
print(dataBounds) midx = int(dataBounds[0] / 2) midy = int(dataBounds[1] / 2) midz = int(dataBounds[2] / 2) WindowX = dataBounds[0] WindowY = dataBounds[1] # midx = WindowX/2 # midy = WindowY/2 # midz = 100 # initialise the mapper mapper = vtk.vtkImageMapper() mapper.SetInputConnection(reader.GetOutputPort()) mapper.SetZSlice(midz) mapper.SetColorWindow(1000) mapper.SetColorLevel(0) # create the actor actor = vtk.vtkActor2D() actor.SetMapper(mapper) # actor.SetPosition(midx, midy) # create the renderer ren = vtk.vtkRenderer() # create the render window renWin = vtk.vtkRenderWindow()
def displayImages(reader):
# Gets all image data
imageData = reader.GetOutput()
# Extracting the dimensions of the image
coordBounds = imageData.GetDimensions(
) # this gives maxx, maxy, maxz coordinate numbers
# assigning dimension variables in case want to use for sizing and positioning actors and windows
# in the future, would want to assign location and sizing of objects by local screen resolution
xdim = int(coordBounds[0])
ydim = int(coordBounds[1])
zdim = int(coordBounds[2])
# initialise the mapper. The image displayed will be the middle image in the image set
mapper = vtk.vtkImageMapper()
mapper.SetInputConnection(reader.GetOutputPort())
mapper.SetZSlice(int(zdim / 2))
mapper.SetColorWindow(1000)
mapper.SetColorLevel(600)
# create the actor
actor = vtk.vtkActor2D()
actor.SetMapper(mapper)
actor.SetPosition(100, 170)
# assign text to display: current slice and window level and color level
outputText1 = ("Current slice: " + str(mapper.GetZSlice() + 1) + " of " +
str(zdim) + '\n'
'Window level: ' + str(int(mapper.GetColorWindow())) +
' Color level: ' + str(int(mapper.GetColorLevel())) + '\n')
# create text actor
txt = vtk.vtkTextActor()
txt.SetInput(outputText1)
txtprop = txt.GetTextProperty()
txtprop.SetFontFamilyToArial()
txtprop.SetFontSize(30)
txtprop.SetColor(1, 1, 1)
txt.SetDisplayPosition(10, 30)
# create second text actor
infoText = vtk.vtkTextActor()
infoText.SetInput("Scroll up or down to navigate through the slices. \n")
infotxtprop = infoText.GetTextProperty()
infotxtprop.SetFontFamilyToArial()
infotxtprop.SetFontSize(20)
infotxtprop.SetColor(1, 1, 1)
infoText.SetDisplayPosition(10, 15)
# create the renderer
ren = vtk.vtkRenderer()
# create the render window
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
renWin.SetSize(800, 700)
# Connect an interactor to the image viewer
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
iren.SetInteractorStyle(vtk.vtkInteractorStyleImage())
# function to change projected image slice with key press
# Add observers for mouse wheel events to scroll through slices
def wheelForward(obj, event):
zSlice = mapper.GetZSlice()
if (zSlice < mapper.GetWholeZMax()):
mapper.SetZSlice(zSlice + 1)
# update displayed text
outputText1 = ("Current slice: " + str(mapper.GetZSlice() + 1) +
" of " + str(zdim) + '\n'
'Window level: ' + str(int(mapper.GetColorWindow())) +
' Color level: ' + str(int(mapper.GetColorLevel())) +
'\n')
txt.SetInput(outputText1)
def wheelBackward(obj, event):
zSlice = mapper.GetZSlice()
if (zSlice > mapper.GetWholeZMin()):
mapper.SetZSlice(zSlice - 1)
# update displayed text
outputText1 = ("Current slice: " + str(mapper.GetZSlice() + 1) +
" of " + str(zdim) + '\n'
'Window level: ' + str(int(mapper.GetColorWindow())) +
' Color level: ' + str(int(mapper.GetColorLevel())) +
'\n')
txt.SetInput(outputText1)
# add the scrolling events to move through slices
iren.AddObserver("MouseWheelForwardEvent", wheelForward)
iren.AddObserver("MouseWheelBackwardEvent", wheelBackward)
# add the actors to the renderer
ren.AddActor(actor)
ren.AddActor(txt)
ren.AddActor(infoText)
# initialise the interactor
iren.Initialize()
# render the scene with all actors in it
renWin.Render()
# Start the event loop for the interactor
iren.Start()
return ()
def testAllMaskBits(self):
# This script calculates the luminance of an image
renWin = vtk.vtkRenderWindow()
# Image pipeline
image1 = vtk.vtkTIFFReader()
image1.SetFileName(VTK_DATA_ROOT + "/Data/beach.tif")
# "beach.tif" image contains ORIENTATION tag which is
# ORIENTATION_TOPLEFT (row 0 top, col 0 lhs) type. The TIFF
# reader parses this tag and sets the internal TIFF image
# orientation accordingly. To overwrite this orientation with a vtk
# convention of ORIENTATION_BOTLEFT (row 0 bottom, col 0 lhs ), invoke
# SetOrientationType method with parameter value of 4.
image1.SetOrientationType(4)
shrink = vtk.vtkImageShrink3D()
shrink.SetInputConnection(image1.GetOutputPort())
shrink.SetShrinkFactors(2, 2, 1)
operators = ["ByPass", "And", "Nand", "Xor", "Or", "Nor"]
operator = dict()
mapper = dict()
actor = dict()
imager = dict()
for idx, op in enumerate(operators):
if op != "ByPass":
operator.update({idx: vtk.vtkImageMaskBits()})
operator[idx].SetInputConnection(shrink.GetOutputPort())
eval('operator[' + str(idx) + '].SetOperationTo' + op + '()')
operator[idx].SetMasks(255, 255, 0)
mapper.update({idx: vtk.vtkImageMapper()})
if op != "ByPass":
mapper[idx].SetInputConnection(operator[idx].GetOutputPort())
else:
mapper[idx].SetInputConnection(shrink.GetOutputPort())
mapper[idx].SetColorWindow(255)
mapper[idx].SetColorLevel(127.5)
actor.update({idx: vtk.vtkActor2D()})
actor[idx].SetMapper(mapper[idx])
imager.update({idx: vtk.vtkRenderer()})
imager[idx].AddActor2D(actor[idx])
renWin.AddRenderer(imager[idx])
column = 0
row = 0
deltaX = 1.0 / 3.0
deltaY = 1.0 / 2.0
for idx in range(len(operators)):
imager[idx].SetViewport(column * deltaX, row * deltaY, (column + 1) * deltaX, (row + 1) * deltaY)
column += 1
if column > 2:
column = 0
row += 1
renWin.SetSize(384, 256)
# render and interact with data
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renWin);
renWin.Render()
img_file = "TestAllMaskBits.png"
vtk.test.Testing.compareImage(iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25)
vtk.test.Testing.interact()
def get_vtkobjects(self, opacity=None):
if self.data is None:
raise Exception('No image data loaded!')
ImageImporter = vtk.vtkImageImport()
# Create a temporary floating point copy of the data, for scaling.
# Also flip the data (vtk addresses y from bottom right) and put in display coords.
Data = np.float32(
np.flipud(self.transform.original_to_display_image(self.data)))
clim = np.float32(self.clim)
# Scale to colour limits and convert to uint8 for displaying.
Data -= clim[0]
Data /= (clim[1] - clim[0])
Data *= 255.
Data = np.uint8(Data)
if self.postprocessor is not None:
Data = self.postprocessor(Data)
if opacity is not None:
Alpha = np.uint8(np.ones(Data.shape[:2]) * opacity * 255)
Data = np.dstack([Data, Alpha])
if self.alpha is not None:
Alpha = np.flipud(
self.transform.original_to_display_image(self.alpha))
Data = np.dstack([Data, Alpha])
DataString = Data.tostring()
ImageImporter.CopyImportVoidPointer(DataString, len(DataString))
ImageImporter.SetDataScalarTypeToUnsignedChar()
if len(self.data.shape) == 2:
ImageImporter.SetNumberOfScalarComponents(1)
else:
ImageImporter.SetNumberOfScalarComponents(Data.shape[2])
ImageImporter.SetDataExtent(0, Data.shape[1] - 1, 0, Data.shape[0] - 1,
0, 0)
ImageImporter.SetWholeExtent(0, Data.shape[1] - 1, 0,
Data.shape[0] - 1, 0, 0)
Resizer = vtk.vtkImageResize()
Resizer.SetInputConnection(ImageImporter.GetOutputPort())
Resizer.SetResizeMethodToOutputDimensions()
Resizer.SetOutputDimensions((Data.shape[1], Data.shape[0], 1))
# jrh mod begin
Resizer.InterpolateOff()
mapper = vtk.vtkImageMapper()
mapper.SetInputConnection(Resizer.GetOutputPort())
mapper.SetColorWindow(255)
mapper.SetColorLevel(127.5)
Actor = vtk.vtkActor2D()
Actor.SetMapper(mapper)
Actor.GetProperty().SetDisplayLocationToBackground()
return Actor, Resizer
def testAllShrinks(self):
prefix = VTK_DATA_ROOT + "/Data/headsq/quarter"
renWin = vtk.vtkRenderWindow()
# Image pipeline
reader = vtk.vtkImageReader()
reader.SetDataExtent(0, 63, 0, 63, 1, 93)
reader.SetFilePrefix(prefix)
reader.SetDataByteOrderToLittleEndian()
reader.SetDataMask(0x7fff)
factor = 4
magFactor = 8
ops = ["Minimum", "Maximum", "Mean", "Median", "NoOp"]
shrink = dict()
mag = dict()
mapper = dict()
actor = dict()
imager = dict()
for operator in ops:
shrink.update({operator: vtk.vtkImageShrink3D()})
shrink[operator].SetMean(0)
if operator != "NoOp":
eval('shrink[operator].' + operator + 'On()')
shrink[operator].SetShrinkFactors(factor, factor, factor)
shrink[operator].SetInputConnection(reader.GetOutputPort())
mag.update({operator: vtk.vtkImageMagnify()})
mag[operator].SetMagnificationFactors(magFactor, magFactor,
magFactor)
mag[operator].InterpolateOff()
mag[operator].SetInputConnection(shrink[operator].GetOutputPort())
mapper.update({operator: vtk.vtkImageMapper()})
mapper[operator].SetInputConnection(mag[operator].GetOutputPort())
mapper[operator].SetColorWindow(2000)
mapper[operator].SetColorLevel(1000)
mapper[operator].SetZSlice(45)
actor.update({operator: vtk.vtkActor2D()})
actor[operator].SetMapper(mapper[operator])
imager.update({operator: vtk.vtkRenderer()})
imager[operator].AddActor2D(actor[operator])
renWin.AddRenderer(imager[operator])
shrink["Minimum"].Update
shrink["Maximum"].Update
shrink["Mean"].Update
shrink["Median"].Update
imager["Minimum"].SetViewport(0, 0, .5, .33)
imager["Maximum"].SetViewport(0, .33, .5, .667)
imager["Mean"].SetViewport(.5, 0, 1, .33)
imager["Median"].SetViewport(.5, .33, 1, .667)
imager["NoOp"].SetViewport(0, .667, 1, 1)
renWin.SetSize(256, 384)
# render and interact with data
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renWin)
renWin.Render()
img_file = "TestAllShrinks.png"
vtk.test.Testing.compareImage(
iRen.GetRenderWindow(),
vtk.test.Testing.getAbsImagePath(img_file),
threshold=25)
vtk.test.Testing.interact()
def get_image_actor(image_array, clim=None, actortype='vtkImageActor'):
image = image_array.copy()
if clim is None:
if image.min() != image.max():
clim = [image.min(), image.max()]
else:
clim = [0, 255]
clim = np.array(clim)
# If the array isn't already 8-bit int, make it 8-bit int...
if image.dtype != np.uint8:
# If we're given a higher bit-depth integer, it's easy to downcast it.
if image.dtype == np.uint16 or image.dtype == np.int16:
image = np.uint8(image / 2**8)
clim = np.uint8(clim / 2**8)
elif image.dtype == np.uint32 or image.dtype == np.int32:
image = np.uint8(image / 2**24)
clim = np.uint8(clim / 2**24)
elif image.dtype == np.uint64 or image.dtype == np.int64:
image = np.uint8(image / 2**56)
clim = np.uint8(clim / 2**24)
# Otherwise, scale it in a floating point way to its own max & min
# and strip out any transparency info (since we can't be sure of the scale used for transparency)
else:
if image.min() < 0:
image = image - image.min()
clim = clim - image.min()
if len(image.shape) == 3:
if image.shape[2] == 4:
image = image[:, :, :-1]
image = np.uint8(255. * (image - image.min()) /
(image.max() - image.min()))
vtk_im_importer = vtk.vtkImageImport()
# Create a temporary floating point copy of the data, for scaling.
# Also flip the data (vtk addresses y from bottom right) and put in display coords.
image = np.float32(np.flipud(image))
clim = np.float32(clim)
# Scale to colour limits and convert to uint8 for displaying.
image -= clim[0]
image /= (clim[1] - clim[0])
image *= 255.
image = np.uint8(image)
im_data_string = image.tostring()
vtk_im_importer.CopyImportVoidPointer(im_data_string, len(im_data_string))
vtk_im_importer.SetDataScalarTypeToUnsignedChar()
if len(image.shape) == 2:
vtk_im_importer.SetNumberOfScalarComponents(1)
else:
vtk_im_importer.SetNumberOfScalarComponents(image.shape[2])
vtk_im_importer.SetDataExtent(0, image.shape[1] - 1, 0, image.shape[0] - 1,
0, 0)
vtk_im_importer.SetWholeExtent(0, image.shape[1] - 1, 0,
image.shape[0] - 1, 0, 0)
if actortype == 'vtkImageActor':
actor = vtk.vtkImageActor()
actor.InterpolateOff()
mapper = actor.GetMapper()
mapper.SetInputConnection(vtk_im_importer.GetOutputPort())
return actor
elif actortype == 'vtkActor2D':
resizer = vtk.vtkImageResize()
resizer.SetInputConnection(vtk_im_importer.GetOutputPort())
resizer.SetResizeMethodToOutputDimensions()
resizer.SetOutputDimensions(
(image_array.shape[1], image_array.shape[0], 1))
resizer.InterpolateOff()
mapper = vtk.vtkImageMapper()
mapper.SetInputConnection(resizer.GetOutputPort())
mapper.SetColorWindow(255)
mapper.SetColorLevel(127.5)
actor = vtk.vtkActor2D()
actor.SetMapper(mapper)
actor.GetProperty().SetDisplayLocationToForeground()
return actor, resizer
def _CreateLabel(self):
borderwidth = self._Config['borderwidth']
width, height = self._DisplaySize
x, y = self._DisplayOrigin
x0, y0 = self._Renderer.GetOrigin()
image = self._Config['bitmap']
# set up the border
self._Points = vtk.vtkPoints()
self._SetPoints()
cells = vtk.vtkCellArray()
cells.InsertNextCell(4)
cells.InsertCellPoint(1)
cells.InsertCellPoint(3)
cells.InsertCellPoint(5)
cells.InsertCellPoint(7)
if borderwidth > 0:
cells.InsertNextCell(4)
cells.InsertCellPoint(0)
cells.InsertCellPoint(1)
cells.InsertCellPoint(3)
cells.InsertCellPoint(2)
cells.InsertNextCell(4)
cells.InsertCellPoint(2)
cells.InsertCellPoint(3)
cells.InsertCellPoint(5)
cells.InsertCellPoint(4)
cells.InsertNextCell(4)
cells.InsertCellPoint(4)
cells.InsertCellPoint(5)
cells.InsertCellPoint(7)
cells.InsertCellPoint(6)
cells.InsertNextCell(4)
cells.InsertCellPoint(6)
cells.InsertCellPoint(7)
cells.InsertCellPoint(1)
cells.InsertCellPoint(0)
try: # for VTK 3.x
scalars = vtk.vtkScalars()
scalars.SetDataTypeToUnsignedChar()
scalars.InsertScalar(0, 0)
scalars.InsertScalar(1, 2)
scalars.InsertScalar(2, 2)
scalars.InsertScalar(3, 3)
scalars.InsertScalar(4, 3)
except (NameError, AttributeError):
scalars = vtk.vtkUnsignedCharArray()
scalars.InsertTuple1(0, 0)
scalars.InsertTuple1(1, 2)
scalars.InsertTuple1(2, 2)
scalars.InsertTuple1(3, 3)
scalars.InsertTuple1(4, 3)
data = vtk.vtkPolyData()
data.SetPoints(self._Points)
data.SetPolys(cells)
data.GetCellData().SetScalars(scalars)
mapper = vtk.vtkPolyDataMapper2D()
mapper.SetInput(data)
mapper.SetLookupTable(self._LookupTable)
mapper.SetColorModeToMapScalars()
mapper.SetScalarRange(0, 3)
actor = vtk.vtkActor2D()
actor.SetMapper(mapper)
actor.SetPosition(x - x0, y - y0)
self._Scalars = scalars
self._Actors.append(actor)
if self._Renderer:
self._Renderer.AddActor2D(actor)
# if there is a bitmap
if image:
image.UpdateInformation()
extent = image.GetExtent() # VTK 6
spacing = image.GetSpacing()
origin = image.GetOrigin()
newextent = (0, width - 1 - borderwidth * 2,
0, height - 1 - borderwidth * 2,
extent[4], extent[5])
newspacing = (spacing[0] * float(extent[1] - extent[0]) /
float(newextent[1] - newextent[0]),
spacing[1] * float(extent[3] - extent[2]) /
float(newextent[3] - newextent[2]),
spacing[2])
neworigin = (origin[0] + extent[0] * spacing[0] -
newextent[0] * newspacing[0],
origin[1] + extent[2] * spacing[1] -
newextent[2] * newspacing[1],
origin[2])
reslice = vtk.vtkImageReslice()
reslice.SetInput(image)
reslice.SetInterpolationModeToCubic()
reslice.SetOutputExtent(newextent)
reslice.SetOutputSpacing(newspacing)
reslice.SetOutputOrigin(neworigin)
self._BitmapReslice = reslice
mapper = vtk.vtkImageMapper()
mapper.SetInput(reslice.GetOutput())
mapper.SetColorWindow(255.0)
mapper.SetColorLevel(127.5)
actor = vtk.vtkActor2D()
actor.SetMapper(mapper)
actor.SetPosition(x - x0, y - y0)
self._Actors.append(actor)
if self._Renderer:
self._Renderer.AddActor2D(actor)
mapper = vtk.vtkTextMapper()
mapper.SetInput(self._Config['text'])
try:
property = mapper.GetTextProperty()
except AttributeError:
property = mapper
property.SetFontSize(self._Config['fontsize'])
if self._Config['font'] in ('courier', 'Courier'):
property.SetFontFamilyToCourier()
elif self._Config['font'] in ('arial', 'Arial'):
property.SetFontFamilyToArial()
elif self._Config['font'] in ('times', 'Times'):
property.SetFontFamilyToTimes()
property.SetJustificationToCentered()
property.SetVerticalJustificationToCentered()
property.BoldOn()
self._TextMapper = mapper
actor = vtk.vtkActor2D()
actor.GetProperty().SetColor(*self._Config['foreground'])
actor.SetMapper(mapper)
if "FreeType" in mapper.GetClassName():
actor.SetPosition(x + old_div(width, 2) - x0,
y + old_div(height, 2) - y0)
else: # not a FreeType font, needs position correction
actor.SetPosition(x + old_div(width, 2) - x0 + 1,
y + old_div(height, 2) - y0 + 1)
self._Actors.append(actor)
if self._Renderer:
self._Renderer.AddActor2D(actor)
source = mabdi.SourceEnvironmentTable()
source.Update()
fdi = mabdi.FilterDepthImage(offscreen=False)
fdi.set_polydata(source)
# show output of the filter
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
iren = vtk.vtkRenderWindowInteractor()
renWin.AddRenderer(ren)
iren.SetRenderWindow(renWin)
renWin.SetSize(640, 480)
imageMapper = vtk.vtkImageMapper()
imageMapper.SetInputConnection(fdi.GetOutputPort())
imageMapper.SetColorWindow(1.0)
imageMapper.SetColorLevel(0.5)
imageActor = vtk.vtkActor2D()
imageActor.SetMapper(imageMapper)
ren.AddActor(imageActor)
iren.Initialize()
iren.Render()
rang = np.arange(-40, 41, dtype=float)
position = np.vstack((rang/20,
np.ones(len(rang)),
np.ones(len(rang))*2)).T
lookat = np.vstack((rang/40,
def testWipe(self):
# Image pipeline
renWin = vtk.vtkRenderWindow()
image1 = vtk.vtkImageCanvasSource2D()
image1.SetNumberOfScalarComponents(3)
image1.SetScalarTypeToUnsignedChar()
image1.SetExtent(0, 79, 0, 79, 0, 0)
image1.SetDrawColor(255, 255, 0)
image1.FillBox(0, 79, 0, 79)
image1.Update()
image2 = vtk.vtkImageCanvasSource2D()
image2.SetNumberOfScalarComponents(3)
image2.SetScalarTypeToUnsignedChar()
image2.SetExtent(0, 79, 0, 79, 0, 0)
image2.SetDrawColor(0, 255, 255)
image2.FillBox(0, 79, 0, 79)
image2.Update()
mapper = vtk.vtkImageMapper()
mapper.SetInputConnection(image1.GetOutputPort())
mapper.SetColorWindow(255)
mapper.SetColorLevel(127.5)
actor = vtk.vtkActor2D()
actor.SetMapper(mapper)
imager = vtk.vtkRenderer()
imager.AddActor2D(actor)
renWin.AddRenderer(imager)
wipes = ["Quad", "Horizontal", "Vertical", "LowerLeft", "LowerRight", "UpperLeft", "UpperRight"]
wiper = dict()
mapper = dict()
actor = dict()
imagers = dict()
for wipe in wipes:
wiper.update({wipe:vtk.vtkImageRectilinearWipe()})
wiper[wipe].SetInput1Data(image1.GetOutput())
wiper[wipe].SetInput2Data(image2.GetOutput())
wiper[wipe].SetPosition(20, 20)
eval('wiper[wipe].SetWipeTo' + wipe + '()')
mapper.update({wipe:vtk.vtkImageMapper()})
mapper[wipe].SetInputConnection(wiper[wipe].GetOutputPort())
mapper[wipe].SetColorWindow(255)
mapper[wipe].SetColorLevel(127.5)
actor.update({wipe:vtk.vtkActor2D()})
actor[wipe].SetMapper(mapper[wipe])
imagers.update({wipe:vtk.vtkRenderer()})
imagers[wipe].AddActor2D(actor[wipe])
renWin.AddRenderer(imagers[wipe])
imagers["Quad"].SetViewport(0, .5, .25, 1)
imagers["Horizontal"].SetViewport(.25, .5, .5, 1)
imagers["Vertical"].SetViewport(.5, .5, .75, 1)
imagers["LowerLeft"].SetViewport(.75, .5, 1, 1)
imagers["LowerRight"].SetViewport(0, 0, .25, .5)
imagers["UpperLeft"].SetViewport(.25, 0, .5, .5)
imagers["UpperRight"].SetViewport(.5, 0, .75, .5)
imager.SetViewport(.75, 0, 1, .5)
renWin.SetSize(400, 200)
# render and interact with data
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renWin);
renWin.Render()
img_file = "TestWipe.png"
vtk.test.Testing.compareImage(iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25)
vtk.test.Testing.interact()
def testAllMathematics(self):
# append multiple displaced spheres into an RGB image.
# Image pipeline
renWin = vtk.vtkRenderWindow()
sphere1 = vtk.vtkImageEllipsoidSource()
sphere1.SetCenter(40, 20, 0)
sphere1.SetRadius(30, 30, 0)
sphere1.SetInValue(.75)
sphere1.SetOutValue(.3)
sphere1.SetOutputScalarTypeToFloat()
sphere1.SetWholeExtent(0, 99, 0, 74, 0, 0)
sphere1.Update()
sphere2 = vtk.vtkImageEllipsoidSource()
sphere2.SetCenter(60, 30, 0)
sphere2.SetRadius(20, 20, 20)
sphere2.SetInValue(.2)
sphere2.SetOutValue(.5)
sphere2.SetOutputScalarTypeToFloat()
sphere2.SetWholeExtent(0, 99, 0, 74, 0, 0)
sphere2.Update()
mathematics = [
"Add", "Subtract", "Multiply", "Divide", "Invert", "Sin", "Cos",
"Exp", "Log", "AbsoluteValue", "Square", "SquareRoot", "Min",
"Max", "ATAN", "ATAN2", "MultiplyByK", "ReplaceCByK", "AddConstant"
]
mathematic = list()
mapper = list()
actor = list()
imager = list()
for idx, operator in enumerate(mathematics):
mathematic.append(vtk.vtkImageMathematics())
mathematic[idx].SetInput1Data(sphere1.GetOutput())
mathematic[idx].SetInput2Data(sphere2.GetOutput())
eval('mathematic[idx].SetOperationTo' + operator + '()')
mathematic[idx].SetConstantK(.3)
mathematic[idx].SetConstantC(.75)
mapper.append(vtk.vtkImageMapper())
mapper[idx].SetInputConnection(mathematic[idx].GetOutputPort())
mapper[idx].SetColorWindow(2.0)
mapper[idx].SetColorLevel(.75)
actor.append(vtk.vtkActor2D())
actor[idx].SetMapper(mapper[idx])
imager.append(vtk.vtkRenderer())
imager[idx].AddActor2D(actor[idx])
renWin.AddRenderer(imager[idx])
column = 1
row = 1
deltaX = 1.0 / 6.0
deltaY = 1.0 / 4.0
for idx, operator in enumerate(mathematics):
imager[idx].SetViewport((column - 1) * deltaX, (row - 1) * deltaY,
column * deltaX, row * deltaY)
column += 1
if column > 6:
column = 1
row += 1
# Make the last operator finish the row
vp = imager[len(mathematics) - 1].GetViewport()
imager[len(mathematics) - 1].SetViewport(vp[0], vp[1], 1, 1)
renWin.SetSize(600, 300)
# render and interact with data
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renWin)
renWin.Render()
img_file = "TestAllMathematics.png"
vtk.test.Testing.compareImage(
iRen.GetRenderWindow(),
vtk.test.Testing.getAbsImagePath(img_file),
threshold=25)
vtk.test.Testing.interact()
def testAllBlendsFloat(self):
# This script blends images that consist of float data
renWin = vtk.vtkRenderWindow()
renWin.SetSize(512, 256)
# Image pipeline
inputImage = vtk.vtkTIFFReader()
inputImage.SetFileName(VTK_DATA_ROOT + "/Data/beach.tif")
# "beach.tif" image contains ORIENTATION tag which is
# ORIENTATION_TOPLEFT (row 0 top, col 0 lhs) type. The TIFF
# reader parses this tag and sets the internal TIFF image
# orientation accordingly. To overwrite this orientation with a vtk
# convention of ORIENTATION_BOTLEFT (row 0 bottom, col 0 lhs ), invoke
# SetOrientationType method with parameter value of 4.
inputImage.SetOrientationType(4)
inputImage2 = vtk.vtkBMPReader()
inputImage2.SetFileName(VTK_DATA_ROOT + "/Data/masonry.bmp")
# shrink the images to a reasonable size
shrink1 = vtk.vtkImageShrink3D()
shrink1.SetInputConnection(inputImage.GetOutputPort())
shrink1.SetShrinkFactors(2, 2, 1)
shrink2 = vtk.vtkImageShrink3D()
shrink2.SetInputConnection(inputImage2.GetOutputPort())
shrink2.SetShrinkFactors(2, 2, 1)
color = vtk.vtkImageShiftScale()
color.SetOutputScalarTypeToFloat()
color.SetShift(0)
color.SetScale(1.0 / 255)
color.SetInputConnection(shrink1.GetOutputPort())
backgroundColor = vtk.vtkImageShiftScale()
backgroundColor.SetOutputScalarTypeToFloat()
backgroundColor.SetShift(0)
backgroundColor.SetScale(1.0 / 255)
backgroundColor.SetInputConnection(shrink2.GetOutputPort())
# create a greyscale version
luminance = vtk.vtkImageLuminance()
luminance.SetInputConnection(color.GetOutputPort())
backgroundLuminance = vtk.vtkImageLuminance()
backgroundLuminance.SetInputConnection(backgroundColor.GetOutputPort())
# create an alpha mask
alpha = vtk.vtkImageThreshold()
alpha.SetInputConnection(luminance.GetOutputPort())
alpha.ThresholdByLower(0.9)
alpha.SetInValue(1.0)
alpha.SetOutValue(0.0)
# make luminanceAlpha and colorAlpha versions
luminanceAlpha = vtk.vtkImageAppendComponents()
luminanceAlpha.AddInputConnection(luminance.GetOutputPort())
luminanceAlpha.AddInputConnection(alpha.GetOutputPort())
colorAlpha = vtk.vtkImageAppendComponents()
colorAlpha.AddInputConnection(color.GetOutputPort())
colorAlpha.AddInputConnection(alpha.GetOutputPort())
foregrounds = ["luminance", "luminanceAlpha", "color", "colorAlpha"]
backgrounds = ["backgroundColor", "backgroundLuminance"]
deltaX = 1.0 / 4.0
deltaY = 1.0 / 2.0
blend = dict()
mapper = dict()
actor = dict()
imager = dict()
for row, bg in enumerate(backgrounds):
for column, fg in enumerate(foregrounds):
blend.update({bg:{fg:vtk.vtkImageBlend()}})
blend[bg][fg].AddInputConnection(eval(bg + '.GetOutputPort()'))
if bg == "backgroundColor" or fg == "luminance" or fg == "luminanceAlpha":
blend[bg][fg].AddInputConnection(eval(fg + '.GetOutputPort()'))
blend[bg][fg].SetOpacity(1, 0.8)
mapper.update({bg:{fg:vtk.vtkImageMapper()}})
mapper[bg][fg].SetInputConnection(blend[bg][fg].GetOutputPort())
mapper[bg][fg].SetColorWindow(1.0)
mapper[bg][fg].SetColorLevel(0.5)
actor.update({bg:{fg:vtk.vtkActor2D()}})
actor[bg][fg].SetMapper(mapper[bg][fg])
imager.update({bg:{fg:vtk.vtkRenderer()}})
imager[bg][fg].AddActor2D(actor[bg][fg])
imager[bg][fg].SetViewport(column * deltaX, row * deltaY, (column + 1) * deltaX, (row + 1) * deltaY)
renWin.AddRenderer(imager[bg][fg])
# render and interact with data
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renWin);
renWin.Render()
img_file = "TestAllBlendsFloat.png"
vtk.test.Testing.compareImage(iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25)
vtk.test.Testing.interact()
def testAllShrinks(self):
prefix = VTK_DATA_ROOT + "/Data/headsq/quarter"
renWin = vtk.vtkRenderWindow()
# Image pipeline
reader = vtk.vtkImageReader()
reader.SetDataExtent(0, 63, 0, 63, 1, 93)
reader.SetFilePrefix(prefix)
reader.SetDataByteOrderToLittleEndian()
reader.SetDataMask(0x7fff)
factor = 4
magFactor = 8
ops = ["Minimum", "Maximum", "Mean", "Median", "NoOp"]
shrink = dict()
mag = dict()
mapper = dict()
actor = dict()
imager = dict()
for operator in ops:
shrink.update({operator:vtk.vtkImageShrink3D()})
shrink[operator].SetMean(0)
if operator != "NoOp":
eval('shrink[operator].' + operator + 'On()')
shrink[operator].SetShrinkFactors(factor, factor, factor)
shrink[operator].SetInputConnection(reader.GetOutputPort())
mag.update({operator:vtk.vtkImageMagnify()})
mag[operator].SetMagnificationFactors(magFactor, magFactor, magFactor)
mag[operator].InterpolateOff()
mag[operator].SetInputConnection(shrink[operator].GetOutputPort())
mapper.update({operator:vtk.vtkImageMapper()})
mapper[operator].SetInputConnection(mag[operator].GetOutputPort())
mapper[operator].SetColorWindow(2000)
mapper[operator].SetColorLevel(1000)
mapper[operator].SetZSlice(45)
actor.update({operator:vtk.vtkActor2D()})
actor[operator].SetMapper(mapper[operator])
imager.update({operator:vtk.vtkRenderer()})
imager[operator].AddActor2D(actor[operator])
renWin.AddRenderer(imager[operator])
shrink["Minimum"].Update
shrink["Maximum"].Update
shrink["Mean"].Update
shrink["Median"].Update
imager["Minimum"].SetViewport(0, 0, .5, .33)
imager["Maximum"].SetViewport(0, .33, .5, .667)
imager["Mean"].SetViewport(.5, 0, 1, .33)
imager["Median"].SetViewport(.5, .33, 1, .667)
imager["NoOp"].SetViewport(0, .667, 1, 1)
renWin.SetSize(256, 384)
# render and interact with data
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renWin);
renWin.Render()
img_file = "TestAllShrinks.png"
vtk.test.Testing.compareImage(iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25)
vtk.test.Testing.interact()
def testAllLogic(self):
# append multiple displaced spheres into an RGB image.
# Image pipeline
renWin = vtk.vtkRenderWindow()
logics = ["And", "Or", "Xor", "Nand", "Nor", "Not"]
types = [
"Float", "Double", "UnsignedInt", "UnsignedLong", "UnsignedShort",
"UnsignedChar"
]
sphere1 = list()
sphere2 = list()
logic = list()
mapper = list()
actor = list()
imager = list()
for idx, operator in enumerate(logics):
ScalarType = types[idx]
sphere1.append(vtk.vtkImageEllipsoidSource())
sphere1[idx].SetCenter(95, 100, 0)
sphere1[idx].SetRadius(70, 70, 70)
eval('sphere1[idx].SetOutputScalarTypeTo' + ScalarType + '()')
sphere1[idx].Update()
sphere2.append(vtk.vtkImageEllipsoidSource())
sphere2[idx].SetCenter(161, 100, 0)
sphere2[idx].SetRadius(70, 70, 70)
eval('sphere2[idx].SetOutputScalarTypeTo' + ScalarType + '()')
sphere2[idx].Update()
logic.append(vtk.vtkImageLogic())
logic[idx].SetInput1Data(sphere1[idx].GetOutput())
if operator != "Not":
logic[idx].SetInput2Data(sphere2[idx].GetOutput())
logic[idx].SetOutputTrueValue(150)
eval('logic[idx].SetOperationTo' + operator + '()')
mapper.append(vtk.vtkImageMapper())
mapper[idx].SetInputConnection(logic[idx].GetOutputPort())
mapper[idx].SetColorWindow(255)
mapper[idx].SetColorLevel(127.5)
actor.append(vtk.vtkActor2D())
actor[idx].SetMapper(mapper[idx])
imager.append(vtk.vtkRenderer())
imager[idx].AddActor2D(actor[idx])
renWin.AddRenderer(imager[idx])
imager[0].SetViewport(0, .5, .33, 1)
imager[1].SetViewport(.33, .5, .66, 1)
imager[2].SetViewport(.66, .5, 1, 1)
imager[3].SetViewport(0, 0, .33, .5)
imager[4].SetViewport(.33, 0, .66, .5)
imager[5].SetViewport(.66, 0, 1, .5)
renWin.SetSize(768, 512)
# render and interact with data
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renWin)
renWin.Render()
img_file = "TestAllLogic.png"
vtk.test.Testing.compareImage(
iRen.GetRenderWindow(),
vtk.test.Testing.getAbsImagePath(img_file),
threshold=25)
vtk.test.Testing.interact()
def testAllBlends(self):
# This script calculates the luminance of an image
renWin = vtk.vtkRenderWindow()
renWin.SetSize(512, 256)
# Image pipeline
image1 = vtk.vtkTIFFReader()
image1.SetFileName(VTK_DATA_ROOT + "/Data/beach.tif")
# "beach.tif" image contains ORIENTATION tag which is
# ORIENTATION_TOPLEFT (row 0 top, col 0 lhs) type. The TIFF
# reader parses this tag and sets the internal TIFF image
# orientation accordingly. To overwrite this orientation with a vtk
# convention of ORIENTATION_BOTLEFT (row 0 bottom, col 0 lhs ), invoke
# SetOrientationType method with parameter value of 4.
image1.SetOrientationType(4)
image2 = vtk.vtkBMPReader()
image2.SetFileName(VTK_DATA_ROOT + "/Data/masonry.bmp")
# shrink the images to a reasonable size
color = vtk.vtkImageShrink3D()
color.SetInputConnection(image1.GetOutputPort())
color.SetShrinkFactors(2, 2, 1)
backgroundColor = vtk.vtkImageShrink3D()
backgroundColor.SetInputConnection(image2.GetOutputPort())
backgroundColor.SetShrinkFactors(2, 2, 1)
# create a greyscale version
luminance = vtk.vtkImageLuminance()
luminance.SetInputConnection(color.GetOutputPort())
backgroundLuminance = vtk.vtkImageLuminance()
backgroundLuminance.SetInputConnection(backgroundColor.GetOutputPort())
# create an alpha mask
table = vtk.vtkLookupTable()
table.SetTableRange(220, 255)
table.SetValueRange(1, 0)
table.SetSaturationRange(0, 0)
table.Build()
alpha = vtk.vtkImageMapToColors()
alpha.SetInputConnection(luminance.GetOutputPort())
alpha.SetLookupTable(table)
alpha.SetOutputFormatToLuminance()
# make luminanceAlpha and colorAlpha versions
luminanceAlpha = vtk.vtkImageAppendComponents()
luminanceAlpha.AddInputConnection(luminance.GetOutputPort())
luminanceAlpha.AddInputConnection(alpha.GetOutputPort())
colorAlpha = vtk.vtkImageAppendComponents()
colorAlpha.AddInputConnection(color.GetOutputPort())
colorAlpha.AddInputConnection(alpha.GetOutputPort())
foregrounds = ["luminance", "luminanceAlpha", "color", "colorAlpha"]
backgrounds = ["backgroundColor", "backgroundLuminance"]
deltaX = 1.0 / 4.0
deltaY = 1.0 / 2.0
blend = dict()
mapper = dict()
actor = dict()
imager = dict()
for row, bg in enumerate(backgrounds):
for column, fg in enumerate(foregrounds):
blend.update({bg:{fg:vtk.vtkImageBlend()}})
blend[bg][fg].AddInputConnection(eval(bg + '.GetOutputPort()'))
if bg == "backgroundColor" or fg == "luminance" or fg == "luminanceAlpha":
blend[bg][fg].AddInputConnection(eval(fg + '.GetOutputPort()'))
blend[bg][fg].SetOpacity(1, 0.8)
mapper.update({bg:{fg:vtk.vtkImageMapper()}})
mapper[bg][fg].SetInputConnection(blend[bg][fg].GetOutputPort())
mapper[bg][fg].SetColorWindow(255)
mapper[bg][fg].SetColorLevel(127.5)
actor.update({bg:{fg:vtk.vtkActor2D()}})
actor[bg][fg].SetMapper(mapper[bg][fg])
imager.update({bg:{fg:vtk.vtkRenderer()}})
imager[bg][fg].AddActor2D(actor[bg][fg])
imager[bg][fg].SetViewport(column * deltaX, row * deltaY, (column + 1) * deltaX, (row + 1) * deltaY)
renWin.AddRenderer(imager[bg][fg])
column += 1
# render and interact with data
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renWin);
renWin.Render()
img_file = "TestAllBlends.png"
vtk.test.Testing.compareImage(iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25)
vtk.test.Testing.interact()
def render(Data1, Data2, point):
ren = vtk.vtkRenderer()
ren.SetBackground(.1, .2, .5)
ren2dimg1 = vtk.vtkRenderer()
ren2dimg2 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
renWin.AddRenderer(ren2dimg1)
renWin.AddRenderer(ren2dimg2)
renWin.SetSize(1536, 1024)
# Create a render window
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
pts = vtk.vtkPoints()
[img1_position, img2_position, epi_point1,
epi_point2] = epigeometry_points(pts, point, Data1, Data2)
colors = vtk.vtkUnsignedCharArray()
colors.SetNumberOfComponents(3)
colors.SetName("Colors")
lines = vtk.vtkCellArray()
add_3dline(lines, pts, 0, 1, colors, 'r')
add_3dline(lines, pts, 2, 3, colors, 'g')
add_3dline(lines, pts, 1, 4, colors, 'w')
add_3dline(lines, pts, 3, 5, colors, 'w')
add_3dline(lines, pts, 3, 6, colors, 'w')
add_3dline(lines, pts, 5, 6, colors, 'w')
linesPolyData = vtk.vtkPolyData()
linesPolyData.SetPoints(pts)
linesPolyData.SetLines(lines)
linesPolyData.GetCellData().SetScalars(colors)
mapper = vtk.vtkPolyDataMapper()
if vtk.VTK_MAJOR_VERSION <= 5:
mapper.SetInput(linesPolyData)
else:
mapper.SetInputData(linesPolyData)
lineactor = vtk.vtkActor()
lineactor.SetMapper(mapper)
img1 = Data1.img.copy()
img2 = Data2.img.copy()
cv2.circle(img1, (point[0], point[1]), 10, (255, 0, 0), -1)
cv2.line(img2, (int(epi_point1[0]), int(epi_point1[1])),
(int(epi_point2[0]), int(epi_point2[1])), (255, 0, 0), 5)
cv2.putText(
img1,
str(int(np.rad2deg(Data1.PA))) + ', ' + str(int(np.rad2deg(Data1.SA))),
(10, 100), 1, 4, (255, 255, 255), 2, cv2.LINE_AA)
cv2.putText(
img2,
str(int(np.rad2deg(Data2.PA))) + ', ' + str(int(np.rad2deg(Data2.SA))),
(10, 100), 1, 4, (255, 255, 255), 2, cv2.LINE_AA)
reader1 = vtkImageImportFromArray()
reader1.SetArray(img1)
reader1.Update()
fliper1 = vtk.vtkImageFlip()
fliper1.SetFilteredAxis(1)
fliper1.SetInputConnection(reader1.GetOutputPort())
fliper1.Update()
reader2 = vtkImageImportFromArray()
reader2.SetArray(img2)
reader2.Update()
fliper2 = vtk.vtkImageFlip()
fliper2.SetFilteredAxis(1)
fliper2.SetInputConnection(reader2.GetOutputPort())
fliper2.Update()
# transform1 = vtk.vtkTransform()
# transform1.Translate(img1_position)
# transform1.RotateY(np.rad2deg(Data1.PA))
# transform1.RotateX(-np.rad2deg(Data1.SA))
# transform1.Scale(img1.shape[0]*Data1.PS[0],img1.shape[1]*Data1.PS[1],1)
# transform2 = vtk.vtkTransform()
# transform2.Translate(img2_position)
# transform2.RotateY(np.rad2deg(Data2.PA))
# transform2.RotateZ(-np.rad2deg(Data2.SA))
# transform2.Scale(img2.shape[0]*Data2.PS[0],img2.shape[1]*Data2.PS[1],1)
planeA_actor = createQuad(img1)
planeA_actor.SetPosition(img1_position)
planeA_actor.SetScale(Data1.PS[0], Data1.PS[1], 1)
planeA_actor.RotateY(np.rad2deg(Data1.PA))
planeA_actor.RotateX(-np.rad2deg(Data1.SA))
# planeA_actor.SetUserTransform(transform1)
planeB_actor = createQuad(img2)
planeB_actor.SetPosition(img2_position)
planeB_actor.SetScale(Data2.PS[0], Data2.PS[1], 1)
planeB_actor.RotateY(np.rad2deg(Data2.PA))
planeB_actor.RotateZ(-np.rad2deg(Data2.SA))
# planeB_actor.SetUserTransform(transform2)
axes = vtk.vtkAxesActor()
transform = vtk.vtkTransform()
transform.Scale(100, 100, 100)
axes.SetUserTransform(transform)
textProperty = vtk.vtkTextProperty()
textProperty.SetFontSize(25)
textProperty.SetJustificationToCentered()
textMapper = vtk.vtkTextMapper()
textActor = vtk.vtkActor2D()
textMapper.SetInput('Epipolar Geometry')
textMapper.SetTextProperty(textProperty)
textActor.SetMapper(textMapper)
textActor.SetPosition(512, 950)
ren.AddActor(lineactor)
ren.AddActor(planeA_actor)
ren.AddActor(planeB_actor)
ren.AddActor(axes)
ren.AddViewProp(textActor)
ren.SetViewport([0.0, 0.0, 2 / 3, 1.0])
mapper2d1 = vtk.vtkImageMapper()
mapper2d1.SetInputConnection(fliper1.GetOutputPort())
mapper2d1.SetColorWindow(255)
mapper2d1.SetColorLevel(127.5)
actor2d1 = vtk.vtkActor2D()
actor2d1.SetMapper(mapper2d1)
ren2dimg1.AddActor2D(actor2d1)
ren2dimg1.SetViewport([2 / 3, 0.5, 1.0, 1.0])
mapper2d2 = vtk.vtkImageMapper()
mapper2d2.SetInputConnection(fliper2.GetOutputPort())
mapper2d2.SetColorWindow(255)
mapper2d2.SetColorLevel(127.5)
actor2d2 = vtk.vtkActor2D()
actor2d2.SetMapper(mapper2d2)
ren2dimg2.AddActor2D(actor2d2)
ren2dimg2.SetViewport([2 / 3, 0.0, 1.0, 0.5])
iren.Initialize()
renWin.Render()
iren.Start()
print("GetAlphaBitPlanes: " + str(renWin.GetAlphaBitPlanes()))
# create window to image filter, grabbing RGB and alpha
w2i = vtk.vtkWindowToImageFilter()
w2i.SetInput(renWin)
w2i.SetInputBufferTypeToRGBA()
# grab window
w2i.Update()
# copy the output
outputData = w2i.GetOutput().NewInstance()
outputData.DeepCopy(w2i.GetOutput())
# set up mappers and actors to display the image
im = vtk.vtkImageMapper()
im.SetColorWindow(255)
im.SetColorLevel(127.5)
im.SetInputData(outputData)
ia2 = vtk.vtkActor2D()
ia2.SetMapper(im)
# now, change the image (background is now green)
sphactor.SetScale(2, 2, 2)
ren1.SetBackground(0, 1, 0)
# add the image of the sphere (keeping the original sphere too)
ren1.AddActor(ia2)
ren1.SetViewport(0, 0, 1, 1)
blend = dict()
mapper = dict()
actor = dict()
imager = dict()
for row, bg in enumerate(backgrounds):
for column, fg in enumerate(foregrounds):
blend.update({bg: {fg: vtk.vtkImageBlend()}})
blend[bg][fg].AddInputConnection(eval(bg + '.GetOutputPort()'))
blend[bg][fg].SetBlendModeToCompound()
if bg == "backgroundColor" or fg == "luminance" or fg == "luminanceAlpha":
blend[bg][fg].AddInputConnection(eval(fg + '.GetOutputPort()'))
blend[bg][fg].SetOpacity(1, 0.8)
mapper.update({bg: {fg: vtk.vtkImageMapper()}})
mapper[bg][fg].SetInputConnection(blend[bg][fg].GetOutputPort())
mapper[bg][fg].SetColorWindow(255)
mapper[bg][fg].SetColorLevel(127.5)
actor.update({bg: {fg: vtk.vtkActor2D()}})
actor[bg][fg].SetMapper(mapper[bg][fg])
imager.update({bg: {fg: vtk.vtkRenderer()}})
imager[bg][fg].AddActor2D(actor[bg][fg])
imager[bg][fg].SetViewport(column * deltaX, row * deltaY,
(column + 1) * deltaX, (row + 1) * deltaY)
renWin.AddRenderer(imager[bg][fg])
column += 1
def testThreshold(self):
# This script is for testing the 3D threshold filter.
# Image pipeline
renWin = vtk.vtkRenderWindow()
renWin.SetSize(192, 256)
reader = vtk.vtkImageReader()
reader.ReleaseDataFlagOff()
reader.SetDataByteOrderToLittleEndian()
reader.SetDataExtent(0, 63, 0, 63, 1, 93)
reader.SetDataSpacing(3.2, 3.2, 1.5)
reader.SetFilePrefix(VTK_DATA_ROOT + "/Data/headsq/quarter")
reader.SetDataMask(0x7fff)
outputtype = ["SignedChar", "UnsignedChar", "Long", "UnsignedLong", "Int", "UnsignedInt",
"Short", "UnsignedShort", "Double", "Float", "Double", "Float"]
replacein = ["ReplaceInOn", "ReplaceInOff"]
replaceout = ["ReplaceOutOn", "ReplaceOutOff"]
thresholds = ["ThresholdByLower(800)", "ThresholdByUpper(1200)", "ThresholdBetween(800, 1200)"]
thresh = list()
map = list()
act = list()
ren = list()
k = 0
for rin in replacein:
for rout in replaceout:
for t in thresholds:
thresh.append(vtk.vtkImageThreshold())
thresh[k].SetInValue(2000)
thresh[k].SetOutValue(0)
eval('thresh[k].' + rin + '()')
eval('thresh[k].' + rout + '()')
thresh[k].SetInputConnection(reader.GetOutputPort())
eval('thresh[k].' + t)
eval('thresh[k].SetOutputScalarTypeTo' + outputtype[k] + '()')
map.append(vtk.vtkImageMapper())
map[k].SetInputConnection(thresh[k].GetOutputPort())
if k < 3:
map[k].SetColorWindow(255)
map[k].SetColorLevel(127.5)
else:
map[k].SetColorWindow(2000)
map[k].SetColorLevel(1000)
act.append(vtk.vtkActor2D())
act[k].SetMapper(map[k])
ren.append(vtk.vtkRenderer())
ren[k].AddActor2D(act[k])
renWin.AddRenderer(ren[k])
k += 1
ren[0].SetViewport(0, 0, .33333, .25)
ren[1].SetViewport(.33333, 0, .66667, .25)
ren[2].SetViewport(.66667, 0, 1, .25)
ren[3].SetViewport(0, .25, .33333, .5)
ren[4].SetViewport(.33333, .25, .66667, .5)
ren[5].SetViewport(.66667, .25, 1, .5)
ren[6].SetViewport(0, .5, .33333, .75)
ren[7].SetViewport(.33333, .5, .66667, .75)
ren[8].SetViewport(.66667, .5, 1, .75)
ren[9].SetViewport(0, .75, .33333, 1)
ren[10].SetViewport(.33333, .75, .66667, 1)
ren[11].SetViewport(.66667, .75, 1, 1)
# render and interact with data
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renWin);
renWin.Render()
img_file = "TestThreshold.png"
vtk.test.Testing.compareImage(iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25)
vtk.test.Testing.interact()
def __init__(self, in_source):
self.mapper = vtk.vtkImageMapper()
self.mapper.SetInputConnection(in_source.GetOutputPort())
self.actor = vtk.vtkActor2D()
self.actor.SetMapper(self.mapper)
#!/usr/bin/env python
import vtk
from vtk.util.misc import vtkGetDataRoot
VTK_DATA_ROOT = vtkGetDataRoot()
#
# display text over an image
#
ellipse = vtk.vtkImageEllipsoidSource()
mapImage = vtk.vtkImageMapper()
mapImage.SetInputConnection(ellipse.GetOutputPort())
mapImage.SetColorWindow(255)
mapImage.SetColorLevel(127.5)
img = vtk.vtkActor2D()
img.SetMapper(mapImage)
mapText = vtk.vtkTextMapper()
mapText.SetInput("Text Overlay")
mapText.GetTextProperty().SetFontSize(15)
mapText.GetTextProperty().SetColor(0,1,1)
mapText.GetTextProperty().BoldOn()
mapText.GetTextProperty().ShadowOn()
txt = vtk.vtkActor2D()
txt.SetMapper(mapText)
txt.SetPosition(138,128)
ren1 = vtk.vtkRenderer()
ren1.AddActor2D(img)
ren1.AddActor2D(txt)
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
def SetMapper(self):
self.mapper = vtk.vtkImageMapper()
self.SetColorLevel()
self.SetColorWindow()
stencil1.SetInputConnection(reader.GetOutputPort()) stencil1.SetBackgroundInputData(shiftScale.GetOutput()) stencil1.SetStencilConnection(roiStencil1.GetOutputPort()) stencil2 = vtk.vtkImageStencil() stencil2.SetInputConnection(reader.GetOutputPort()) stencil2.SetBackgroundInputData(shiftScale.GetOutput()) stencil2.SetStencilConnection(roiStencil2.GetOutputPort()) stencil3 = vtk.vtkImageStencil() stencil3.SetInputConnection(reader.GetOutputPort()) stencil3.SetBackgroundInputData(shiftScale.GetOutput()) stencil3.SetStencilConnection(roiStencil3.GetOutputPort()) stencil4 = vtk.vtkImageStencil() stencil4.SetInputConnection(reader.GetOutputPort()) stencil4.SetBackgroundInputData(shiftScale.GetOutput()) stencil4.SetStencilConnection(roiStencil4.GetOutputPort()) mapper1 = vtk.vtkImageMapper() mapper1.SetInputConnection(stencil1.GetOutputPort()) mapper1.SetColorWindow(2000) mapper1.SetColorLevel(1000) mapper1.SetZSlice(0) mapper2 = vtk.vtkImageMapper() mapper2.SetInputConnection(stencil2.GetOutputPort()) mapper2.SetColorWindow(2000) mapper2.SetColorLevel(1000) mapper2.SetZSlice(0) mapper3 = vtk.vtkImageMapper() mapper3.SetInputConnection(stencil3.GetOutputPort()) mapper3.SetColorWindow(2000) mapper3.SetColorLevel(1000) mapper3.SetZSlice(0) mapper4 = vtk.vtkImageMapper()
def testAllMaskBits(self):
# This script calculates the luminance of an image
renWin = vtk.vtkRenderWindow()
# Image pipeline
image1 = vtk.vtkTIFFReader()
image1.SetFileName(VTK_DATA_ROOT + "/Data/beach.tif")
# "beach.tif" image contains ORIENTATION tag which is
# ORIENTATION_TOPLEFT (row 0 top, col 0 lhs) type. The TIFF
# reader parses this tag and sets the internal TIFF image
# orientation accordingly. To overwrite this orientation with a vtk
# convention of ORIENTATION_BOTLEFT (row 0 bottom, col 0 lhs ), invoke
# SetOrientationType method with parameter value of 4.
image1.SetOrientationType(4)
shrink = vtk.vtkImageShrink3D()
shrink.SetInputConnection(image1.GetOutputPort())
shrink.SetShrinkFactors(2, 2, 1)
operators = ["ByPass", "And", "Nand", "Xor", "Or", "Nor"]
operator = dict()
mapper = dict()
actor = dict()
imager = dict()
for idx, op in enumerate(operators):
if op != "ByPass":
operator.update({idx: vtk.vtkImageMaskBits()})
operator[idx].SetInputConnection(shrink.GetOutputPort())
eval('operator[' + str(idx) + '].SetOperationTo' + op + '()')
operator[idx].SetMasks(255, 255, 0)
mapper.update({idx: vtk.vtkImageMapper()})
if op != "ByPass":
mapper[idx].SetInputConnection(operator[idx].GetOutputPort())
else:
mapper[idx].SetInputConnection(shrink.GetOutputPort())
mapper[idx].SetColorWindow(255)
mapper[idx].SetColorLevel(127.5)
actor.update({idx: vtk.vtkActor2D()})
actor[idx].SetMapper(mapper[idx])
imager.update({idx: vtk.vtkRenderer()})
imager[idx].AddActor2D(actor[idx])
renWin.AddRenderer(imager[idx])
column = 0
row = 0
deltaX = 1.0 / 3.0
deltaY = 1.0 / 2.0
for idx in range(len(operators)):
imager[idx].SetViewport(column * deltaX, row * deltaY, (column + 1) * deltaX, (row + 1) * deltaY)
column += 1
if column > 2:
column = 0
row += 1
renWin.SetSize(384, 256)
# render and interact with data
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renWin);
renWin.Render()
img_file = "TestAllMaskBits.png"
vtk.test.Testing.compareImage(iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25)
vtk.test.Testing.interact()
reslice2.SetOutputExtent(0, 127, 0, 127, 0, 0) reslice3 = vtk.vtkImageReslice() reslice3.SetInputConnection(reader.GetOutputPort()) reslice3.WrapOn() reslice3.SetInterpolationModeToNearestNeighbor() reslice3.SetOutputSpacing(2.0, 2.0, 1.5) reslice3.SetOutputOrigin(-32, -32, 40) reslice3.SetOutputExtent(0, 127, 0, 127, 0, 0) reslice4 = vtk.vtkImageReslice() reslice4.SetInputConnection(reader.GetOutputPort()) reslice4.WrapOn() reslice4.SetInterpolationModeToLinear() reslice4.SetOutputSpacing(3.2, 3.2, 1.5) reslice4.SetOutputOrigin(-102.4, -102.4, 40) reslice4.SetOutputExtent(0, 127, 0, 127, 0, 0) mapper1 = vtk.vtkImageMapper() mapper1.SetInputConnection(reslice1.GetOutputPort()) mapper1.SetColorWindow(2000) mapper1.SetColorLevel(1000) mapper1.SetZSlice(0) mapper2 = vtk.vtkImageMapper() mapper2.SetInputConnection(reslice2.GetOutputPort()) mapper2.SetColorWindow(2000) mapper2.SetColorLevel(1000) mapper2.SetZSlice(0) mapper3 = vtk.vtkImageMapper() mapper3.SetInputConnection(reslice3.GetOutputPort()) mapper3.SetColorWindow(2000) mapper3.SetColorLevel(1000) mapper3.SetZSlice(0) mapper4 = vtk.vtkImageMapper()
blend.update({bg:{fg:vtk.vtkImageBlend()}})
blend[bg][fg].AddInputConnection(eval(bg + '.GetOutputPort()'))
blend[bg][fg].SetBlendModeToCompound()
if bg == "backgroundAlpha" or bg == "backgroundColor":
blend[bg][fg].AddInputConnection(eval(fg + '.GetOutputPort()'))
if bg == "backgroundAlpha":
blend[bg][fg].SetCompoundAlpha(True)
blend[bg][fg].SetOpacity(0, 0.5)
blend[bg][fg].SetOpacity(1, 0.5)
else:
blend[bg][fg].SetOpacity(1, 0.8)
elif fg == "luminance" or fg == "luminanceAlpha":
blend[bg][fg].AddInputConnection(eval(fg + '.GetOutputPort()'))
blend[bg][fg].SetOpacity(1, 0.8)
mapper.update({bg:{fg:vtk.vtkImageMapper()}})
mapper[bg][fg].SetInputConnection(blend[bg][fg].GetOutputPort())
mapper[bg][fg].SetColorWindow(255)
mapper[bg][fg].SetColorLevel(127.5)
actor.update({bg:{fg:vtk.vtkActor2D()}})
actor[bg][fg].SetMapper(mapper[bg][fg])
imager.update({bg:{fg:vtk.vtkRenderer()}})
imager[bg][fg].AddActor2D(actor[bg][fg])
imager[bg][fg].SetViewport(column * deltaX, row * deltaY, (column + 1) * deltaX, (row + 1) * deltaY)
imager[bg][fg].SetBackground(0.3, 0.3, 0.3)
renWin.AddRenderer(imager[bg][fg])
column += 1
