def __init__(self):
super(camphorBlendedStackVOI, self).__init__()
self.blender = vtk.vtkImageBlend()
self.sliceBlender = vtk.vtkImageBlend()
self.output = self.blender
self.sliceOutput = self.sliceBlender
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 SetInput(self, imagedata, mask_dict):
print "SETINPUT!"
self.imagedata = imagedata
self.extent = imagedata.GetExtent()
imagedata_bg = self.__create_background(imagedata)
if not mask_dict:
imagedata_mask = self.__build_mask(imagedata, create=True)
else:
self.__load_masks(imagedata, mask_dict)
imagedata_mask = self.img_colours_mask.GetOutput()
mask_opacity = self.current_mask.opacity
# blend both imagedatas, so it can be inserted into viewer
blend_filter = vtk.vtkImageBlend()
blend_filter.SetBlendModeToNormal()
blend_filter.SetOpacity(0, 1)
if self.current_mask.is_shown:
blend_filter.SetOpacity(1, mask_opacity)
else:
blend_filter.SetOpacity(1, 0)
blend_filter.SetInput(0, imagedata_bg)
blend_filter.SetInput(1, imagedata_mask)
blend_filter.SetBlendModeToNormal()
blend_filter.GetOutput().ReleaseDataFlagOn()
self.blend_filter = blend_filter
self.window_level = vtk.vtkImageMapToWindowLevelColors()
self.window_level.SetInput(self.imagedata)
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkImageBlend(), 'Processing.',
('vtkImageData', 'vtkImageStencilData'), ('vtkImageData',),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
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__(self):
super(camphorBlendedVOIs, self).__init__()
# data objects
self.data = [] # reference to the data array
# Blenders
self.blender = vtk.vtkImageBlend()
self.sliceBlender = vtk.vtkImageBlend()
# Other objects
self.image = []
self.append = vtk.vtkImageAppendComponents()
self.luminance = vtk.vtkImageLuminance()
# Output objects
self.output = self.blender
self.sliceOutput = self.append
def __init__(self):
super(camphorBlendedStacks, self).__init__()
self.blender = vtk.vtkImageBlend()
self.sliceBlender = vtk.vtkImageBlend()
self.output = self.blender
self.sliceOutput = self.sliceBlender
self.stack = [camphorStack() for i in range(2)]
self.append = vtk.vtkImageAppendComponents()
self.slice = [vtk.vtkImageReslice() for i in range(2)]
self.sliceAppend = vtk.vtkImageAppendComponents()
# Display mode: raw fluorescence or dF/F
self.displayMode = 0
self.numberOfTimeFrames = 0
self.currentTimeFrame = None
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self,
module_manager,
vtk.vtkImageBlend(),
'Processing.', ('vtkImageData', 'vtkImageStencilData'),
('vtkImageData', ),
replaceDoc=True,
inputFunctions=None,
outputFunctions=None)
def blend(self, pic, alpha1=0.5, alpha2=0.5):
"""Take L, LA, RGB, or RGBA images as input and blends
them according to the alpha values and/or the opacity setting for each input.
"""
blf = vtk.vtkImageBlend()
blf.AddInputData(self._data)
blf.AddInputData(pic._data)
blf.SetOpacity(0, alpha1)
blf.SetOpacity(1, alpha2)
blf.SetBlendModeToNormal()
blf.Update()
return self._update(blf.GetOutput())
def do_blend(self, imagedata, mask):
"""
blend image with the mask.
"""
blend_imagedata = vtk.vtkImageBlend()
blend_imagedata.SetBlendModeToNormal()
# blend_imagedata.SetOpacity(0, 1.0)
blend_imagedata.SetOpacity(1, 0.8)
blend_imagedata.SetInput(imagedata)
blend_imagedata.AddInput(mask)
blend_imagedata.Update()
return blend_imagedata.GetOutput()
def do_blend(self, imagedata, mask):
# blend both imagedatas, so it can be inserted into viewer
print "Blending Spacing", imagedata.GetSpacing(), mask.GetSpacing()
blend_imagedata = vtk.vtkImageBlend()
blend_imagedata.SetBlendModeToNormal()
blend_imagedata.SetOpacity(1, 0.8)
blend_imagedata.SetInputData(imagedata)
blend_imagedata.AddInputData(mask)
blend_imagedata.Update()
# return colorer.GetOutput()
return blend_imagedata.GetOutput()
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 combine_images(*images):
"""
Layer images onto each other (centered) and return the output
"""
width, height = 0, 0
for i in images:
new_w, new_h, _ = i.GetDimensions()
if new_w > width:
width = new_w
if new_h > height:
height = new_h
from vtk import vtkImageBlend
blender = vtkImageBlend()
for index, image in enumerate(images):
w, h, _ = image.GetDimensions()
if w != width or h != height:
image = pad_image(image, pad_width=width, pad_height=height)
blender.AddInputData(image)
blender.Update()
return blender.GetOutput()
def combine_images(*images):
"""
Layer images onto each other (centered) and return the output
"""
width, height = 0, 0
for i in images:
new_w, new_h, _ = i.GetDimensions()
if new_w > width:
width = new_w
if new_h > height:
height = new_h
from vtk import vtkImageBlend
blender = vtkImageBlend()
for index, image in enumerate(images):
w, h, _ = image.GetDimensions()
if w != width or h != height:
image = pad_image(image, pad_width=width, pad_height=height)
blender.AddInputData(image)
blender.Update()
return blender.GetOutput()
def main():
# Create a black image with a red circle of radius 50 centered at (60, 60)
drawing = vtk.vtkImageCanvasSource2D()
drawing.SetScalarTypeToUnsignedChar(
) # PNGWriter requires unsigned char (or unsigned short)
drawing.SetNumberOfScalarComponents(3)
drawing.SetExtent(0, 150, 0, 120, 0,
0) # xmin, xmax, ymin, ymax, zmin, zmax
drawing.SetDrawColor(255, 0, 0) # red
drawing.DrawCircle(60, 60, 50) # parameters: x, y, radius
# Create an image of text
freeType = vtk.vtkFreeTypeTools.GetInstance()
textProperty = vtk.vtkTextProperty()
textProperty.SetColor(1.0, 1.0, 0.0) # yellow
textProperty.SetFontSize(24)
# alignment property
textImage = vtk.vtkImageData()
dpi = 50
# add argument int[2]
a = [1, 2]
freeType.RenderString(textProperty, "Test String", dpi, textImage, a)
print(a)
print(textImage.GetExtent())
# Combine the images
blend = vtk.vtkImageBlend()
blend.AddInputConnection(drawing.GetOutputPort())
#blend.AddInputData(textImage)
blend.AddInputData(drawing.GetOutput())
blend.SetOpacity(0, 0.5) # background image: 50% opaque
blend.SetOpacity(1, 1.0) # text: 100% opaque
blend.Update()
writer = vtk.vtkPNGWriter()
writer.SetFileName("output.png")
writer.SetInputConnection(blend.GetOutputPort())
writer.Write()
imageGrid.SetGridOrigin(0, 0, 0)
imageGrid.SetDataExtent(0, 255, 0, 255, 0, 0)
imageGrid.SetDataScalarTypeToUnsignedChar()
table = vtk.vtkLookupTable()
table.SetTableRange(0, 1)
table.SetValueRange(1.0, 0.0)
table.SetSaturationRange(0.0, 0.0)
table.SetHueRange(0.0, 0.0)
table.SetAlphaRange(0.0, 1.0)
table.Build()
alpha = vtk.vtkImageMapToColors()
alpha.SetInputConnection(imageGrid.GetOutputPort())
alpha.SetLookupTable(table)
reader1 = vtk.vtkBMPReader()
reader1.SetFileName("" + str(VTK_DATA_ROOT) + "/Data/masonry.bmp")
blend = vtk.vtkImageBlend()
blend.AddInputConnection(reader1.GetOutputPort())
blend.AddInputConnection(alpha.GetOutputPort())
# next, create a ThinPlateSpline transform
p1 = vtk.vtkPoints()
p1.SetNumberOfPoints(8)
p1.SetPoint(0, 0, 0, 0)
p1.SetPoint(1, 0, 255, 0)
p1.SetPoint(2, 255, 0, 0)
p1.SetPoint(3, 255, 255, 0)
p1.SetPoint(4, 96, 96, 0)
p1.SetPoint(5, 96, 159, 0)
p1.SetPoint(6, 159, 159, 0)
p1.SetPoint(7, 159, 96, 0)
p2 = vtk.vtkPoints()
p2.SetNumberOfPoints(8)
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()
# Simple example that used to crash when an UpdateExtent request
# from one algorithm is overwritten by a smaller UpdateExtent
# request from another algorithm. The COMBINED_UPDATE_EXTENT
# key was added to vtkStreamingDemandDrivenPipeline to fix the
# bug that caused the crash.
# read an image that has an extent of 0 255 0 255 0 0
reader = vtk.vtkPNGReader()
reader.SetDataSpacing(0.8,0.8,1.5)
reader.SetFileName("" + str(VTK_DATA_ROOT) + "/Data/fullhead15.png")
# Uncomment this to make the crash disappear
#reader Update
# clip the image down to 0 127 0 127 0 0
clip = vtk.vtkImageClip()
clip.SetInputConnection(reader.GetOutputPort())
clip.SetOutputWholeExtent(0,127,0,127,0,0)
# darken the background
darken = vtk.vtkImageShiftScale()
darken.SetInputConnection(reader.GetOutputPort())
darken.SetScale(0.2)
# do an operation on the clipped and unclipped data
blend = vtk.vtkImageBlend()
blend.SetInputConnection(darken.GetOutputPort())
blend.AddInputConnection(clip.GetOutputPort())
viewer = vtk.vtkImageViewer()
viewer.SetInputConnection(blend.GetOutputPort())
viewer.SetColorWindow(2000)
viewer.SetColorLevel(1000)
viewer.Render()
# --- end of script --
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 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
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()'))
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()}})
def initView(self, data, widget):
image_type = data.getITKImageType()
self.image = data.getITKImage()
self.space = data.getResolution().tolist()
if len(self.space) == 3:
self.space = [float(x) / self.space[-1] for x in self.space]
self.image.SetSpacing(self.space)
self.rescale_filter = itk.RescaleIntensityImageFilter[image_type, image_type].New()
self.rescale_filter.SetOutputMinimum(0)
self.rescale_filter.SetOutputMaximum(255)
self.rescale_filter.SetInput(self.image)
self.itk_vtk_converter = itk.ImageToVTKImageFilter[image_type].New()
self.itk_vtk_converter.SetInput(self.rescale_filter.GetOutput())
self.image_resample = vtk.vtkImageResample()
self.image_resample.SetInput(self.itk_vtk_converter.GetOutput())
data = self.parent.getData()
image_type = data.getITKImageType()
self.image2 = data.getITKImage()
self.space2 = data.getResolution().tolist()
if len(self.space2) == 3:
self.space2 = [float(x) / self.space2[-1] for x in self.space2]
self.image2.SetSpacing(self.space2)
shapeList = data.getData().shape
y, x = shapeList[-2], shapeList[-1]
self.dimension = len(shapeList) == 2
self.rescale_filter2 = itk.RescaleIntensityImageFilter[image_type, image_type].New()
self.rescale_filter2.SetOutputMinimum(0)
self.rescale_filter2.SetOutputMaximum(255)
self.rescale_filter2.SetInput(self.image2)
self.itk_vtk_converter2 = itk.ImageToVTKImageFilter[image_type].New()
self.itk_vtk_converter2.SetInput(self.rescale_filter2.GetOutput())
self.image_resample2 = vtk.vtkImageResample()
self.image_resample2.SetInput(self.itk_vtk_converter2.GetOutput())
self.blend_filter = vtk.vtkImageBlend()
self.blend_filter.AddInput(self.image_resample.GetOutput())
self.blend_filter.AddInput(self.image_resample2.GetOutput())
self.opacity = 0.5
self.blend_filter.SetOpacity(0, 0.5)
self.blend_filter.SetOpacity(1, 0.5)
self.renderer = vtk.vtkRenderer()
self.render_window = widget.GetRenderWindow()
self.render_window.AddRenderer(self.renderer)
self.reslice_mapper = vtk.vtkImageResliceMapper()
self.reslice_mapper.SetInput(self.blend_filter.GetOutput())
self.reslice_mapper.SliceFacesCameraOn()
self.reslice_mapper.SliceAtFocalPointOn()
self.reslice_mapper.JumpToNearestSliceOn()
self.reslice_mapper.BorderOff()
self.reslice_mapper.BackgroundOn()
array = data.getData()
self.minI = 0
self.maxI = 255
image_property = vtk.vtkImageProperty()
image_property.SetColorWindow(self.maxI - self.minI)
image_property.SetColorLevel((self.maxI + self.minI) / 2.0)
image_property.SetAmbient(0.0)
image_property.SetDiffuse(1.0)
image_property.SetOpacity(1.0)
image_property.SetInterpolationTypeToLinear()
self.image_slice = vtk.vtkImageSlice()
self.image_slice.SetMapper(self.reslice_mapper)
self.image_slice.SetProperty(image_property)
self.renderer.AddViewProp(self.image_slice)
self.window_interactor = vtk.vtkRenderWindowInteractor()
self.interactor_style = vtk.vtkInteractorStyleImage()
self.interactor_style.SetInteractionModeToImage3D()
self.window_interactor.SetInteractorStyle(self.interactor_style)
self.render_window.SetInteractor(self.window_interactor)
point_picker = vtk.vtkPointPicker()
self.window_interactor.SetPicker(point_picker)
self.render_window.GlobalWarningDisplayOff()
self.render_window.Render()
self.camera = self.renderer.GetActiveCamera()
self.camera.ParallelProjectionOn()
w, h = self.window_interactor.GetSize()
if h * x * self.space[0] < w * y * self.space[1]:
scale = y / 2.0 * self.space[1]
else:
scale = h * x * self.space[0] / 2.0 / w
self.camera.SetParallelScale(scale)
point = self.camera.GetFocalPoint()
dis = self.camera.GetDistance()
self.camera.SetViewUp(0, -1, 0)
self.camera.SetPosition(point[0], point[1], point[2] - dis)
self.renderer.ResetCameraClippingRange()
# View of image
self.view = 2
self.interactor_style.AddObserver("MouseMoveEvent", self.MouseMoveCallback)
self.interactor_style.AddObserver("LeftButtonReleaseEvent", self.LeftButtonReleaseCallback)
self.interactor_style.AddObserver("LeftButtonPressEvent", self.LeftButtonPressCallback)
self.interactor_style.AddObserver("MiddleButtonPressEvent", self.MiddleButtonPressCallback)
self.interactor_style.AddObserver("RightButtonPressEvent", self.RightButtonPressCallback)
self.interactor_style.AddObserver("RightButtonReleaseEvent", self.RightButtonReleaseCallback)
self.interactor_style.AddObserver("KeyPressEvent", self.KeyPressCallback)
self.interactor_style.AddObserver("CharEvent", self.CharCallback)
self.updateAfter()
self.render_window.Render()
def loadSingleFile(self):
loader = self.fileLoader
loader.loadFile()
if loader.accepted:
loader.setDir(os.path.dirname(str(loader.selectedFile)))
self.disableSlider()
self.dicomReader = vtkgdcm.vtkGDCMImageReader()
self.dicomReader.SetFileName(str(loader.selectedFile))
print(dir(self.dicomReader))
print(self.dicomReader.GetScale())
self.dicomReader.Update()
imageData = self.dicomReader.GetOutput()
size = imageData.GetDimensions()
width = size[0]
height = size[1]
self.vtkWidget.setMaximumSize(QtCore.QSize(width, height))
self.vtkWidget.setMinimumSize(QtCore.QSize(width, height))
RefDs = dicom.read_file(str(loader.selectedFile))
ConstPixelDims = (int(RefDs.Rows), int(RefDs.Columns), 1)
pointData = imageData.GetPointData()
arrayData = pointData.GetArray(0)
arrayDicom = numpy_support.vtk_to_numpy(arrayData)
arrayDicom = arrayDicom.reshape(ConstPixelDims, order='F')
shape = arrayDicom.shape
wtf = arrayDicom.reshape(shape[0], shape[1])
wtf = numpy.fliplr(wtf).transpose()
max = numpy.max(wtf)
min = numpy.min(wtf)
print(numpy.max(wtf))
print(numpy.min(wtf))
grad = numpy.gradient(wtf)
print(wtf)
computed = numpy.sqrt(numpy.square(grad[0]) + numpy.square(grad[1]))
#self.proc.start()
ax = self.figure.add_subplot(111)
ax.imshow(wtf, interpolation="nearest", cmap=plt.get_cmap('gray'), vmin=0, vmax=max)
self.canvas.draw()
#points = vtk.vtkPoints()
#points.SetNumberOfPoints(2)
#points.Allocate(2)
#points.InsertPoint(0, 100, 100, 0.001)
#points.InsertPoint(0, 200, 200, 0.001)
#cells = vtk.vtkCellArray()
#cells.Initialize()
#line = vtk.vtkLine()
#line.GetPointIds().SetId(0,0)
#line.GetPointIds().SetId(1,1)
#cells.InsertNextCell(line)
#poly = vtk.vtkPolyData()
#poly.Initialize()
#poly.SetPoints(points)
#poly.SetLines(cells)
#poly.Modified()
#mapper = vtk.vtkPolyDataMapper2D()
#print(dir(mapper))
#mapper.SetInput(poly)
#mapper.ScalarVisibilityOn()
#mapper.SetScalarModeToUsePointData()
#mapper.Update()
#self.drawLine([(200,200), (300,300)])
#actor = vtk.vtkActor2D()
#actor.SetMapper(mapper)
blend = vtk.vtkImageBlend()
blend.AddInputConnection(self.dicomReader.GetOutputPort())
#blend.AddInputConnection(actor.GetOutputPort())
self.viewer.SetInputConnection(blend.GetOutputPort())
#print(dir(self.viewer.GetRenderer()))
#self.viewer.GetRenderer().AddActor2D(actor)
#self.viewer.SetInputConnection(self.dicomReader.GetOutputPort())
self.viewer.SetZSlice(0)
self.getMedicalData()
self.iren.ReInitialize()
self.iren.Render()
self.iren.Start()
#actor = vtk.vtkImageActor()
#self.viewer.GetRenderer().AddActor(actor)
self.viewer.GetRenderer().Render()
def __init__(self):
vtkViewImage.__init__(self)
self.FirstRender = 1
self.FirstImage = 1
self.ShowCurrentPoint = True
self.ShowDirections = True
self.ShowSliceNumber = True
self.Orientation = vtkViewImage.AXIAL_ID
self.InteractionStyle = self.SELECT_INTERACTION
self.LeftButtonInteractionStyle = self.SELECT_INTERACTION
self.MiddleButtonInteractionStyle = self.SELECT_INTERACTION
self.RightButtonInteractionStyle = self.SELECT_INTERACTION
self.WheelInteractionStyle = self.SELECT_INTERACTION
self.Conventions = self.RADIOLOGIC
self.InitialParallelScale = 1.0
self.OverlappingImage = None
self.ImageReslice = vtk.vtkImageReslice()
self.ImageActor = vtk.vtkImageActor()
self.WindowLevelForCorner = vtk.vtkImageMapToWindowLevelColors()
self.WindowLevel = vtk.vtkImageMapToColors()
#self.MaskFilter = vtk.vtkImageBlendWithMask()
self.Blender = vtk.vtkImageBlend()
self.HorizontalLineSource = vtk.vtkLineSource()
self.VerticalLineSource = vtk.vtkLineSource()
self.HorizontalLineActor = vtk.vtkActor()
self.VerticalLineActor = vtk.vtkActor()
self.DataSetCutPlane = vtk.vtkPlane()
self.DataSetCutBox = vtk.vtkBox()
self.DataSetCutPlane.SetOrigin(0,0,0)
self.DataSetCutPlane.SetNormal(0,0,1)
self.DataSetCutBox.SetBounds(0, 0, 0, 0, 0, 0)
self.BoxThickness = 2
self.LinkCameraFocalAndPosition = 0
# set the filters properties
self.Blender.SetBlendModeToNormal()
self.Blender.SetOpacity(0, 0.25)
self.Blender.SetOpacity(1, 0.75)
# set up the vtk pipeline
self.ImageReslice.SetOutputDimensionality(2)
self.ImageReslice.InterpolateOff()
self.ImageReslice.SetInputConnection(self.WindowLevel.GetOutputPort())
self.AuxInput = self.WindowLevel.GetOutput()
self.ResliceInput = self.WindowLevel.GetOutput()
# Interactor Style
self.InitInteractorStyle(self.SELECT_INTERACTION)
# Initialize cursor lines
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(self.HorizontalLineSource.GetOutputPort())
self.HorizontalLineActor.SetMapper(mapper)
self.HorizontalLineActor.GetProperty().SetColor(1.0, 0.0, 0.0)
#del mapper
self.HorizontalLineActor.SetVisibility(0)
mapper2 = vtk.vtkPolyDataMapper()
mapper2.SetInputConnection(self.VerticalLineSource.GetOutputPort())
self.VerticalLineActor.SetMapper(mapper2)
self.VerticalLineActor.GetProperty().SetColor(1.0, 0.0, 0.0)
#del mapper2
self.VerticalLineActor.SetVisibility(0)
self.CornerAnnotation.SetWindowLevel(self.WindowLevelForCorner)
self.SetOrientation(vtkViewImage.AXIAL_ID)
if self.GetViewImage2DDisplayConventions() == 0:
self.SetConventionsToRadiological()
else:
self.SetConventionsToNeurological()
backgroundAlpha.AddInputConnection(bmask.GetOutputPort())
foregrounds = ["luminance", "luminanceAlpha", "color", "colorAlpha"]
backgrounds = ["backgroundAlpha", "backgroundColor", "backgroundLuminance"]
deltaX = 1.0 / 4.0
deltaY = 1.0 / 3.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()'))
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()}})
