def __set_up_drawing_actor(self):
lut = vtk.vtkLookupTable()
lut.SetRange(0, 1000)
lut.SetValueRange(0.0, 1.0) # from black to white
lut.SetSaturationRange(0.0, 0.0) # no color saturation
lut.SetRampToLinear()
lut.Build()
# Map the image through the lookup table
color = vtk.vtkImageMapToColors()
color.SetLookupTable(lut)
color.SetInputConnection(self.filter.GetOutputPort())
# Display the image
self.actor = vtk.vtkImageActor()
self.actor.GetMapper().SetInputConnection(color.GetOutputPort())
# mask
mask_lut = vtk.vtkLookupTable()
mask_lut.SetNumberOfTableValues(2)
mask_lut.SetTableValue(0, 0.0, 0.0, 0.0, 1.0)
mask_lut.SetTableValue(1, 1.0, 0.0, 0.0, 1.0)
color = vtk.vtkImageMapToColors()
color.SetLookupTable(mask_lut)
color.SetInputConnection(self.mask_filter.GetOutputPort())
self.mask_actor = vtk.vtkImageActor()
self.mask_actor.GetMapper().SetInputConnection(color.GetOutputPort())
self.mask_actor.SetOpacity(0.7)
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):
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 vtkInitialData(self, read_path, volum = 'GAUSSIAN'):
""" Creation des donnees initiales """
self.path = read_path
#-----------------------------------------
# Creation de la donnee volumique
#-----------------------------------------
self.vtkReadVolumAll(os.path.join(self.path,'image.raw'))
self.valSagittal = (self.lig-1)/2
self.valCoronal = (self.col-1)/2
self.valTransversal = (self.nb_coupe-1)/2
self.min_pixel_value = self.NumpyData.min()
self.max_pixel_value = self.NumpyData.max()
if self.valSeuil >= self.max_pixel_value :
self.valSeuil = (self.max_pixel_value - self.min_pixel_value)/2
self.VOI_pt2 = [self.col,self.lig,self.nb_coupe]
#-----------------------------------------
# Start by creatin a black/white lookup table.
#-----------------------------------------
self.bwLut = vtk.vtkLookupTable()
self.bwLut.SetTableRange(self.min_pixel_value, self.max_pixel_value)
self.bwLut.SetSaturationRange(0, 0)
self.bwLut.SetHueRange(0, 0)
self.bwLut.SetValueRange(0, 1)
self.bwLut.Build()
#-----------------------------------------
# Creation de la bounding box
#-----------------------------------------
self.vtkBoundingBox()
#-----------------------------------------
# Creation de la VOI
#-----------------------------------------
self.vtkVOIdata(volum = volum)
self.vtkBoundingVOI()
#-----------------------------------------
# Creation des infos geometriques
#-----------------------------------------
self.vtkCreateGeometricInformations()
#-----------------------------------------
# Creation de la couleur des coupe
#-----------------------------------------
self.sliceColors0 = vtk.vtkImageMapToColors()
self.sliceColors0.SetInputConnection(self.vtkVolumAll.GetOutputPort())
self.sliceColors0.SetLookupTable(self.bwLut)
self.sliceColors1 = vtk.vtkImageMapToColors()
self.sliceColors1.SetInputConnection(self.vtkVolumAll.GetOutputPort())
self.sliceColors1.SetLookupTable(self.bwLut)
self.sliceColors2 = vtk.vtkImageMapToColors()
self.sliceColors2.SetInputConnection(self.vtkVolumAll.GetOutputPort())
self.sliceColors2.SetLookupTable(self.bwLut)
#-----------------------------------------
# Creation de la camera
#-----------------------------------------
self.vtkCreateCamera()
#-----------------------------------------
# Fin de creation des elements et affichage
#-----------------------------------------
self.vtkRedraw()
def createItemToolbar(self):
"""
Method to create a toolbar for the window that allows use to select processed channel
"""
# Pass flag force which indicates that we do want an item toolbar
# although we only have one input channel
n = GUI.FilterBasedTaskPanel.FilterBasedTaskPanel.createItemToolbar(self, force=1)
for i, tid in enumerate(self.toolIds):
self.dataUnit.setOutputChannel(i, 0)
self.toolMgr.toggleTool(tid, 0)
ctf = vtk.vtkColorTransferFunction()
ctf.AddRGBPoint(0, 0, 0, 0)
ctf.AddRGBPoint(255, 1, 1, 1)
imagedata = self.itemMips[0]
ctf = vtk.vtkColorTransferFunction()
ctf.AddRGBPoint(0, 0, 0, 0)
ctf.AddRGBPoint(255, 1, 1, 1)
maptocolor = vtk.vtkImageMapToColors()
maptocolor.SetInput(imagedata)
maptocolor.SetLookupTable(ctf)
maptocolor.SetOutputFormatToRGB()
maptocolor.Update()
imagedata = maptocolor.GetOutput()
bmp = lib.ImageOperations.vtkImageDataToWxImage(imagedata).ConvertToBitmap()
bmp = self.getChannelItemBitmap(bmp, (255, 255, 255))
toolid = wx.NewId()
name = "Manipulation"
self.toolMgr.addChannelItem(name, bmp, toolid, lambda e, x=n, s=self: s.setPreviewedData(e, x))
self.toolIds.append(toolid)
self.dataUnit.setOutputChannel(len(self.toolIds), 1)
self.toolMgr.toggleTool(toolid, 1)
def getMIP(imageData, color):
"""
A function that will take a volume and do a simple
maximum intensity projection that will be converted to a
wxBitmap
"""
maxval = imageData.GetScalarRange()[1]
imageData.SetUpdateExtent(imageData.GetWholeExtent())
if maxval > 255:
shiftscale = vtk.vtkImageShiftScale()
shiftscale.SetInputConnection(imageData.GetProducerPort())
shiftscale.SetScale(255.0 / maxval)
shiftscale.SetOutputScalarTypeToUnsignedChar()
imageData = shiftscale.GetOutput()
mip = vtkbxd.vtkImageSimpleMIP()
mip.SetInputConnection(imageData.GetProducerPort())
if color == None:
output = optimize.execute_limited(mip)
return output
if mip.GetOutput().GetNumberOfScalarComponents() == 1:
ctf = getColorTransferFunction(color)
maptocolor = vtk.vtkImageMapToColors()
maptocolor.SetInputConnection(mip.GetOutputPort())
maptocolor.SetLookupTable(ctf)
maptocolor.SetOutputFormatToRGB()
imagedata = optimize.execute_limited(maptocolor)
else:
imagedata = output = optimize.execute_limited(mip)
return imagedata
def __init__(self,
world_to_slice,
image,
display_coordinates="physical",
colormap=None,
opacity=1.0):
############################
# Property-related members #
############################
self._actor = vtkImageActor()
###################
# Private members #
###################
self._image_map_to_colors = vtkImageMapToColors()
######################
# Initialize members #
######################
super(ImageLayer,
self).__init__(world_to_slice, image, display_coordinates,
colormap, opacity)
self._image_map_to_colors.SetInputConnection(
self._change_information.GetOutputPort())
self._actor.SetInput(self._image_map_to_colors.GetOutput())
self._actor.InterpolateOff()
def do_colour_mask(self, imagedata):
scalar_range = int(imagedata.GetScalarRange()[1])
r, g, b = 0, 1, 0
# map scalar values into colors
lut_mask = vtk.vtkLookupTable()
lut_mask.SetNumberOfColors(255)
lut_mask.SetHueRange(const.THRESHOLD_HUE_RANGE)
lut_mask.SetSaturationRange(1, 1)
lut_mask.SetValueRange(0, 1)
lut_mask.SetNumberOfTableValues(256)
lut_mask.SetTableValue(0, 0, 0, 0, 0.0)
lut_mask.SetTableValue(1, 0, 0, 0, 0.0)
lut_mask.SetTableValue(2, 0, 0, 0, 0.0)
lut_mask.SetTableValue(255, r, g, b, 1.0)
lut_mask.SetRampToLinear()
lut_mask.Build()
# self.lut_mask = lut_mask
# map the input image through a lookup table
img_colours_mask = vtk.vtkImageMapToColors()
img_colours_mask.SetLookupTable(lut_mask)
img_colours_mask.SetOutputFormatToRGBA()
img_colours_mask.SetInputData(imagedata)
img_colours_mask.Update()
# self.img_colours_mask = img_colours_mask
return img_colours_mask.GetOutput()
def do_colour_mask(self, imagedata):
scalar_range = int(imagedata.GetScalarRange()[1])
r, g, b = self.current_mask.colour
# map scalar values into colors
lut_mask = vtk.vtkLookupTable()
lut_mask.SetNumberOfColors(256)
lut_mask.SetHueRange(const.THRESHOLD_HUE_RANGE)
lut_mask.SetSaturationRange(1, 1)
lut_mask.SetValueRange(0, 255)
lut_mask.SetRange(0, 255)
lut_mask.SetNumberOfTableValues(256)
lut_mask.SetTableValue(0, 0, 0, 0, 0.0)
lut_mask.SetTableValue(1, 0, 0, 0, 0.0)
lut_mask.SetTableValue(254, r, g, b, 1.0)
lut_mask.SetTableValue(255, r, g, b, 1.0)
lut_mask.SetRampToLinear()
lut_mask.Build()
# self.lut_mask = lut_mask
# map the input image through a lookup table
img_colours_mask = vtk.vtkImageMapToColors()
img_colours_mask.SetLookupTable(lut_mask)
img_colours_mask.SetOutputFormatToRGBA()
img_colours_mask.SetInput(imagedata)
img_colours_mask.Update()
# self.img_colours_mask = img_colours_mask
return img_colours_mask.GetOutput()
def _set_colour(self, imagedata, colour):
scalar_range = int(imagedata.GetScalarRange()[1])
r, g, b = colour
# map scalar values into colors
lut_mask = vtk.vtkLookupTable()
lut_mask.SetNumberOfColors(256)
lut_mask.SetHueRange(const.THRESHOLD_HUE_RANGE)
lut_mask.SetSaturationRange(1, 1)
lut_mask.SetValueRange(0, 255)
lut_mask.SetRange(0, 255)
lut_mask.SetNumberOfTableValues(256)
lut_mask.SetTableValue(0, 0, 0, 0, 0.0)
lut_mask.SetTableValue(1, 1-r, 1-g, 1-b, 0.50)
lut_mask.SetRampToLinear()
lut_mask.Build()
# map the input image through a lookup table
img_colours_mask = vtk.vtkImageMapToColors()
img_colours_mask.SetLookupTable(lut_mask)
img_colours_mask.SetOutputFormatToRGBA()
img_colours_mask.SetInput(imagedata)
img_colours_mask.Update()
return img_colours_mask.GetOutput()
def __init__(self, source, orientation, opacity=1.0):
self.reslice = vtk.vtkImageReslice()
self.reslice.SetInputData(source)
self.reslice.SetOutputDimensionality(2)
self.reslice.SetResliceAxes(orientation)
self.reslice.SetInterpolationModeToNearestNeighbor()
# Set lookup table
color_transfer = vtk.vtkDiscretizableColorTransferFunction()
alpha_transfer = vtk.vtkPiecewiseFunction()
color_transfer.AddRGBPoint(0, 0., 0., 0.) # Background
alpha_transfer.AddPoint(0, 0) # Background
for i, organ in enumerate(Settings.labels):
color_transfer.AddRGBPoint(Settings.labels[organ]['value'],
*Settings.labels[organ]['rgb'])
if organ in Settings.organs:
alpha_transfer.AddPoint(Settings.labels[organ]['value'],
opacity)
else:
alpha_transfer.AddPoint(Settings.labels[organ]['value'], 0.)
color_transfer.SetScalarOpacityFunction(alpha_transfer)
color_transfer.EnableOpacityMappingOn()
# Map the image through the lookup table
self.color = vtk.vtkImageMapToColors()
self.color.SetLookupTable(color_transfer)
self.color.SetInputConnection(self.reslice.GetOutputPort())
# Display the image
self.actor = vtk.vtkImageActor()
self.actor.GetMapper().SetInputConnection(self.color.GetOutputPort())
def _set_colour(self, imagedata, colour):
scalar_range = int(imagedata.GetScalarRange()[1])
r, g, b = colour
# map scalar values into colors
lut_mask = vtk.vtkLookupTable()
lut_mask.SetNumberOfColors(256)
lut_mask.SetHueRange(const.THRESHOLD_HUE_RANGE)
lut_mask.SetSaturationRange(1, 1)
lut_mask.SetValueRange(0, 255)
lut_mask.SetRange(0, 255)
lut_mask.SetNumberOfTableValues(256)
lut_mask.SetTableValue(0, 0, 0, 0, 0.0)
lut_mask.SetTableValue(1, 1 - r, 1 - g, 1 - b, 0.50)
lut_mask.SetRampToLinear()
lut_mask.Build()
# map the input image through a lookup table
img_colours_mask = vtk.vtkImageMapToColors()
img_colours_mask.SetLookupTable(lut_mask)
img_colours_mask.SetOutputFormatToRGBA()
img_colours_mask.SetInput(imagedata)
img_colours_mask.Update()
return img_colours_mask.GetOutput()
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkImageMapToColors(), 'Processing.',
('vtkImageData',), ('vtkImageData',),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
def __init__(self, data_dir, PW, reader):
# Create a greyscale lookup table
table2 = vtk.vtkLookupTable()
table2.SetRange(2440, 2800) # image intensity range
table2.SetValueRange(0.0, 1) # from black to white
table2.SetAlphaRange(1.0, 1.0)
table2.SetHueRange(0.0, 0.1)
table2.SetSaturationRange(0.0, 0.2) # no color saturation
table2.SetRampToLinear()
table2.Build()
grx = PW.GetResliceAxes()
reslice = vtk.vtkImageReslice()
reslice.SetInputConnection(reader.GetOutputPort())
reslice.SetOutputDimensionality(2)
reslice.SetResliceAxes(grx)
reslice.SetSlabModeToMax()
reslice.SetSlabNumberOfSlices(30)
reslice.SetInterpolationModeToLinear()
reslice.Update()
# Map the image through the lookup table
color = vtk.vtkImageMapToColors()
color.SetLookupTable(table2)
color.SetInputConnection(reslice.GetOutputPort())
actor = vtk.vtkImageActor()
actor.GetMapper().SetInputConnection(color.GetOutputPort())
self.actor = actor
def __init__(self, ren):
self.volume = self.LoadVolume()
self.ren = ren
# next initialize the pipeline
self.slicer = vtk.vtkImageReslice()
self.slicer.SetInput( self.volume )
self.slicer.SetOutputDimensionality(2)
# the next filter provides a mechanism for slice selection
self.selector = SliceSelector(self.volume)
self.slicer.SetResliceAxes( self.selector.GetDirectionCosines() )
self.slicer.SetResliceAxesOrigin( self.selector.GetAxesOrigin() )
# setup link for adjusting the contrast of the image
r = self.volume.GetScalarRange()
self.lutBuilder = LUTBuilder(r[0],r[1],1)
lut = self.lutBuilder.Build()
self.colors = vtk.vtkImageMapToColors()
self.colors.SetInputConnection( self.slicer.GetOutputPort() )
self.colors.SetLookupTable( lut )
self.actor = vtk.vtkImageActor()
self.actor.SetInput( self.colors.GetOutput() )
def setup_brain(renderer, file):
brain = NiiObject()
brain.file = file
brain.reader = read_volume(brain.file)
brain.labels.append(
NiiLabel(BRAIN_COLORS[0], BRAIN_OPACITY, BRAIN_SMOOTHNESS))
brain.labels[0].extractor = create_brain_extractor(brain)
brain.extent = brain.reader.GetDataExtent()
scalar_range = brain.reader.GetOutput().GetScalarRange()
bw_lut = vtk.vtkLookupTable()
bw_lut.SetTableRange(scalar_range)
bw_lut.SetSaturationRange(0, 0)
bw_lut.SetHueRange(0, 0)
bw_lut.SetValueRange(0, 2)
bw_lut.Build()
view_colors = vtk.vtkImageMapToColors()
view_colors.SetInputConnection(brain.reader.GetOutputPort())
view_colors.SetLookupTable(bw_lut)
view_colors.Update()
brain.image_mapper = view_colors
brain.scalar_range = scalar_range
add_surface_rendering(brain, 0,
sum(scalar_range) /
2) # render index, default extractor value
renderer.AddActor(brain.labels[0].actor)
return brain
def getMIP(imageData, color):
"""
A function that will take a volume and do a simple
maximum intensity projection that will be converted to a
wxBitmap
"""
maxval = imageData.GetScalarRange()[1]
imageData.SetUpdateExtent(imageData.GetWholeExtent())
if maxval > 255:
shiftscale = vtk.vtkImageShiftScale()
shiftscale.SetInputConnection(imageData.GetProducerPort())
shiftscale.SetScale(255.0 / maxval)
shiftscale.SetOutputScalarTypeToUnsignedChar()
imageData = shiftscale.GetOutput()
mip = vtkbxd.vtkImageSimpleMIP()
mip.SetInputConnection(imageData.GetProducerPort())
if color == None:
output = optimize.execute_limited(mip)
return output
if mip.GetOutput().GetNumberOfScalarComponents() == 1:
ctf = getColorTransferFunction(color)
maptocolor = vtk.vtkImageMapToColors()
maptocolor.SetInputConnection(mip.GetOutputPort())
maptocolor.SetLookupTable(ctf)
maptocolor.SetOutputFormatToRGB()
imagedata = optimize.execute_limited(maptocolor)
else:
imagedata = output = optimize.execute_limited(mip)
return imagedata
def writeAllImageSlices(imgfn,pathfn,ext,output_dir):
reader = vtk.vtkMetaImageReader()
reader.SetFileName(imgfn)
reader.Update()
img = reader.GetOutput()
parsed_path = parsePathFile(pathfn)
slices = getAllImageSlices(img,parsed_path,ext)
writer = vtk.vtkJPEGWriter()
table = vtk.vtkLookupTable()
scalar_range = img.GetScalarRange()
table.SetRange(scalar_range[0], scalar_range[1]) # image intensity range
table.SetValueRange(0.0, 1.0) # from black to white
table.SetSaturationRange(0.0, 0.0) # no color saturation
table.SetRampToLinear()
table.Build()
# Map the image through the lookup table
color = vtk.vtkImageMapToColors()
color.SetLookupTable(table)
mkdir(output_dir)
for i in range(len(slices)):
color.SetInputData(slices[i])
writer.SetInputConnection(color.GetOutputPort())
writer.SetFileName(output_dir+'{}.jpg'.format(i))
writer.Update()
writer.Write()
def setup_brain(render_window, renderer, name):
file = name + ".nii.gz"
# print(file)
brain = NiiObject()
brain.file = file
brain.reader = read_volume(brain.file)
brain.labels.append(
NiiLabel(BRAIN_COLORS[0], BRAIN_OPACITY, BRAIN_SMOOTHNESS))
brain.labels[0].extractor = create_brain_extractor(brain)
brain.extent = brain.reader.GetDataExtent()
scalar_range = brain.reader.GetOutput().GetScalarRange()
bw_lut = vtk.vtkLookupTable()
bw_lut.SetTableRange(scalar_range)
bw_lut.SetSaturationRange(0, 0)
bw_lut.SetHueRange(0, 0)
bw_lut.SetValueRange(0, 2)
bw_lut.Build()
# print('step1')
view_colors = vtk.vtkImageMapToColors()
view_colors.SetInputConnection(brain.reader.GetOutputPort())
view_colors.SetLookupTable(bw_lut)
view_colors.Update()
brain.image_mapper = view_colors
brain.scalar_range = scalar_range
# print('step2')
add_surface_rendering(brain, 0,
sum(scalar_range) /
2) # render index, default extractor value
renderer.AddActor(brain.labels[0].actor)
objWriter = vtk.vtkOBJExporter()
objWriter.SetFilePrefix(name)
objWriter.SetInput(render_window)
objWriter.Write()
def __init__(self, im_data, orie='Sagittal'):
# orie
self.orie = orie
source = im_data.im_src
self.translation = [0, 0]
# (xMin, xMax, yMin, yMax, zMin, zMax)
self.sizes = source.GetExecutive().GetWholeExtent(
source.GetOutputInformation(0))
self.spacing = source.GetOutput().GetSpacing()
self.origin = source.GetOutput().GetOrigin()
# include (xSpacing, ySpacing, zSpacing) to get the correct slices
self.center = [
self.origin[0] + self.spacing[0] * 0.5 *
(self.sizes[0] + self.sizes[1]), self.origin[1] +
self.spacing[1] * 0.5 * (self.sizes[2] + self.sizes[3]),
self.origin[2] + self.spacing[2] * 0.5 *
(self.sizes[4] + self.sizes[5])
]
self.slices = [
self.center[0] - self.spacing[0] * 0.5 *
(self.sizes[0] + self.sizes[1]), self.center[0] +
self.spacing[0] * 0.5 * (self.sizes[0] + self.sizes[1]),
self.center[1] - self.spacing[1] * 0.5 *
(self.sizes[2] + self.sizes[3]), self.center[1] +
self.spacing[1] * 0.5 * (self.sizes[2] + self.sizes[3]),
self.center[2] - self.spacing[2] * 0.5 *
(self.sizes[4] + self.sizes[5]), self.center[2] +
self.spacing[2] * 0.5 * (self.sizes[4] + self.sizes[5])
]
self.reslice = vtk.vtkImageReslice()
self.reslice.SetInputConnection(source.GetOutputPort())
self.reslice.SetOutputDimensionality(2)
self.reslice.SetResliceAxes(self.get_orie_mat())
self.reslice.SetInterpolationModeToLinear()
# Create a greyscale lookup table
self.table = vtk.vtkLookupTable()
self.table.SetRange(0, 1500) # image intensity range
self.table.SetValueRange(0.0, 0.7) # from black to white
self.table.SetSaturationRange(0.0, 0.0) # no color saturation
self.table.SetRampToLinear()
self.table.Build()
# Map the image through the lookup table
self.color = vtk.vtkImageMapToColors()
self.color.SetLookupTable(self.table)
self.color.SetInputConnection(self.reslice.GetOutputPort())
# Display the image
self.actor = vtk.vtkImageActor()
self.actor.GetMapper().SetInputConnection(self.color.GetOutputPort())
def _on_new_image_attrib(self, attrib):
((w, h, num_channels), dtype) = attrib
if self._image_handler.is_depth_image():
assert num_channels == 1, num_channels
assert dtype in (np.uint16, np.float32), dtype
# TODO(eric.cousineau): Delegate to outside of `ImageWidget`?
# This is depth-image specific.
# For now, just set arbitrary values.
depth_range = self._get_depth_range()
lower_color = (1, 1, 1) # White
upper_color = (0, 0, 0) # Black
nan_color = (0.5, 0.5, 1) # Light blue - No return.
inf_color = (0.5, 0, 0.) # Dark red - Too far / too close.
# Use `vtkColorTransferFunction` as it provides a more intuitive
# interpolating interface for me (Eric) than `vtkLookupTable`,
# since it permits direct specification of RGB values.
coloring = vtk.vtkColorTransferFunction()
coloring.AddRGBPoint(depth_range[0], *lower_color)
coloring.AddRGBPoint(depth_range[1], *upper_color)
coloring.SetNanColor(*nan_color)
# @note `coloring.SetAboveRangeColor` doesn't seem to work?
coloring.AddRGBPoint(depth_range[1] + 10000, *inf_color)
coloring.SetClamping(True)
coloring.SetScaleToLinear()
self._depth_mapper = vtk.vtkImageMapToColors()
self._depth_mapper.SetLookupTable(coloring)
vtk_SetInputData(self._depth_mapper, self._image)
vtk_SetInputData(self._image_actor, self._depth_mapper.GetOutput())
self._image_actor.GetMapper().SetInputConnection(
self._depth_mapper.GetOutputPort())
else:
# Direct connection.
self._depth_mapper = None
vtk_SetInputData(self._image_actor, self._image)
# Must render first.
self._view.render()
# Fit image to view.
# TODO(eric.cousineau): No idea why this is needed; it worked for
# VTK 5, but no longer for VTK 6+?
camera = self._view.camera()
camera.ParallelProjectionOn()
camera.SetFocalPoint(0, 0, 0)
camera.SetPosition(0, 0, -1)
camera.SetViewUp(0, -1, 0)
self._view.resetCamera()
image_height, image_width = get_vtk_image_shape(self._image)[:2]
view_width, view_height = self._view.renderWindow().GetSize()
aspect_ratio = float(view_width) / view_height
parallel_scale = max(image_width / aspect_ratio, image_height) / 2.0
camera.SetParallelScale(parallel_scale)
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(self,
module_manager,
vtk.vtkImageMapToColors(),
'Processing.', ('vtkImageData', ),
('vtkImageData', ),
replaceDoc=True,
inputFunctions=None,
outputFunctions=None)
def _on_new_image_attrib(self, attrib):
((w, h, num_channels), dtype) = attrib
if self._image_handler.is_depth_image():
assert num_channels == 1, num_channels
assert dtype in (np.uint16, np.float32), dtype
# TODO(eric.cousineau): Delegate to outside of `ImageWidget`?
# This is depth-image specific.
# For now, just set arbitrary values.
depth_range = self._get_depth_range()
lower_color = (1, 1, 1) # White
upper_color = (0, 0, 0) # Black
nan_color = (0.5, 0.5, 1) # Light blue - No return.
inf_color = (0.5, 0, 0.) # Dark red - Too far / too close.
# Use `vtkColorTransferFunction` as it provides a more intuitive
# interpolating interface for me (Eric) than `vtkLookupTable`,
# since it permits direct specification of RGB values.
coloring = vtk.vtkColorTransferFunction()
coloring.AddRGBPoint(depth_range[0], *lower_color)
coloring.AddRGBPoint(depth_range[1], *upper_color)
coloring.SetNanColor(*nan_color)
# @note `coloring.SetAboveRangeColor` doesn't seem to work?
coloring.AddRGBPoint(depth_range[1] + 10000, *inf_color)
coloring.SetClamping(True)
coloring.SetScaleToLinear()
self._depth_mapper = vtk.vtkImageMapToColors()
self._depth_mapper.SetLookupTable(coloring)
vtk_SetInputData(self._depth_mapper, self._image)
vtk_SetInputData(self._image_actor, self._depth_mapper.GetOutput())
self._image_actor.GetMapper().SetInputConnection(
self._depth_mapper.GetOutputPort())
else:
# Direct connection.
self._depth_mapper = None
vtk_SetInputData(self._image_actor, self._image)
# Must render first.
self._view.render()
# Fit image to view.
# TODO(eric.cousineau): No idea why this is needed; it worked for
# VTK 5, but no longer for VTK 6+?
camera = self._view.camera()
camera.ParallelProjectionOn()
camera.SetFocalPoint(0, 0, 0)
camera.SetPosition(0, 0, -1)
camera.SetViewUp(0, -1, 0)
self._view.resetCamera()
image_height, image_width = get_vtk_image_shape(self._image)[:2]
view_width, view_height = self._view.renderWindow().GetSize()
aspect_ratio = float(view_width) / view_height
parallel_scale = max(image_width / aspect_ratio, image_height) / 2.0
camera.SetParallelScale(parallel_scale)
def vtkImageDataToPreviewBitmap(dataunit,
timepoint,
color,
width=0,
height=0,
getvtkImage=0):
"""
A function that will take a volume and do a simple
Maximum Intensity Projection that will be converted to a
wxBitmap
"""
imagedata = dataunit.getMIP(timepoint, None, small=1, noColor=1)
vtkImg = imagedata
if not color:
color = dataunit.getColorTransferFunction()
ctf = getColorTransferFunction(color)
minval, maxval = ctf.GetRange()
imax = imagedata.GetScalarRange()[1]
if maxval > imax:
step = float((maxval - minval) / imax)
ctf2 = vtk.vtkColorTransferFunction()
Logging.info("Creating CTF in range %d, %d with steps %d" %
(int(minval), int(maxval), int(step)))
for i in range(int(minval), int(maxval), int(step)):
red, green, blue = ctf.GetColor(i)
ctf2.AddRGBPoint(i / step, red, green, blue)
ctf = ctf2
maptocolor = vtk.vtkImageMapToColors()
maptocolor.SetInputConnection(imagedata.GetProducerPort())
maptocolor.SetLookupTable(ctf)
maptocolor.SetOutputFormatToRGB()
maptocolor.Update()
imagedata = maptocolor.GetOutput()
image = vtkImageDataToWxImage(imagedata)
xSize, ySize = image.GetWidth(), image.GetHeight()
if not width and height:
aspect = float(xSize) / ySize
width = aspect * height
if not height and width:
aspect = float(ySize) / xSize
height = aspect * width
if not width and not height:
width = height = 64
image.Rescale(width, height)
bitmap = image.ConvertToBitmap()
ret = [bitmap]
if getvtkImage:
ret.append(vtkImg)
return ret
return bitmap
def updateRendering(self):
"""
Update the Rendering of this module
"""
data = self.getInput(1)
x, y, z = self.dataUnit.getDimensions()
data = optimize.optimize(image=data,
updateExtent=(0, x - 1, 0, y - 1, 0, z - 1))
if data.GetNumberOfScalarComponents() > 3:
extract = vtk.vtkImageExtractComponents()
extract.SetInput(data)
extract.SetComponents(1, 1, 1)
data = extract.GetOutput()
if data.GetNumberOfScalarComponents() > 1:
self.luminance.SetInput(data)
data = self.luminance.GetOutput()
z = self.parameters["Slice"]
ext = (0, x - 1, 0, y - 1, z, z)
voi = vtk.vtkExtractVOI()
voi.SetVOI(ext)
voi.SetInput(data)
slice = voi.GetOutput()
self.geometry.SetInput(slice)
self.warp.SetInput(self.geometry.GetOutput())
self.warp.SetScaleFactor(self.parameters["Scale"])
self.merge.SetGeometry(self.warp.GetOutput())
if slice.GetNumberOfScalarComponents() == 1:
maptocol = vtk.vtkImageMapToColors()
ctf = self.getInputDataUnit(1).getColorTransferFunction()
maptocol.SetInput(slice)
maptocol.SetLookupTable(ctf)
maptocol.Update()
scalars = maptocol.GetOutput()
else:
scalars = slice
self.merge.SetScalars(scalars)
data = self.merge.GetOutput()
if self.parameters["Normals"]:
self.normals.SetInput(data)
self.normals.SetFeatureAngle(self.parameters["FeatureAngle"])
print "Feature angle=", self.parameters["FeatureAngle"]
data = self.normals.GetOutput()
self.mapper.SetInput(data)
self.mapper.Update()
VisualizationModule.updateRendering(self)
self.parent.Render()
def __init__(self):
super(camphorVOIs, self).__init__()
# data objects
self.data = [] # reference to the data array
# Other objects
self.image = [vtk.vtkImageMapToColors()]
# Output objects
self.output = self.image[0]
self.sliceOutput = self.slice[0]
def setImage(self, dicomfile):
logging.debug("In VTKImageView::setImage()")
if dicomfile:
if os.path.exists(dicomfile):
self.reader = vtkgdcm.vtkGDCMImageReader()
self.reader.SetFileName(dicomfile)
self.reader.Update()
vtkImageData = self.reader.GetOutput()
vtkImageData.UpdateInformation()
srange = vtkImageData.GetScalarRange()
cast = vtk.vtkImageCast()
cast.SetInput(vtkImageData)
cast.SetOutputScalarType(4)
cast.Update()
cast.GetOutput().SetUpdateExtentToWholeExtent()
table = vtk.vtkLookupTable()
table.SetNumberOfColors(256)
table.SetHueRange(0.0, 0.0)
table.SetSaturationRange(0.0, 0.0)
table.SetValueRange(0.0, 1.0)
table.SetAlphaRange(1.0, 1.0)
table.SetRange(srange)
table.SetRampToLinear()
table.Build()
color = vtk.vtkImageMapToColors()
color.SetLookupTable(table)
color.SetInputConnection(cast.GetOutputPort())
color.Update()
self.cast = vtk.vtkImageMapToWindowLevelColors()
self.cast.SetOutputFormatToLuminance()
self.cast.SetInputConnection(color.GetOutputPort())
self.cast.SetWindow(255.0)
self.cast.SetLevel(127.0)
self.cast.Update()
self.cast.UpdateWholeExtent()
self.render.RemoveActor(self.actor)
self.actor = vtk.vtkImageActor()
self.actor.SetInput(self.cast.GetOutput())
self.render.AddActor(self.actor)
self.render.ResetCamera()
self.Render()
else:
self.render.RemoveActor(self.actor)
self.Render()
else:
self.render.RemoveActor(self.actor)
self.Render()
def updateRendering(self): """ Update the Rendering of this module """ data = self.getInput(1) x,y,z = self.dataUnit.getDimensions() data = optimize.optimize(image = data, updateExtent = (0, x-1, 0, y-1, 0, z-1)) if data.GetNumberOfScalarComponents() > 3: extract = vtk.vtkImageExtractComponents() extract.SetInput(data) extract.SetComponents(1, 1, 1) data = extract.GetOutput() if data.GetNumberOfScalarComponents() > 1: self.luminance.SetInput(data) data = self.luminance.GetOutput() z = self.parameters["Slice"] ext = (0, x - 1, 0, y - 1, z, z) voi = vtk.vtkExtractVOI() voi.SetVOI(ext) voi.SetInput(data) slice = voi.GetOutput() self.geometry.SetInput(slice) self.warp.SetInput(self.geometry.GetOutput()) self.warp.SetScaleFactor(self.parameters["Scale"]) self.merge.SetGeometry(self.warp.GetOutput()) if slice.GetNumberOfScalarComponents() == 1: maptocol = vtk.vtkImageMapToColors() ctf = self.getInputDataUnit(1).getColorTransferFunction() maptocol.SetInput(slice) maptocol.SetLookupTable(ctf) maptocol.Update() scalars = maptocol.GetOutput() else: scalars = slice self.merge.SetScalars(scalars) data = self.merge.GetOutput() if self.parameters["Normals"]: self.normals.SetInput(data) self.normals.SetFeatureAngle(self.parameters["FeatureAngle"]) print "Feature angle=", self.parameters["FeatureAngle"] data = self.normals.GetOutput() self.mapper.SetInput(data) self.mapper.Update() VisualizationModule.updateRendering(self) self.parent.Render()
def CreateImageActor(actor, colorWindow, colorLevel):
wlut = vtk.vtkWindowLevelLookupTable()
wlut.SetWindow(colorWindow)
wlut.SetLevel(colorLevel)
wlut.Build()
# Map the image through the lookup table.
color = vtk.vtkImageMapToColors()
color.SetLookupTable(wlut)
color.SetInputData(actor.GetMapper().GetInput())
actor.GetMapper().SetInputConnection(color.GetOutputPort())
return
def dumpImage(filename):
toImage = vtk.vtkWindowToImageFilter()
toImage.SetInput(renWin)
toImage.Modified()
writer = vtk.vtkPNGWriter()
writer.SetInput(toImage.GetOutput())
writer.SetFileName(filename)
writer.Modified()
print "writing to ", filename
writer.Write()
Fractal0 = vtk.vtkImageMandelbrotSource()
Fractal0.SetWholeExtent(0, 247, 0, 247, 0, 0)
Fractal0.SetProjectionAxes(0, 1, 2)
Fractal0.SetOriginCX(-1.75, -1.25, 0, 0)
Fractal0.SetSizeCX(2.5, 2.5, 2, 1.5)
Fractal0.SetMaximumNumberOfIterations(1000)
cast = vtk.vtkImageCast()
cast.SetInputConnection(Fractal0.GetOutputPort())
cast.SetOutputScalarTypeToUnsignedChar()
table = vtk.vtkLookupTable()
table.SetTableRange(0, 100)
table.SetNumberOfColors(100)
table.Build()
table.SetTableValue(99, 0, 0, 0, 0)
colorize = vtk.vtkImageMapToColors()
colorize.SetOutputFormatToRGB()
colorize.SetLookupTable(table)
colorize.SetInputConnection(cast.GetOutputPort())
mpeg = vtk.vtkMPEG2Writer()
#mpeg.SetInputConnection(toImage.GetOutputPort())
#mpeg.SetFileName("TestMovie.mpg")
#print "writing File TestMovie.mpg "
#mpeg.Start()
itr = 1
for itr in range(1, 10):
Fractal0.SetMaximumNumberOfIterations(itr)
table.SetTableRange(0, itr)
table.SetNumberOfColors(itr)
table.ForceBuild()
table.SetTableValue(itr - 1, 0, 0, 0, 0)
mpeg.Write()
itr += 1
err = 0
exists = 0
def vtkRemapImageColor(img, ranges=[0,2000],mapRange=[0,1.0],satRange=[0.0,0.0]):
table = vtk.vtkLookupTable()
table.SetRange(ranges) # image intensity range
table.SetValueRange(mapRange) # from black to white
table.SetSaturationRange(satRange) # no color saturation
table.SetRampToLinear()
table.Build()
# Map the image through the lookup table
color = vtk.vtkImageMapToColors()
color.SetLookupTable(table)
color.SetInputData(img)
color.Update()
return color.GetOutput()
def vtkImageDataToPreviewBitmap(dataunit, timepoint, color, width=0, height=0, getvtkImage=0):
"""
A function that will take a volume and do a simple
Maximum Intensity Projection that will be converted to a
wxBitmap
"""
imagedata = dataunit.getMIP(timepoint, None, small=1, noColor=1)
vtkImg = imagedata
if not color:
color = dataunit.getColorTransferFunction()
ctf = getColorTransferFunction(color)
minval, maxval = ctf.GetRange()
imax = imagedata.GetScalarRange()[1]
if maxval > imax:
step = float((maxval - minval) / imax)
ctf2 = vtk.vtkColorTransferFunction()
Logging.info("Creating CTF in range %d, %d with steps %d" % (int(minval), int(maxval), int(step)))
for i in range(int(minval), int(maxval), int(step)):
red, green, blue = ctf.GetColor(i)
ctf2.AddRGBPoint(i / step, red, green, blue)
ctf = ctf2
maptocolor = vtk.vtkImageMapToColors()
maptocolor.SetInputConnection(imagedata.GetProducerPort())
maptocolor.SetLookupTable(ctf)
maptocolor.SetOutputFormatToRGB()
maptocolor.Update()
imagedata = maptocolor.GetOutput()
image = vtkImageDataToWxImage(imagedata)
xSize, ySize = image.GetWidth(), image.GetHeight()
if not width and height:
aspect = float(xSize) / ySize
width = aspect * height
if not height and width:
aspect = float(ySize) / xSize
height = aspect * width
if not width and not height:
width = height = 64
image.Rescale(width, height)
bitmap = image.ConvertToBitmap()
ret = [bitmap]
if getvtkImage:
ret.append(vtkImg)
return ret
return bitmap
def set_image_color(vtkimagedata,max_value,color):
lut = vtk.vtkLookupTable()
lut.SetTableRange(0, max_value)
for k in range(max_value):
val = k/(max_value-1)
lut.SetTableValue(k,val*color[0],val*color[1],val*color[2],val*color[3])
lut.Build()
colormapper = vtk.vtkImageMapToColors()
colormapper.SetLookupTable(lut)
colormapper.SetInputData(vtkimagedata)
actor = vtk.vtkImageActor()
actor.GetMapper().SetInputConnection(colormapper.GetOutputPort())
return actor
def main():
filename = get_program_parameters()
colors = vtk.vtkNamedColors()
# Read the file
reader = vtk.vtkDEMReader()
reader.SetFileName(filename)
reader.Update()
lut = vtk.vtkLookupTable()
lut.SetHueRange(0.6, 0)
lut.SetSaturationRange(1.0, 0)
lut.SetValueRange(0.5, 1.0)
lut.SetTableRange(reader.GetOutput().GetScalarRange())
# Visualize
map_colors = vtk.vtkImageMapToColors()
map_colors.SetLookupTable(lut)
map_colors.SetInputConnection(reader.GetOutputPort())
# Create an actor
actor = vtk.vtkImageActor()
actor.GetMapper().SetInputConnection(map_colors.GetOutputPort())
# Setup renderer
renderer = vtk.vtkRenderer()
renderer.AddActor(actor)
renderer.ResetCamera()
renderer.SetBackground(colors.GetColor3d("Azure"))
# Setup render window
render_window = vtk.vtkRenderWindow()
render_window.AddRenderer(renderer)
# Setup render window interactor
render_window_interactor = vtk.vtkRenderWindowInteractor()
style = vtk.vtkInteractorStyleImage()
render_window_interactor.SetInteractorStyle(style)
# Render and start interaction
render_window_interactor.SetRenderWindow(render_window)
render_window.Render()
render_window_interactor.Initialize()
render_window_interactor.Start()
def do_colour_image(self, imagedata):
# map scalar values into colors
lut_bg = vtk.vtkLookupTable()
lut_bg.SetTableRange(imagedata.GetScalarRange())
lut_bg.SetSaturationRange(self.saturation_range)
lut_bg.SetHueRange(self.hue_range)
lut_bg.SetValueRange(self.value_range)
lut_bg.Build()
# map the input image through a lookup table
img_colours_bg = vtk.vtkImageMapToColors()
img_colours_bg.SetOutputFormatToRGB()
img_colours_bg.SetLookupTable(lut_bg)
img_colours_bg.SetInput(imagedata)
img_colours_bg.Update()
return img_colours_bg.GetOutput()
def formatImageData(self, data):
if data.GetNumberOfScalarComponents() == 1:
imageToRgb = vtk.vtkImageMapToColors()
imageToRgb.SetOutputFormatToRGB()
imageToRgb.SetLookupTable(vtk.vtkScalarsToColors())
imageToRgb.SetInputData(data)
imageToRgb.Update()
data = imageToRgb.GetOutput()
if data.GetScalarType() != vtk.VTK_UNSIGNED_CHAR:
shift = vtk.vtkImageShiftScale()
shift.SetOutputScalarTypeToUnsignedChar()
shift.SetInputData(data)
shift.Update()
data = shift.GetOutput()
self.image_data.DeepCopy(data)
def set_lookup_table_min_max(self, min, max):
#pylint:disable=redefined-builtin
""" Set the minimum/maximum values for the VTK lookup table i.e.
change displayed range of intensity values. """
self.lut = vtk.vtkLookupTable()
self.lut.SetTableRange(min, max)
self.lut.SetHueRange(0, 0)
self.lut.SetSaturationRange(0, 0)
self.lut.SetValueRange(0, 1)
self.lut.Build()
self.colours = vtk.vtkImageMapToColors()
self.colours.SetInputConnection(self.reader.GetOutputPort())
self.colours.SetLookupTable(self.lut)
self.colours.Update()
self.actor.GetMapper().SetInputConnection(self.colours.GetOutputPort())
def showSlice(self, vtkImageData, preserveState):
'''Shows slice of image.'''
self.producer.SetOutput(vtkImageData)
self.reslice.SetInputConnection(self.producer.GetOutputPort())
self.reslice.SetResliceAxesDirectionCosines((1,0,0), (0,1,0), (0,0,1))
self.reslice.SetOutputDimensionality(2)
self.reslice.SetInterpolationModeToLinear()
flip = vtk.vtkImageFlip()
# flip over y axis
flip.SetFilteredAxis(1)
flip.SetInputConnection(self.reslice.GetOutputPort())
# create lookup table for intensity -> color
table = vtk.vtkLookupTable()
table.SetRange(vtkImageData.GetScalarRange())
table.SetValueRange(0, 1)
# no saturation
table.SetSaturationRange(0, 0)
table.SetRampToLinear()
table.Build()
# map lookup table to colors
colors = vtk.vtkImageMapToColors()
colors.SetLookupTable(table)
colors.SetInputConnection(flip.GetOutputPort())
# preserve image property
imageProperty = None
if preserveState and self.sliceActor:
imageProperty = self.sliceActor.GetProperty()
self.sliceActor = vtk.vtkImageActor()
self.sliceActor.GetMapper().SetInputConnection(colors.GetOutputPort())
# restore image property
if preserveState and imageProperty:
self.sliceActor.SetProperty(imageProperty)
self.sliceRenderer.RemoveAllViewProps()
self.sliceRenderer.AddActor(self.sliceActor)
self.sliceRenderer.ResetCamera()
def __create_background(self, imagedata):
thresh_min, thresh_max = imagedata.GetScalarRange()
Publisher.sendMessage("Update threshold limits list", (thresh_min, thresh_max))
# map scalar values into colors
lut_bg = self.lut_bg = vtk.vtkLookupTable()
lut_bg.SetTableRange(thresh_min, thresh_max)
lut_bg.SetSaturationRange(0, 0)
lut_bg.SetHueRange(0, 0)
lut_bg.SetValueRange(0, 1)
lut_bg.Build()
# map the input image through a lookup table
img_colours_bg = self.img_colours_bg = vtk.vtkImageMapToColors()
img_colours_bg.SetOutputFormatToRGBA()
img_colours_bg.SetLookupTable(lut_bg)
img_colours_bg.SetInput(imagedata)
return img_colours_bg.GetOutput()
def __build_mask(self, imagedata, create=True):
# create new mask instance and insert it into project
if create:
self.CreateMask(imagedata=imagedata)
current_mask = self.current_mask
# properties to be inserted into pipeline
scalar_range = int(imagedata.GetScalarRange()[1])
r, g, b = current_mask.colour
# map scalar values into colors
lut_mask = vtk.vtkLookupTable()
lut_mask.SetNumberOfTableValues(1)
lut_mask.SetNumberOfColors(1)
lut_mask.SetHueRange(const.THRESHOLD_HUE_RANGE)
lut_mask.SetSaturationRange(1, 1)
lut_mask.SetValueRange(1, 1)
lut_mask.SetNumberOfTableValues(scalar_range)
lut_mask.SetTableValue(1, r, g, b, 1.0)
lut_mask.SetTableValue(scalar_range - 1, r, g, b, 1.0)
lut_mask.SetRampToLinear()
lut_mask.Build()
self.lut_mask = lut_mask
mask_thresh_imagedata = self.__create_mask_threshold(imagedata)
if create:
# threshold pipeline
current_mask.imagedata.DeepCopy(mask_thresh_imagedata)
else:
mask_thresh_imagedata = self.current_mask.imagedata
# map the input image through a lookup table
img_colours_mask = vtk.vtkImageMapToColors()
img_colours_mask.SetOutputFormatToRGBA()
img_colours_mask.SetLookupTable(lut_mask)
img_colours_mask.SetInput(mask_thresh_imagedata)
self.img_colours_mask = img_colours_mask
return img_colours_mask.GetOutput()
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 __create_background(self, imagedata):
thresh_min, thresh_max = imagedata.GetScalarRange()
# map scalar values into colors
lut_bg = vtk.vtkLookupTable()
lut_bg.SetTableRange(thresh_min, thresh_max)
lut_bg.SetSaturationRange(0, 0)
lut_bg.SetHueRange(0, 0)
lut_bg.SetValueRange(0, 1)
lut_bg.Build()
# map the input image through a lookup table
img_colours_bg = vtk.vtkImageMapToColors()
img_colours_bg.SetOutputFormatToRGBA()
img_colours_bg.SetLookupTable(lut_bg)
img_colours_bg.SetInputData(imagedata)
img_colours_bg.Update()
return img_colours_bg.GetOutput()
def _getRGBVolume(self):
"""
Calculates the RBG volume from the indexed volume. Note that the input
volume has to be 1 channel, 16bpp indexed volume.
@rtype: C{vtkImageData}
@return: RGB colored, 24bpp volume
"""
# input volume has to
srcRead = self._inputVolume
# Create and configure proper vtk fiter:
map = vtk.vtkImageMapToColors()
map.SetInput(srcRead)
map.SetOutputFormatToRGB()
map.SetLookupTable(self._makeLut())
map.Update()
# and return the result
return map.GetOutput()
def display_axis_slice(self, axis, index):
slice_colors = vtk.vtkImageMapToColors()
slice_colors.SetInputData(self.volume)
slice_colors.SetLookupTable(self.greyscale_lut)
#slice_colors.SetLookupTable(self.hue_lut)
#slice_colors.SetLookupTable(self.sat_lut)
slice_colors.Update()
slice = vtk.vtkImageActor()
slice.GetMapper().SetInputData(slice_colors.GetOutput())
if axis == 'i':
imin = index
imax = index
jmin = 0
jmax = self.height
kmin = 0
kmax = self.depth
elif axis == 'j':
imin = 0
imax = self.width
jmin = index
jmax = index
kmin = 0
kmax = self.depth
elif axis == 'k':
imin = 0
imax = self.width
jmin = 0
jmax = self.height
kmin = index
kmax = index
slice.SetDisplayExtent(imin, imax, jmin, jmax, kmin, kmax)
slice.ForceOpaqueOn()
slice.PickableOff()
self.graphics.add_actor(slice)
def createItemToolbar(self): """ Method to create a toolbar for the window that allows use to select processed channel """ n = TaskPanel.createItemToolbar(self) coloc = vtkbxd.vtkImageColocalizationFilter() coloc.SetOutputDepth(8) i = 0 for data in self.itemMips: coloc.AddInput(data) coloc.SetColocalizationLowerThreshold(i, 100) coloc.SetColocalizationUpperThreshold(i, 255) i = i + 1 coloc.Update() ctf = vtk.vtkColorTransferFunction() ctf.AddRGBPoint(0, 0, 0, 0) ctf.AddRGBPoint(255, 1, 1, 1) maptocolor = vtk.vtkImageMapToColors() maptocolor.SetInput(coloc.GetOutput()) maptocolor.SetLookupTable(ctf) maptocolor.SetOutputFormatToRGB() maptocolor.Update() imagedata = maptocolor.GetOutput() bmp = ImageOperations.vtkImageDataToWxImage(imagedata).ConvertToBitmap() bmp = self.getChannelItemBitmap(bmp, (255, 255, 0)) toolid = wx.NewId() name = "Colocalization" self.toolMgr.addChannelItem(name, bmp, toolid, lambda e, x = n, s = self:s.setPreviewedData(e, x)) for i, tid in enumerate(self.toolIds): self.dataUnit.setOutputChannel(i, 0) self.toolMgr.toggleTool(tid, 0) self.dataUnit.setOutputChannel(len(self.toolIds), 1) self.toolIds.append(toolid) self.toolMgr.toggleTool(toolid, 1) self.restoreFromCache()
def __init__( self, color, plane, reslice, range ):
self._color = color
self._source = plane
self._mapper = vtk.vtkPolyDataMapper()
self._mapper.SetInput( self._source.GetOutput() )
self.SetMapper( self._mapper )
self._lut = vtk.vtkWindowLevelLookupTable()
self._lut.SetNumberOfColors( 256 )
self._lut.SetTableRange( range[0], range[1] )
self._lut.SetHueRange( 0.0, 0.0 )
self._lut.SetSaturationRange( 0.0, 0.0 )
self._lut.SetValueRange( 0.0, 1.0 )
self._lut.SetAlphaRange( 0.0, 1.0 )
self._lut.Build()
self._colormap = vtk.vtkImageMapToColors()
self._colormap.SetInputConnection( reslice.GetOutputPort() )
self._colormap.SetLookupTable( self._lut )
self._colormap.SetOutputFormatToRGBA()
self._colormap.PassAlphaToOutputOn()
self._texture = vtk.vtkTexture()
self._texture.SetInterpolate( True )
self._texture.SetQualityTo32Bit()
self._texture.MapColorScalarsThroughLookupTableOff()
self._texture.RepeatOff()
self._texture.SetInput( self._colormap.GetOutput() )
self._texture.SetLookupTable( self._lut )
self.SetTexture( self._texture )
self._property = vtk.vtkProperty()
self._property.SetOpacity( 0.9 )
self._property.EdgeVisibilityOn()
self._property.SetEdgeColor( self._color[0], self._color[1], self._color[2] )
self.SetProperty( self._property )
def createItemToolbar(self):
"""
Method to create a toolbar for the window that allows use to select processed channel
"""
# Pass flag force which indicates that we do want an item toolbar
# although we only have one input channel
n = GUI.FilterBasedTaskPanel.FilterBasedTaskPanel.createItemToolbar(
self, force=1)
for i, tid in enumerate(self.toolIds):
self.dataUnit.setOutputChannel(i, 0)
self.toolMgr.toggleTool(tid, 0)
ctf = vtk.vtkColorTransferFunction()
ctf.AddRGBPoint(0, 0, 0, 0)
ctf.AddRGBPoint(255, 1, 1, 1)
imagedata = self.itemMips[0]
ctf = vtk.vtkColorTransferFunction()
ctf.AddRGBPoint(0, 0, 0, 0)
ctf.AddRGBPoint(255, 1, 1, 1)
maptocolor = vtk.vtkImageMapToColors()
maptocolor.SetInput(imagedata)
maptocolor.SetLookupTable(ctf)
maptocolor.SetOutputFormatToRGB()
maptocolor.Update()
imagedata = maptocolor.GetOutput()
bmp = lib.ImageOperations.vtkImageDataToWxImage(
imagedata).ConvertToBitmap()
bmp = self.getChannelItemBitmap(bmp, (255, 255, 255))
toolid = wx.NewId()
name = "Manipulation"
self.toolMgr.addChannelItem(
name, bmp, toolid, lambda e, x=n, s=self: s.setPreviewedData(e, x))
self.toolIds.append(toolid)
self.dataUnit.setOutputChannel(len(self.toolIds), 1)
self.toolMgr.toggleTool(toolid, 1)
def imageDataTo3Component(image, ctf):
"""
Processes image data to get it to proper 3 component RGB data
"""
image.UpdateInformation()
ncomps = image.GetNumberOfScalarComponents()
if ncomps == 1:
maptocolor = vtk.vtkImageMapToColors()
maptocolor.SetInputConnection(image.GetProducerPort())
maptocolor.SetLookupTable(ctf)
maptocolor.SetOutputFormatToRGB()
imagedata = maptocolor.GetOutput()
elif ncomps > 3:
Logging.info("Data has %d components, extracting" % ncomps, kw="imageop")
extract = vtk.vtkImageExtractComponents()
extract.SetComponents(0, 1, 2)
extract.SetInputConnection(image.GetProducerPort())
imagedata = extract.GetOutput()
else:
imagedata = image
return imagedata
def processOutputData(self, data):
"""
Process the data before it's send to the preview
"""
data.UpdateInformation()
ncomps = data.GetNumberOfScalarComponents()
if ncomps > 3:
extract = vtk.vtkImageExtractComponents()
extract.SetComponents(0, 1, 2)
extract.SetInput(data)
data = extract.GetOutput()
if ncomps == 1:
Logging.info("Mapping trough ctf", kw = "preview")
self.mapToColors = vtk.vtkImageMapToColors()
self.mapToColors.SetInput(data)
self.updateColor()
colorImage = self.mapToColors.GetOutput()
outdata = colorImage
return outdata
return data
def __init__(self,data_reader,origin,normal,camera_normal):
self.axial=self.get_matrix(data_reader,origin,normal,camera_normal)
# Extract a slice in the desired orientation
self.reslice = vtk.vtkImageReslice()
self.reslice.SetInput(data_reader.get_data_set())
self.reslice.SetOutputDimensionality(2)
self.reslice.SetResliceAxes(self.axial)
self.reslice.SetInterpolationModeToLinear()
# Create a colorscale lookup table
self.lut=vtk.vtkLookupTable()
self.lut.SetNumberOfColors(256)
self.lut.SetTableRange(data_reader.get_scalar_range())
self.lut.SetRange(data_reader.get_scalar_range())
self.lut.SetHueRange(0,1)
self.lut.Build()
# Map the image through the lookup table
self.color = vtk.vtkImageMapToColors()
self.color.SetLookupTable(self.lut)
self.color.SetInputConnection(self.reslice.GetOutputPort())
# Display the image
self.actor = vtk.vtkImageActor()
self.actor.SetInput(self.color.GetOutput())
c="c"
if origin[0]==c or origin[1]==c or origin[2]==c:
origin=self.center
origin=(float(origin[0]),float(origin[1]),float(origin[2]))
self.actor.SetOrigin(origin)
self.actor.PokeMatrix(self.axial)
# that image into a different orientation for viewing. It uses
# vtkImageReslice for reformatting the image, and uses vtkImageActor
# and vtkInteractorStyleImage to display the image. This InteractorStyle
# forces the camera to stay perpendicular to the XY plane.
import vtk
# these globals are needed for this to work. perhaps create a class
# later. the below code was modified from a vtk example, to create a
# function to call for rendering.
reslice = vtk.vtkImageReslice()
window = vtk.vtkRenderWindow()
interactorStyle = vtk.vtkInteractorStyleImage()
interactor = vtk.vtkRenderWindowInteractor()
table = vtk.vtkLookupTable()
color = vtk.vtkImageMapToColors()
actor = vtk.vtkImageActor()
renderer = vtk.vtkRenderer()
actions = {}
def ButtonCallback(obj, event):
#print "button"
if event == "LeftButtonPressEvent":
actions["Slicing"] = 1
else:
actions["Slicing"] = 0
def MouseMoveCallback(obj, event):
#print "mouse move"
(lastX, lastY) = interactor.GetLastEventPosition()
(mouseX, mouseY) = interactor.GetEventPosition()
def display(image, image_pos_pat, image_ori_pat):
global xMin, xMax, yMin, yMax, zMin, zMax, xSpacing, ySpacing, zSpacing, interactor, actions, reslice, interactorStyle
# The box widget observes the events invoked by the render window
# interactor. These events come from user interaction in the render
# window.
# boxWidget = vtk.vtkBoxWidget()
# boxWidget.SetInteractor(iren1)
# boxWidget.SetPlaceFactor(1)
# Initialize Image orienation
IO = matrix( [[0, 0,-1, 0],
[1, 0, 0, 0],
[0,-1, 0, 0],
[0, 0, 0, 1]])
# Assign the 6-Image orientation patient coordinates (from Dicomtags)
IO[0,0] = image_ori_pat[0]; IO[1,0] = image_ori_pat[1]; IO[2,0] = image_ori_pat[2];
IO[0,1] = image_ori_pat[3]; IO[1,1] = image_ori_pat[4]; IO[2,1] = image_ori_pat[5];
# obtain thrid column as the cross product of column 1 y 2
IO_col1 = [image_ori_pat[0], image_ori_pat[1], image_ori_pat[2]]
IO_col2 = [image_ori_pat[3], image_ori_pat[4], image_ori_pat[5]]
IO_col3 = cross(IO_col1, IO_col2)
# assign column 3
IO[0,2] = IO_col3[0]; IO[1,2] = IO_col3[1]; IO[2,2] = IO_col3[2];
IP = array([0, 0, 0, 1]) # Initialization Image Position
IP[0] = image_pos_pat[0]; IP[1] = image_pos_pat[1]; IP[2] = image_pos_pat[2];
IO[0,3] = image_pos_pat[0]; IO[1,3] = image_pos_pat[1]; IO[2,3] = image_pos_pat[2]
print "image_pos_pat :"
print image_pos_pat
print "image_ori_pat:"
print image_ori_pat
origin = IP*IO.I
print "Volume Origin:"
print origin[0,0], origin[0,1], origin[0,2]
# Create matrix 4x4
DICOM_mat = vtk.vtkMatrix4x4();
DICOM_mat.SetElement(0, 0, IO[0,0])
DICOM_mat.SetElement(0, 1, IO[0,1])
DICOM_mat.SetElement(0, 2, IO[0,2])
DICOM_mat.SetElement(0, 3, IO[0,3])
DICOM_mat.SetElement(1, 0, IO[1,0])
DICOM_mat.SetElement(1, 1, IO[1,1])
DICOM_mat.SetElement(1, 2, IO[1,2])
DICOM_mat.SetElement(1, 3, IO[1,3])
DICOM_mat.SetElement(2, 0, IO[2,0])
DICOM_mat.SetElement(2, 1, IO[2,1])
DICOM_mat.SetElement(2, 2, IO[2,2])
DICOM_mat.SetElement(2, 3, IO[2,3])
DICOM_mat.SetElement(3, 0, IO[3,0])
DICOM_mat.SetElement(3, 1, IO[3,1])
DICOM_mat.SetElement(3, 2, IO[3,2])
DICOM_mat.SetElement(3, 3, IO[3,3])
#DICOM_mat.Invert()
# Set up the axes
transform = vtk.vtkTransform()
transform.Concatenate(DICOM_mat)
transform.Update()
# Set up the cube (set up the translation back to zero
DICOM_mat_cube = vtk.vtkMatrix4x4();
DICOM_mat_cube.DeepCopy(DICOM_mat)
DICOM_mat_cube.SetElement(0, 3, 0)
DICOM_mat_cube.SetElement(1, 3, 0)
DICOM_mat_cube.SetElement(2, 3, 0)
transform_cube = vtk.vtkTransform()
transform_cube.Concatenate(DICOM_mat_cube)
transform_cube.Update()
##########################
# Calculate the center of the volume
(xMin, xMax, yMin, yMax, zMin, zMax) = image.GetWholeExtent()
(xSpacing, ySpacing, zSpacing) = image.GetSpacing()
(x0, y0, z0) = image.GetOrigin()
center = [x0 + xSpacing * 0.5 * (xMin + xMax),
y0 + ySpacing * 0.5 * (yMin + yMax),
z0 + zSpacing * 0.5 * (zMin + zMax)]
# Matrices for axial, coronal, sagittal, oblique view orientations
axial = vtk.vtkMatrix4x4()
axial.DeepCopy((1, 0, 0, center[0],
0, 1, 0, center[1],
0, 0, 1, center[2],
0, 0, 0, 1))
coronal = vtk.vtkMatrix4x4()
coronal.DeepCopy((1, 0, 0, center[0],
0, 0, 1, center[1],
0,-1, 0, center[2],
0, 0, 0, 1))
sagittal = vtk.vtkMatrix4x4()
sagittal.DeepCopy((0, 0,-1, center[0],
1, 0, 0, center[1],
0,-1, 0, center[2],
0, 0, 0, 1))
oblique = vtk.vtkMatrix4x4()
oblique.DeepCopy((1, 0, 0, center[0],
0, 0.866025, -0.5, center[1],
0, 0.5, 0.866025, center[2],
0, 0, 0, 1))
# Extract a slice in the desired orientation
reslice = vtk.vtkImageReslice()
reslice.SetInput(image)
reslice.SetOutputDimensionality(2)
reslice.SetResliceAxes(sagittal)
reslice.SetInterpolationModeToLinear()
# Create a greyscale lookup table
table = vtk.vtkLookupTable()
table.SetRange(0, 2000) # image intensity range
table.SetValueRange(0.0, 1.0) # from black to white
table.SetSaturationRange(0.0, 0.0) # no color saturation
table.SetRampToLinear()
table.Build()
# Map the image through the lookup table
color = vtk.vtkImageMapToColors()
color.SetLookupTable(table)
color.SetInputConnection(reslice.GetOutputPort())
# Display the image
actor = vtk.vtkImageActor()
actor.GetMapper().SetInputConnection(color.GetOutputPort())
renderer1 = vtk.vtkRenderer()
renderer1.AddActor(actor)
################
# set up cube actor with Orientation(R-L, A-P, S-O) using transform_cube
# Set up to ALS (+X=A, +Y=S, +Z=L) source:
cube = vtk.vtkAnnotatedCubeActor()
cube.SetXPlusFaceText( "S" );
cube.SetXMinusFaceText( "I" );
cube.SetYPlusFaceText( "L" );
cube.SetYMinusFaceText( "R" );
cube.SetZPlusFaceText( "A" );
cube.SetZMinusFaceText( "P" );
cube.SetFaceTextScale( 0.5 );
cube.GetAssembly().SetUserTransform( transform_cube );
# Set UP the axes
axes2 = vtk.vtkAxesActor()
axes2.SetShaftTypeToCylinder();
#axes2.SetUserTransform( transform_cube );
axes2.SetTotalLength( 1.5, 1.5, 1.5 );
axes2.SetCylinderRadius( 0.500 * axes2.GetCylinderRadius() );
axes2.SetConeRadius( 1.025 * axes2.GetConeRadius() );
axes2.SetSphereRadius( 1.500 * axes2.GetSphereRadius() );
tprop2 = axes2.GetXAxisCaptionActor2D()
tprop2.GetCaptionTextProperty();
assembly = vtk.vtkPropAssembly();
assembly.AddPart( axes2 );
assembly.AddPart( cube );
widget = vtk.vtkOrientationMarkerWidget();
widget.SetOutlineColor( 0.9300, 0.5700, 0.1300 );
widget.SetOrientationMarker( assembly );
widget.SetInteractor( iren1 );
widget.SetViewport( 0.0, 0.0, 0.4, 0.4 );
widget.SetEnabled( 1 );
widget.InteractiveOff();
# Set Up Camera view
renderer1.SetBackground(0.0, 0.0, 0.0)
camera = renderer1.GetActiveCamera()
# bounds and initialize camera
b = image.GetBounds()
renderer1.ResetCamera(b)
renderer1.ResetCameraClippingRange()
camera.SetViewUp(0.0,-1.0,0.0)
camera.Azimuth(315)
# Create a text property for both cube axes
tprop = vtk.vtkTextProperty()
tprop.SetColor(1, 1, 1)
tprop.ShadowOff()
# Create a vtkCubeAxesActor2D. Use the outer edges of the bounding box to
# draw the axes. Add the actor to the renderer.
axes = vtk.vtkCubeAxesActor2D()
axes.SetInput(image)
axes.SetCamera(renderer1.GetActiveCamera())
axes.SetLabelFormat("%6.4g")
axes.SetFlyModeToOuterEdges()
axes.SetFontFactor(1.2)
axes.SetAxisTitleTextProperty(tprop)
axes.SetAxisLabelTextProperty(tprop)
renderer1.AddViewProp(axes)
############
# Place the interactor initially. The input to a 3D widget is used to
# initially position and scale the widget. The "EndInteractionEvent" is
# observed which invokes the SelectPolygons callback.
# boxWidget.SetInput(image)
# boxWidget.PlaceWidget()
# boxWidget.AddObserver("InteractionEvent", SelectPolygons)
# boxWidget.On()
# Initizalize
# Set up the interaction
interactorStyle = vtk.vtkInteractorStyleImage()
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetInteractorStyle(interactorStyle)
renWin1.SetInteractor(interactor)
renWin1.Render()
renderer1.Render()
interactor.Start()
renderer1.RemoveViewProp(axes)
return transform_cube, zImagePlaneWidget.GetSliceIndex()
def __init__(self, parent, **kws):
"""
Initialize the panel
"""
self.graySize = (0, 0)
self.bgcolor = (127, 127, 127)
self.maxClientSizeX, self.maxClientSizeY = 512, 512
self.dataWidth, self.dataHeight = 512 , 512
self.lastEventSize = None
self.paintSize = (512, 512)
self.parent = parent
self.blackImage = None
self.finalImage = None
self.xdiff, self.ydiff = 0, 0
self.oldZoomFactor = 1
self.selectedItem = -1
self.show = {}
self.rawImages = []
self.rawImage = None
self.oldx, self.oldy = 0, 0
self.curPos = (-1,-1)
Logging.info("kws=", kws, kw = "preview")
self.fixedSize = kws.get("previewsize", None)
size = kws.get("previewsize", (1024, 1024))
self.zoomFactor = kws.get("zoom_factor", 1)
self.zoomx = kws.get("zoomx", 1)
self.zoomy = kws.get("zoomy", 1)
self.show["SCROLL"] = kws.get("scrollbars", 0)
self.rgbMode = 0
self.currentImage = None
self.currentCt = None
# The preview can be no larger than these
self.dataDimX, self.dataDimY, self.dataDimZ = 0, 0, 0
self.running = 0
self.rgb = (255, 255, 0)
self.timePoint = 0
self.mapToColors = vtk.vtkImageMapToColors()
self.mapToColors.SetLookupTable(self.currentCt)
self.mapToColors.SetOutputFormatToRGB()
self.renewNext = 0
self.fitLater = 0
self.imagedata = None
self.bmp = None
self.parent = parent
self.scroll = 1
Logging.info("preview panel size=", size, kw = "preview")
x, y = size
self.buffer = wx.EmptyBitmap(x, y)
if kws.has_key("zoomx"):
del kws["zoomx"]
if kws.has_key("zoomy"):
del kws["zoomy"]
Logging.info("zoom xf=%f, yf=%f" % (self.zoomx, self.zoomy), kw = "preview")
self.size = size
self.slice = None
self.z = 0
self.zooming = 0
self.scrollTo = None
InteractivePanel.__init__(self, parent, size = size, bgColor = self.bgcolor, **kws)
self.annotationsEnabled = True
self.calculateBuffer()
self.paintSize = self.GetClientSize()
self.paintPreview()
self.addListener(wx.EVT_RIGHT_DOWN, self.onRightClick)
self.Bind(wx.EVT_SIZE, self.onSize)
self.Bind(wx.EVT_LEFT_DOWN, self.onLeftDown)
self.Bind(wx.EVT_MOTION, self.onMouseMotion)
self.SetHelpText("This window displays the selected dataset slice by slice.")
if not self.show["SCROLL"]:
Logging.info("Disabling scrollbars", kw="preview")
self.SetScrollbars(0, 0, 0, 0)
self.updateAnnotations()
self.drawableRect = self.GetClientRect()
lib.messenger.connect(None, "zslice_changed", self.setPreviewedSlice)
lib.messenger.connect(None, "renew_preview", self.setRenewFlag)
satLut.SetTableRange(0, 2000) satLut.SetHueRange(.6, .6) satLut.SetSaturationRange(0, 1) satLut.SetValueRange(1, 1) satLut.Build() # Create the first of the three planes. The filter vtkImageMapToColors # maps the data through the corresponding lookup table created above. # The vtkImageActor is a type of vtkProp and conveniently displays an # image on a single quadrilateral plane. It does this using texture # mapping and as a result is quite fast. (Note: the input image has to # be unsigned char values, which the vtkImageMapToColors produces.) # Note also that by specifying the DisplayExtent, the pipeline # requests data of this extent and the vtkImageMapToColors only # processes a slice of data. sagittalColors = vtk.vtkImageMapToColors() sagittalColors.SetInputConnection(v16.GetOutputPort()) sagittalColors.SetLookupTable(bwLut) sagittal = vtk.vtkImageActor() sagittal.GetMapper().SetInputConnection(sagittalColors.GetOutputPort()) sagittal.SetDisplayExtent(32, 32, 0, 63, 0, 92) # Create the second (axial) plane of the three planes. We use the same # approach as before except that the extent differs. axialColors = vtk.vtkImageMapToColors() axialColors.SetInputConnection(v16.GetOutputPort()) axialColors.SetLookupTable(hueLut) axial = vtk.vtkImageActor() axial.GetMapper().SetInputConnection(axialColors.GetOutputPort()) axial.SetDisplayExtent(0, 63, 0, 63, 46, 46)
boneProperty.SetColor(1.0, 1.0, 0.9) bone = vtk.vtkActor() bone.SetMapper(boneMapper) bone.SetProperty(boneProperty) # --------------------------------------------------------- # Create an image actor table = vtk.vtkLookupTable() table.SetRange(0, 2000) table.SetRampToLinear() table.SetValueRange(0, 1) table.SetHueRange(0, 0) table.SetSaturationRange(0, 0) mapToColors = vtk.vtkImageMapToColors() mapToColors.SetInputConnection(reader.GetOutputPort()) mapToColors.SetLookupTable(table) mapToColors.Update() imageActor = vtk.vtkImageActor() imageActor.GetMapper().SetInputConnection(mapToColors.GetOutputPort()) imageActor.SetDisplayExtent(32, 32, 0, 63, 0, 92) # --------------------------------------------------------- # make a transform and some clipping planes transform = vtk.vtkTransform() transform.RotateWXYZ(-20, 0.0, -0.7, 0.7) volume.SetUserTransform(transform) bone.SetUserTransform(transform)
def __init__(self, data_source, input_link):
"""Parallel coordinates view constructor needs a valid DataSource plus
and external annotation link (from the icicle view).
"""
self.ds = data_source
self.input_link = input_link
# Set up callback to listen for changes in IcicleView selections
self.input_link.AddObserver("AnnotationChangedEvent", self.InputSelectionCallback)
# Set up an annotation link for other views to monitor selected image
self.output_link = vtk.vtkAnnotationLink()
# If you don't set the FieldType explicitly it ends up as UNKNOWN (as of 21 Feb 2010)
# See vtkSelectionNode doc for field and content type enum values
self.output_link.GetCurrentSelection().GetNode(0).SetFieldType(1) # Point
# The chart seems to force INDEX selection, so I'm using vtkConvertSelection below to get
# out PedigreeIds...
self.output_link.GetCurrentSelection().GetNode(0).SetContentType(2) # 2 = PedigreeIds, 4 = Indices
# Going to manually create output_link selection list, so not setting up callback for it...
if os.path.isfile(os.path.abspath('BlankImage.png')):
blank_file = 'BlankImage.png'
else:
# For use in app bundles
blank_file = os.path.join(sys.path[0],'BlankImage.png')
self.blankImageReader = vtk.vtkPNGReader()
self.blankImageReader.SetFileName(blank_file)
self.blankImageReader.Update()
tmp = self.blankImageReader.GetOutput().GetBounds()
self.flowSpacing = float(tmp[1]-tmp[0])*1.1
# Create a greyscale lookup table
self.lut = self.ds.GetGrayscaleLUT('gray')
self.lut.SetRange(self.blankImageReader.GetOutput().GetPointData().GetArray('PNGImage').GetRange()) # image intensity range
# Map the image through the lookup table
self.color = vtk.vtkImageMapToColors()
self.color.SetLookupTable(self.lut)
self.color.SetInput(self.blankImageReader.GetOutput())
self.resliceList = []
self.actorList = []
self.numImages = 1
# Map between indices of images and their Pedigree ID
self.pedigree_id_dict = {}
blankImageActor = vtk.vtkImageActor()
blankImageActor.SetInput(self.color.GetOutput())
blankImageActor.SetPickable(False)
blankImageActor.SetOpacity(0.1)
self.actorList.append(blankImageActor)
self.expSpread = 0.5
self.maxAngle = 80.0
self.renderer = vtk.vtkRenderer()
self.cam = self.renderer.GetActiveCamera()
# renderer.SetBackground(0.15, 0.12, 0.1)
# cc0,cc1,cc2 = [float(ccVal)/255.0 for ccVal in [68,57,53]]
# self.renderer.SetBackground(cc0,cc1,cc2)
# cc0,cc1,cc2 = [float(ccVal)/255.0 for ccVal in [60,60,60]]
cc0,cc1,cc2 = [float(ccVal)/255.0 for ccVal in [160, 160, 160]]
self.renderer.SetBackground(cc0,cc1,cc2)
self.renderer.AddActor(self.actorList[0])
self.highlightRect = vtk.vtkOutlineSource()
self.highlightRect.SetBounds(self.actorList[0].GetBounds())
self.highlightMapper = vtk.vtkPolyDataMapper()
self.highlightMapper.SetInputConnection(self.highlightRect.GetOutputPort(0))
self.highlightActor = vtk.vtkActor()
self.highlightActor.SetMapper(self.highlightMapper)
self.highlightActor.GetProperty().SetColor(0,0.5,1.0)
self.highlightActor.GetProperty().SetLineWidth(6.0)
self.highlightActor.GetProperty().SetOpacity(0.5)
self.highlightActor.SetOrientation(self.actorList[0].GetOrientation())
tmpPos = self.actorList[0].GetPosition()
usePos = (tmpPos[0],tmpPos[1],tmpPos[2]+0.01)
self.highlightActor.SetPosition(usePos)
# Setting as if nothing picked even though initialized position & orientation to actor0
self.highlightIndex = -1
self.highlightActor.SetPickable(False)
self.highlightActor.SetVisibility(False)
self.renderer.AddActor(self.highlightActor)
# Create the slider which will control the image positions
self.sliderRep = vtk.vtkSliderRepresentation2D()
self.sliderRep.SetMinimumValue(0)
self.sliderRep.SetMaximumValue(self.numImages-1)
self.sliderRep.SetValue(0)
self.window = vtk.vtkRenderWindow()
self.window.SetSize(600,300)
self.window.AddRenderer(self.renderer)
# Set up the interaction
self.interactorStyle = vtk.vtkInteractorStyleImage()
self.interactor = vtk.vtkRenderWindowInteractor()
self.interactor.SetInteractorStyle(self.interactorStyle)
self.window.SetInteractor(self.interactor)
self.sliderWidget = vtk.vtkSliderWidget()
self.sliderWidget.SetInteractor(self.interactor)
self.sliderWidget.SetRepresentation(self.sliderRep)
self.sliderWidget.SetAnimationModeToAnimate()
self.sliderWidget.EnabledOn()
self.sliderWidget.AddObserver("InteractionEvent", self.sliderCallback)
self.sliderWidget.AddObserver("EndInteractionEvent", self.endSliderCallback)
# Default flow direction Horizontal
self.FlowDirection = Direction.Horizontal
self.SetFlowDirection(self.FlowDirection)
# Set up callback to toggle between inspect modes (manip axes & select data)
# self.interactorStyle.AddObserver("SelectionChangedEvent", self.selectImage)
# Create callbacks for mouse events
self.mouseActions = {}
self.mouseActions["LeftButtonDown"] = 0
self.mouseActions["Picking"] = 0
self.interactorStyle.AddObserver("MouseMoveEvent", self.MouseMoveCallback)
self.interactorStyle.AddObserver("LeftButtonPressEvent", self.LeftButtonPressCallback)
self.interactorStyle.AddObserver("LeftButtonReleaseEvent", self.LeftButtonReleaseCallback)
self.cam.ParallelProjectionOn()
self.renderer.ResetCamera(self.actorList[0].GetBounds())
self.cam.Elevation(10)
self.renderer.ResetCameraClippingRange()
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()
# warp an image with a thin plate spline
# first, create an image to warp
imageGrid = vtk.vtkImageGridSource()
imageGrid.SetGridSpacing(16,16,0)
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(0,reader1.GetOutputPort())
blend.AddInputConnection(0,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)