def addT2transvisualize(self, T2images, image_pos_pat, image_ori_pat, T2dims, T2spacing, sideBreast, interact):
'''Added to build second reference frame and display T2 overlayed into T1 reference frame'''
# Proceed to build reference frame for display objects based on DICOM coords
[transformed_T2image, transform_cube] = self.dicomTransform(T2images, image_pos_pat, image_ori_pat)
#alignR = int(raw_input('\nAlign right? Yes:1 No:0 : '))
#if alignR:
if(sideBreast=="Right"):
zf1 = self.T1spacing[2]*self.T1extent[5] + self.T1origin[2]
self.T2origin[2] = zf1 - T2spacing[2]*self.T2extent[5] # this is z-span
else:
self.T2origin[2] = self.T1origin[2]
# Change info origin
translated_T2image = vtk.vtkImageChangeInformation()
translated_T2image.SetInput( transformed_T2image )
translated_T2image.SetOutputOrigin(self.T2origin)
translated_T2image.Update()
# Set up ortogonal planes
self.xImagePlaneWidget.SetInput( translated_T2image.GetOutput() )
self.xImagePlaneWidget.SetSliceIndex(0)
self.yImagePlaneWidget.SetInput( translated_T2image.GetOutput() )
self.yImagePlaneWidget.SetSliceIndex(0)
self.zImagePlaneWidget.SetInput( translated_T2image.GetOutput() )
self.zImagePlaneWidget.SetSliceIndex(0)
# Create a text property for both cube axes
tprop = vtk.vtkTextProperty()
tprop.SetColor(0.5, 0.5, 0)
tprop.ShadowOff()
# Update the reneder window to receive new image !Important*****
self.renderer1.Modified()
self.renWin1.Modified()
# Create a vtkCubeAxesActor2D. Use the outer edges of the bounding box to
# draw the axes. Add the actor to the renderer.
axesT2 = vtk.vtkCubeAxesActor2D()
axesT2.SetInput(translated_T2image.GetOutput())
axesT2.SetCamera(self.renderer1.GetActiveCamera())
axesT2.SetLabelFormat("%6.4g")
axesT2.SetFlyModeToOuterEdges()
axesT2.SetFontFactor(1.2)
axesT2.SetAxisTitleTextProperty(tprop)
axesT2.SetAxisLabelTextProperty(tprop)
self.renderer1.AddViewProp(axesT2)
### Update T2Images
t_T2images = vtk.vtkImageChangeInformation()
t_T2images.SetInput( T2images )
t_T2images.SetOutputOrigin(self.T2origin)
t_T2images.Update()
############
if(interact==True):
interactor = self.renWin1.GetInteractor()
interactor.Start()
return
def transform_all_images(register, image_datas, defining_image):
image_list = list()
idx = 0
transform_list = register.convert_transforms_to_vtk()
image_datas = [image_datas[0]]
info = vtk.vtkImageChangeInformation()
info.SetInput(defining_image)
info.CenterImageOn()
for image in image_datas:
change = vtk.vtkImageChangeInformation()
change.SetInput(image)
change.CenterImageOn()
#change.SetOutputSpacing(1,1,1)
#spacing = image.GetSpacing()
if 1:
trans = vtk.vtkTransform()
# this is right except scaling is 1/correct
tx = transform_list[idx]
trans.Concatenate(tx)
#trans = tx
#trans.Scale(-1,-1,-1)
trans.Inverse()
#trans.Scale(-1,-1,-1)
if 0:
transform = numpy.zeros(15)
transform2 = numpy.zeros(15)
tform = register._subjects[idx].transform
# rotation and translation are "already inverted"
# from images being in LPS
transform[0:6] = tform[0:6]
# invert scaling
transform[6:9] = numpy.divide(1.0, tform[6:9])
# invert shear
transform2[6:9] = 1.0
transform2[9:15] = tform[9:15]
reg_ops = wma.register.RegistrationInformation()
trans = reg_ops.convert_transform_to_vtk(transform)
trans2 = reg_ops.convert_transform_to_vtk(transform2)
trans2.Scale(-1,-1,-1)
trans2.Inverse()
trans.Concatenate(trans2)
resample = vtk.vtkImageReslice()
#resample.SetResliceAxesDirectionCosines(1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0)
#resample.SetResliceAxesDirectionCosines(-1.0, 0.0, 0.0, 0.0, -1.0, 0.0, 0.0, 0.0, -1.0)
#resample.SetInput(image)
resample.SetInput(change.GetOutput())
resample.SetResliceTransform(trans)
print trans
#resample.SetInformationInput(info.GetOutput())
#resample.SetOutputSpacing(spacing)
resample.Update()
#resample.SetOutputOrigin(origin)
image_list.append(resample.GetOutput())
idx += 1
del resample
return image_list
def __init__(self):
super(DualFlouroSceneVisualizer, self).__init__()
# Remove origin information
self.xray_changer_1 = vtk.vtkImageChangeInformation()
self.xray_changer_1.SetOutputOrigin(0, 0, 0)
self.xray_changer_2 = vtk.vtkImageChangeInformation()
self.xray_changer_2.SetOutputOrigin(0, 0, 0)
self.ct_changer = vtk.vtkImageChangeInformation()
self.ct_changer.SetOutputOrigin(0, 0, 0)
# Setup mapper and actor for x-ray images
self.xray_mapper_1 = vtk.vtkImageSliceMapper()
self.xray_mapper_1.SetInputConnection(
self.xray_changer_1.GetOutputPort())
self.xray_mapper_2 = vtk.vtkImageSliceMapper()
self.xray_mapper_2.SetInputConnection(
self.xray_changer_2.GetOutputPort())
self.xray_property = vtk.vtkImageProperty()
self.xray_property.SetInterpolationTypeToNearest()
self.xray_slice_1 = vtk.vtkImageSlice()
self.xray_slice_1.SetMapper(self.xray_mapper_1)
self.xray_slice_1.SetProperty(self.xray_property)
self.xray_slice_2 = vtk.vtkImageSlice()
self.xray_slice_2.SetMapper(self.xray_mapper_2)
self.xray_slice_2.SetProperty(self.xray_property)
self.marchingCubes = vtk.vtkImageMarchingCubes()
self.marchingCubes.SetInputConnection(self.ct_changer.GetOutputPort())
self.marchingCubes.ComputeGradientsOn()
self.marchingCubes.ComputeNormalsOn()
self.marchingCubes.ComputeScalarsOn()
self.marchingCubes.SetNumberOfContours(1)
self.marchingCubes.SetValue(0, 0)
self.ct_mapper = vtk.vtkPolyDataMapper()
self.ct_mapper.SetInputConnection(self.marchingCubes.GetOutputPort())
self.ct_mapper.ScalarVisibilityOff()
self.ct_actor = vtk.vtkActor()
self.ct_actor.SetMapper(self.ct_mapper)
self.ct_actor.GetProperty().SetInterpolationToGouraud()
self.ct_actor.GetProperty().SetColor(GetRGBColor('antique_white'))
self.renderer = vtk.vtkRenderer()
self.renderer.AddViewProp(self.ct_actor)
self.renderer.AddViewProp(self.xray_slice_1)
self.renderer.AddViewProp(self.xray_slice_2)
self.renderer.SetBackground(0.1, 0.2, 0.3)
self.interactor = vtk.vtkRenderWindowInteractor()
self.interactor_style = vtk.vtkInteractorStyleTrackballCamera()
self.interactor.SetInteractorStyle(self.interactor_style)
def Execute(self):
if not self.KSpace:
self.PrintError("Error: no KSpace.")
ifft = vtk.vtkImageRFFT()
ifft.SetInput(self.KSpace)
ifft.SetDimensionality(self.KSpaceDimensionality)
ifft.Update()
ifftMagnitude = vtk.vtkImageMagnitude()
ifftMagnitude.SetInput(ifft.GetOutput())
ifftMagnitude.Update()
origin = self.KSpace.GetOrigin()
kspacing = self.KSpace.GetSpacing()
dimensions = self.KSpace.GetDimensions()
spacing = [
1.0 / (dimensions[0] * kspacing[0]),
1.0 / (dimensions[1] * kspacing[1]),
1.0 / (dimensions[2] * kspacing[2]),
]
imageInformation = vtk.vtkImageChangeInformation()
imageInformation.SetInput(ifftMagnitude.GetOutput())
imageInformation.SetOutputSpacing(spacing)
imageInformation.SetOutputOrigin(origin)
imageInformation.Update()
self.Image = imageInformation.GetOutput()
def __init__(self, module_manager):
ModuleBase.__init__(self, module_manager)
# setup config
self._config.resolution = 40
# and then our scripted config
configList = [('Resolution: ', 'resolution', 'base:int', 'text',
'x, y and z resolution of sampled volume. '
'According to the article, should be 40 to be '
'at Nyquist.')]
# now create the necessary VTK modules
self._es = vtk.vtkImageEllipsoidSource()
self._es.SetOutputScalarTypeToFloat()
self._ic = vtk.vtkImageChangeInformation()
self._ic.SetInputConnection(self._es.GetOutputPort())
self._output = vtk.vtkImageData()
# mixin ctor
ScriptedConfigModuleMixin.__init__(self, configList,
{'Module (self)': self})
self.sync_module_logic_with_config()
def __init__(self, module_manager):
ModuleBase.__init__(self, module_manager)
self._reader = vtkgdcm.vtkGDCMImageReader()
# NB NB NB: for now we're SWITCHING off the VTK-compatible
# Y-flip, until the X-mirror issues can be solved.
self._reader.SetFileLowerLeft(1)
self._ici = vtk.vtkImageChangeInformation()
self._ici.SetInputConnection(0, self._reader.GetOutputPort(0))
# create output MedicalMetaData and populate it with the
# necessary bindings.
mmd = MedicalMetaData()
mmd.medical_image_properties = \
self._reader.GetMedicalImageProperties()
mmd.direction_cosines = \
self._reader.GetDirectionCosines()
self._output_mmd = mmd
module_utils.setup_vtk_object_progress(self, self._reader,
'Reading DICOM data')
self._view_frame = None
self._file_dialog = None
self._config.dicom_filenames = []
# if this is true, module will still try to load set even if
# IPP sorting fails by sorting images alphabetically
self._config.robust_spacing = False
self.sync_module_logic_with_config()
def _handlerVoiSaveButton(self, event):
input_data = self.getPrimaryInput()
filename = self.controlFrame.voiFilenameText.GetValue()
if input_data and self._voi_widget.GetEnabled() and filename:
# see if we need to reset to zero origin
zor = self.controlFrame.voiResetToOriginCheck.GetValue()
extractVOI = vtk.vtkExtractVOI()
extractVOI.SetInput(input_data)
extractVOI.SetVOI(self._currentVOI)
writer = vtk.vtkXMLImageDataWriter()
writer.SetDataModeToBinary()
writer.SetFileName(filename)
if zor:
ici = vtk.vtkImageChangeInformation()
ici.SetOutputExtentStart(0, 0, 0)
ici.SetInput(extractVOI.GetOutput())
writer.SetInput(ici.GetOutput())
else:
writer.SetInput(extractVOI.GetOutput())
writer.Write()
def __init__(self, module_manager):
ModuleBase.__init__(self, module_manager)
# setup config
self._config.resolution = 40
# and then our scripted config
configList = [
('Resolution: ', 'resolution', 'base:int', 'text',
'x, y and z resolution of sampled volume. '
'According to the article, should be 40 to be '
'at Nyquist.')]
# now create the necessary VTK modules
self._es = vtk.vtkImageEllipsoidSource()
self._es.SetOutputScalarTypeToFloat()
self._ic = vtk.vtkImageChangeInformation()
self._ic.SetInputConnection(self._es.GetOutputPort())
self._output = vtk.vtkImageData()
# mixin ctor
ScriptedConfigModuleMixin.__init__(
self, configList,
{'Module (self)' : self})
self.sync_module_logic_with_config()
def buildPipeline(self):
""" execute() -> None
Dispatch the vtkRenderer to the actual rendering widget
"""
self.initialOrigin = self.input.GetOrigin()
self.initialExtent = self.input.GetExtent()
self.initialSpacing = self.input.GetSpacing()
self.initialAoi = self.getUnscaledWorldExtent( self.initialExtent, self.initialSpacing )
self.currentAoi = list( self.initialAoi )
self.clip = vtk.vtkExtractVOI()
self.inputModule.inputToAlgorithm( self.clip )
self.pad = vtk.vtkImageMagnify()
self.pad.InterpolateOn()
self.pad.SetInputConnection( self.clip.GetOutputPort() )
self.imageInfo = vtk.vtkImageChangeInformation()
self.imageInfo.SetInputConnection( self.pad.GetOutputPort() )
self.imageInfo.SetOutputOrigin( self.initialOrigin[0], self.initialOrigin[1], self.initialOrigin[2] )
self.imageInfo.SetOutputExtentStart( self.initialExtent[0], self.initialExtent[2], self.initialExtent[4] )
self.imageInfo.SetOutputSpacing( self.initialSpacing[0], self.initialSpacing[1], self.initialSpacing[2] )
self.setExtent( self.initialExtent )
self.set3DOutput( port=self.imageInfo.GetOutputPort() )
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkImageChangeInformation(), 'Processing.',
('vtkImageData', 'vtkImageData'), ('vtkImageData',),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
def _handlerVoiSaveButton(self, event):
input_data = self.getPrimaryInput()
filename = self.controlFrame.voiFilenameText.GetValue()
if input_data and self._voi_widget.GetEnabled() and filename:
# see if we need to reset to zero origin
zor = self.controlFrame.voiResetToOriginCheck.GetValue()
extractVOI = vtk.vtkExtractVOI()
extractVOI.SetInput(input_data)
extractVOI.SetVOI(self._currentVOI)
writer = vtk.vtkXMLImageDataWriter()
writer.SetDataModeToBinary()
writer.SetFileName(filename)
if zor:
ici = vtk.vtkImageChangeInformation()
ici.SetOutputExtentStart(0,0,0)
ici.SetInput(extractVOI.GetOutput())
writer.SetInput(ici.GetOutput())
else:
writer.SetInput(extractVOI.GetOutput())
writer.Write()
def Execute(self):
if not self.KSpace:
self.PrintError('Error: no KSpace.')
ifft = vtk.vtkImageRFFT()
ifft.SetInput(self.KSpace)
ifft.SetDimensionality(self.KSpaceDimensionality)
ifft.Update()
ifftMagnitude = vtk.vtkImageMagnitude()
ifftMagnitude.SetInput(ifft.GetOutput())
ifftMagnitude.Update()
origin = self.KSpace.GetOrigin()
kspacing = self.KSpace.GetSpacing()
dimensions = self.KSpace.GetDimensions()
spacing = [1.0/(dimensions[0]*kspacing[0]),1.0/(dimensions[1]*kspacing[1]),1.0/(dimensions[2]*kspacing[2])]
imageInformation = vtk.vtkImageChangeInformation()
imageInformation.SetInput(ifftMagnitude.GetOutput())
imageInformation.SetOutputSpacing(spacing)
imageInformation.SetOutputOrigin(origin)
imageInformation.Update()
self.Image = imageInformation.GetOutput()
def buildPipeline(self):
""" execute() -> None
Dispatch the vtkRenderer to the actual rendering widget
"""
module = self.getRegisteredModule()
world_map = None # wmod.forceGetInputFromPort( "world_map", None ) if wmod else None
opacity = wmod.forceGetInputFromPort( "opacity", 0.4 ) if wmod else 0.4
map_border_size = wmod.forceGetInputFromPort( "map_border_size", 20 ) if wmod else 20
self.y0 = -90.0
dataPosition = None
if world_map == None:
self.map_file = defaultMapFile
self.map_cut = defaultMapCut
else:
self.map_file = world_map[0].name
self.map_cut = world_map[1]
self.world_cut = wmod.forceGetInputFromPort( "world_cut", -1 ) if wmod else getFunctionParmStrValues( module, "world_cut", -1 )
roi_size = [ self.roi[1] - self.roi[0], self.roi[3] - self.roi[2] ]
map_cut_size = [ roi_size[0] + 2*map_border_size, roi_size[1] + 2*map_border_size ]
data_origin = self.input().GetOrigin() if self.input() else [ 0, 0, 0 ]
if self.world_cut == -1:
if (self.roi <> None):
if roi_size[0] > 180:
self.ComputeCornerPosition()
self.world_cut = NormalizeLon( self.x0 )
else:
dataPosition = [ ( self.roi[1] + self.roi[0] ) / 2.0, ( self.roi[3] + self.roi[2] ) / 2.0 ]
else:
self.world_cut = self.map_cut
self.imageInfo = vtk.vtkImageChangeInformation()
image_reader = vtk.vtkJPEGReader()
image_reader.SetFileName( self.map_file )
baseImage = image_reader.GetOutput()
new_dims = None
if dataPosition == None:
baseImage = self.RollMap( baseImage )
new_dims = baseImage.GetDimensions()
else:
baseImage, new_dims = self.getBoundedMap( baseImage, dataPosition, map_cut_size )
scale = [ map_cut_size[0]/new_dims[0], map_cut_size[1]/new_dims[1], 1 ]
# printArgs( " baseMap: ", extent=baseImage.GetExtent(), spacing=baseImage.GetSpacing(), origin=baseImage.GetOrigin() )
self.baseMapActor = vtk.vtkImageActor()
self.baseMapActor.SetOrigin( 0.0, 0.0, 0.0 )
self.baseMapActor.SetScale( scale )
self.baseMapActor.SetOrientation( 0.0, 0.0, 0.0 )
self.baseMapActor.SetOpacity( opacity )
# self.baseMapActor.SetDisplayExtent( -1, 0, 0, 0, 0, 0 )
#Positioning map at location %s, size = %s, roi = %s" % ( str( ( self.x0, self.y0) ), str( map_cut_size ), str( ( NormalizeLon( self.roi[0] ), NormalizeLon( self.roi[1] ), self.roi[2], self.roi[3] ) ) )
self.baseMapActor.SetPosition( self.x0, self.y0, 0.1 )
self.baseMapActor.SetInput( baseImage )
self.renderer.AddActor( self.baseMapActor )
def __init__(self, module_manager):
# initialise our base class
ModuleBase.__init__(self, module_manager)
NoConfigModuleMixin.__init__(self, {'Module (self)': self})
self.sync_module_logic_with_config()
self._ir = vtk.vtkImageReslice()
self._ici = vtk.vtkImageChangeInformation()
def scaleImage(image, scaleX=None,scaleY=None,scaleZ=None):
if (scaleX == None)or(scaleY == None)or(scaleZ == None):
scale = max(abs(image.GetBounds()[1]-image.GetBounds()[0]),abs(image.GetBounds()[3]-image.GetBounds()[2]),abs(image.GetBounds()[5]-image.GetBounds()[4]))
scaleX,scaleY,scaleZ = 1./scale,1./scale,1./scale
rescale = vtk.vtkImageChangeInformation()
rescale.SetInput(image)
rescale.SetOutputOrigin(0.0,0.0,0.0)
rescale.SetSpacingScale(scaleX,scaleY,scaleZ)
rescale.Update()
return rescale.GetOutput()
def __init__(self, module_manager):
# initialise our base class
ModuleBase.__init__(self, module_manager)
NoConfigModuleMixin.__init__(
self, {'Module (self)' : self})
self.sync_module_logic_with_config()
self._ir = vtk.vtkImageReslice()
self._ici = vtk.vtkImageChangeInformation()
def build( self, **args ):
if self.enableBasemap:
# print " @@@ MapManager: build "
world_map = None
dataPosition = None
if world_map == None:
self.map_file = defaultMapFile
self.map_cut = defaultMapCut
else:
self.map_file = world_map[0].name
self.map_cut = world_map[1]
# data_origin = self.input().GetOrigin() if self.input() else [ 0, 0, 0 ]
if self.world_cut == -1:
if (self.roi <> None):
if self.roi_size[0] > 180:
self.ComputeCornerPosition()
self.world_cut = self.NormalizeMapLon( self.x0 )
else:
dataPosition = [ ( self.roi[1] + self.roi[0] ) / 2.0, ( self.roi[3] + self.roi[2] ) / 2.0 ]
else:
self.world_cut = self.map_cut
self.imageInfo = vtk.vtkImageChangeInformation()
self.image_reader = vtk.vtkJPEGReader()
self.image_reader.SetFileName( self.map_file )
self.image_reader.Update()
world_image = self.image_reader.GetOutput()
self.sphericalBaseImage = self.RollMap( world_image )
new_dims, scale = None, None
if dataPosition == None:
self.baseImage = self.RollMap( world_image )
new_dims = self.baseImage.GetDimensions()
scale = [ 360.0/new_dims[0], 180.0/new_dims[1], 1 ]
self.width = 360.0
else:
self.baseImage, new_dims = self.getBoundedMap( world_image, dataPosition )
scale = [ self.map_cut_size[0]/new_dims[0], self.map_cut_size[1]/new_dims[1], 1 ]
self.width = self.map_cut_size[0]
self.baseMapActor = vtk.vtkImageActor()
self.baseMapActor.SetOrigin( 0.0, 0.0, 0.0 )
self.baseMapActor.SetScale( scale )
self.baseMapActor.SetOrientation( 0.0, 0.0, 0.0 )
self.baseMapActor.SetOpacity( self.map_opacity )
mapCorner = [ self.x0, self.y0 ]
self.baseMapActor.SetPosition( mapCorner[0], mapCorner[1], 0.05 )
extent = self.baseImage.GetExtent()
# print " @@@ baseImage.GetExtent: ", str( extent )
# print " @@@ baseImage.Position: ", str( self.x0 )
# print " @@@ baseImage.Size: ", str( self.map_cut_size )
if vtk.VTK_MAJOR_VERSION <= 5: self.baseMapActor.SetInput(self.baseImage)
else: self.baseMapActor.SetInputData(self.baseImage)
self.mapCenter = [ self.x0 + self.map_cut_size[0]/2.0, self.y0 + self.map_cut_size[1]/2.0 ]
def build( self, **args ):
if self.enableBasemap:
# print " @@@ MapManager: build "
world_map = None
dataPosition = None
if world_map == None:
self.map_file = defaultMapFile
self.map_cut = defaultMapCut
else:
self.map_file = world_map[0].name
self.map_cut = world_map[1]
# data_origin = self.input().GetOrigin() if self.input() else [ 0, 0, 0 ]
if self.world_cut == -1:
if (self.roi <> None):
if self.roi_size[0] > 180:
self.ComputeCornerPosition()
self.world_cut = self.NormalizeMapLon( self.x0 )
else:
dataPosition = [ ( self.roi[1] + self.roi[0] ) / 2.0, ( self.roi[3] + self.roi[2] ) / 2.0 ]
else:
self.world_cut = self.map_cut
self.imageInfo = vtk.vtkImageChangeInformation()
self.image_reader = vtk.vtkJPEGReader()
self.image_reader.SetFileName( self.map_file )
self.image_reader.Update()
world_image = self.image_reader.GetOutput()
self.sphericalBaseImage = self.RollMap( world_image )
new_dims, scale = None, None
if dataPosition == None:
self.baseImage = self.RollMap( world_image )
new_dims = self.baseImage.GetDimensions()
scale = [ 360.0/new_dims[0], 180.0/new_dims[1], 1 ]
self.width = 360.0
else:
self.baseImage, new_dims = self.getBoundedMap( world_image, dataPosition )
scale = [ self.map_cut_size[0]/new_dims[0], self.map_cut_size[1]/new_dims[1], 1 ]
self.width = self.map_cut_size[0]
self.baseMapActor = vtk.vtkImageActor()
self.baseMapActor.SetOrigin( 0.0, 0.0, 0.0 )
self.baseMapActor.SetScale( scale )
self.baseMapActor.SetOrientation( 0.0, 0.0, 0.0 )
self.baseMapActor.SetOpacity( self.map_opacity )
mapCorner = [ self.x0, self.y0 ]
self.baseMapActor.SetPosition( mapCorner[0], mapCorner[1], 0.1 )
extent = self.baseImage.GetExtent()
# print " @@@ baseImage.GetExtent: ", str( extent )
# print " @@@ baseImage.Position: ", str( self.x0 )
# print " @@@ baseImage.Size: ", str( self.map_cut_size )
if vtk.VTK_MAJOR_VERSION <= 5: self.baseMapActor.SetInput(self.baseImage)
else: self.baseMapActor.SetInputData(self.baseImage)
self.mapCenter = [ self.x0 + self.map_cut_size[0]/2.0, self.y0 + self.map_cut_size[1]/2.0 ]
def mhaTransform(self, image, image_pos_pat, image_ori_pat):
""" mhaTransform: transforms an image from mha coordinate frame"""
"Image Orientation Patient Matrix"
IO = matrix( [[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 1]])
# Assign the 6-Image orientation patient coordinates (from Dicomtags)
IO[0,0] = image_ori_pat[0]; IO[0,1] = image_ori_pat[1]; IO[0,2] = image_ori_pat[2];
IO[1,0] = image_ori_pat[3]; IO[1,1] = image_ori_pat[4]; IO[1,2] = 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[2,0] = IO_col3[0]; IO[2,1] = 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 "Compute: Position, Orientation, matrix, & Volume Origin"
print image_pos_pat
print image_ori_pat
print IO
origin = IP*IO.I
print origin[0,0], origin[0,1], origin[0,2]
# Change info
# No need to Flip along Y-Z-axis like form DICOM
# Change info origin
origin_image = vtk.vtkImageChangeInformation()
origin_image.SetInputData( image )
origin_image.SetOutputOrigin(origin[0,0], origin[0,1], origin[0,2])
origin_image.Update()
transformed_image = origin_image.GetOutput()
self.T2dims = transformed_image.GetDimensions()
print "Image Dimensions"
print self.T2dims
(xMin, xMax, yMin, yMax, zMin, zMax) = transformed_image.GetExtent()
print "Image Extension"
print xMin, xMax, yMin, yMax, zMin, zMax
self.T2spacing = transformed_image.GetSpacing()
print "Image Spacing"
print self.T2spacing
self.T2origin = transformed_image.GetOrigin()
print "Image Origin"
print self.T2origin
return transformed_image
def build( self, **args ):
if self.enableBasemap:
world_map = None
dataPosition = None
if world_map == None:
self.map_file = defaultMapFile
self.map_cut = defaultMapCut
else:
self.map_file = world_map[0].name
self.map_cut = world_map[1]
roi_size = [ self.roi[1] - self.roi[0], self.roi[3] - self.roi[2] ]
map_cut_size = [ roi_size[0] + 2*self.map_border_size, roi_size[1] + 2*self.map_border_size ]
if map_cut_size[0] > 360.0: map_cut_size[0] = 360.0
if map_cut_size[1] > 180.0: map_cut_size[1] = 180.0
# data_origin = self.input().GetOrigin() if self.input() else [ 0, 0, 0 ]
if self.world_cut == -1:
if (self.roi <> None):
if roi_size[0] > 180:
self.ComputeCornerPosition()
self.world_cut = self.NormalizeMapLon( self.x0 )
else:
dataPosition = [ ( self.roi[1] + self.roi[0] ) / 2.0, ( self.roi[3] + self.roi[2] ) / 2.0 ]
else:
self.world_cut = self.map_cut
self.imageInfo = vtk.vtkImageChangeInformation()
self.image_reader = vtk.vtkJPEGReader()
self.image_reader.SetFileName( self.map_file )
self.image_reader.Update()
world_image = self.image_reader.GetOutput()
self.sphericalBaseImage = self.RollMap( world_image )
new_dims, scale = None, None
if dataPosition == None:
self.baseImage = self.RollMap( world_image )
new_dims = self.baseImage.GetDimensions()
scale = [ 360.0/new_dims[0], 180.0/new_dims[1], 1 ]
else:
self.baseImage, new_dims = self.getBoundedMap( world_image, dataPosition, map_cut_size, self.map_border_size )
scale = [ map_cut_size[0]/new_dims[0], map_cut_size[1]/new_dims[1], 1 ]
self.baseMapActor = vtk.vtkImageActor()
self.baseMapActor.SetOrigin( 0.0, 0.0, 0.0 )
self.baseMapActor.SetScale( scale )
self.baseMapActor.SetOrientation( 0.0, 0.0, 0.0 )
self.baseMapActor.SetOpacity( self.map_opacity )
mapCorner = [ self.x0, self.y0 ]
self.baseMapActor.SetPosition( mapCorner[0], mapCorner[1], 0.1 )
if vtk.VTK_MAJOR_VERSION <= 5: self.baseMapActor.SetInput(self.baseImage)
else: self.baseMapActor.SetInputData(self.baseImage)
self.mapCenter = [ self.x0 + map_cut_size[0]/2.0, self.y0 + map_cut_size[1]/2.0 ]
def loadFilesWithSeriesReader(self, imageIOName, files, name):
""" Explicitly use the named imageIO to perform the loading
"""
reader = vtkITK.vtkITKArchetypeImageSeriesScalarReader()
reader.SetArchetype(files[0])
for f in files:
reader.AddFileName(slicer.util.toVTKString(f))
reader.SetSingleFile(0)
reader.SetOutputScalarTypeToNative()
reader.SetDesiredCoordinateOrientationToNative()
reader.SetUseNativeOriginOn()
if imageIOName == "GDCM":
reader.SetDICOMImageIOApproachToGDCM()
elif imageIOName == "DCMTK":
reader.SetDICOMImageIOApproachToDCMTK()
else:
raise Exception("Invalid imageIOName of %s" % imageIOName)
logging.info("Loading with imageIOName: %s" % imageIOName)
reader.Update()
slicer.modules.reader = reader
if reader.GetErrorCode() != vtk.vtkErrorCode.NoError:
errorStrings = (imageIOName,
vtk.vtkErrorCode.GetStringFromErrorCode(
reader.GetErrorCode()))
logging.error(
"Could not read scalar volume using %s approach. Error is: %s"
% errorStrings)
return
imageChangeInformation = vtk.vtkImageChangeInformation()
imageChangeInformation.SetInputConnection(reader.GetOutputPort())
imageChangeInformation.SetOutputSpacing(1, 1, 1)
imageChangeInformation.SetOutputOrigin(0, 0, 0)
imageChangeInformation.Update()
name = slicer.mrmlScene.GenerateUniqueName(
slicer.util.toVTKString(name))
volumeNode = slicer.mrmlScene.AddNewNodeByClass(
"vtkMRMLScalarVolumeNode", name)
volumeNode.SetAndObserveImageData(
imageChangeInformation.GetOutputDataObject(0))
slicer.vtkMRMLVolumeArchetypeStorageNode.SetMetaDataDictionaryFromReader(
volumeNode, reader)
volumeNode.SetRASToIJKMatrix(reader.GetRasToIjkMatrix())
volumeNode.CreateDefaultDisplayNodes()
slicer.modules.DICOMInstance.reader = reader
slicer.modules.DICOMInstance.imageChangeInformation = imageChangeInformation
return (volumeNode)
def RollMap(self, baseImage):
# baseImage.Update()
if self.world_cut == self.map_cut: return baseImage
baseExtent = baseImage.GetExtent()
baseSpacing = baseImage.GetSpacing()
x0 = baseExtent[0]
x1 = baseExtent[1]
newCut = self.NormalizeMapLon(self.world_cut)
delCut = newCut - self.map_cut
# print " %%%%%% Roll Map %%%%%%: world_cut=%.1f, map_cut=%.1f, newCut=%.1f " % ( float(self.world_cut), float(self.map_cut), float(newCut) )
imageLen = x1 - x0 + 1
sliceSize = imageLen * (delCut / 360.0)
sliceCoord = int(round(x0 + sliceSize))
extent = list(baseExtent)
extent[0:2] = [x0, x0 + sliceCoord - 1]
clip0 = vtk.vtkImageClip()
if vtk.VTK_MAJOR_VERSION <= 5: clip0.SetInput(baseImage)
else: clip0.SetInputData(baseImage)
clip0.SetOutputWholeExtent(extent[0], extent[1], extent[2], extent[3],
extent[4], extent[5])
extent[0:2] = [x0 + sliceCoord, x1]
clip1 = vtk.vtkImageClip()
if vtk.VTK_MAJOR_VERSION <= 5: clip1.SetInput(baseImage)
else: clip1.SetInputData(baseImage)
clip1.SetOutputWholeExtent(extent[0], extent[1], extent[2], extent[3],
extent[4], extent[5])
clip0.Update()
clip1.Update()
append = vtk.vtkImageAppend()
append.SetAppendAxis(0)
if vtk.VTK_MAJOR_VERSION <= 5:
append.AddInput(clip1.GetOutput())
append.AddInput(clip0.GetOutput())
else:
append.SetInputData(0, clip1.GetOutput())
append.SetInputData(1, clip0.GetOutput())
append.Update()
imageInfo = vtk.vtkImageChangeInformation()
imageInfo.SetInputConnection(append.GetOutputPort())
imageInfo.SetOutputOrigin(0.0, 0.0, 0.0)
imageInfo.SetOutputExtentStart(0, 0, 0)
imageInfo.SetOutputSpacing(baseSpacing[0], baseSpacing[1],
baseSpacing[2])
imageInfo.Update()
result = imageInfo.GetOutput()
return result
def Update(self):
# If a dummy input is defined then, probaby a diagnostic run asking
# for output data type is performed. In such case, just generate a
# blank ImageData object just to be able to determine filter's output
# data type.
if self._padding == (0, 0, 0):
self._output = self._input
return
# XXX: (note the date: Mon Mar 25 22:57:45 CET 2013)
# Ok, when we arrived here, it means that we're doing sometging
# significant.
source = self._input
self._output = vtk.vtkImageData()
padx, pady, padz = self._padding
initial_extent = self._input.GetWholeExtent()
sx, sy, sz = self._input.GetSpacing()
if __debug__:
print "\tInitial image extent: " + str(initial_extent)
print "\tInitial image origin: " + str(self._input.GetOrigin())
print "\tRequested padding: %d, %d, %d" % (padx, pady, padz)
translator = vtk.vtkImageChangeInformation()
translator.SetExtentTranslation(padx, pady, padz)
translator.SetOriginTranslation(-padx * sx, -pady * sy, -padz * sz)
translator.SetInput(source)
# Now we actually pad the image filling the extended canvas with the
# "0" value.
pad_filter = vtk.vtkImageConstantPad()
pad_filter.SetConstant(0)
pad_filter.SetOutputWholeExtent(initial_extent[0],
initial_extent[1] + 2 * padx,
initial_extent[2],
initial_extent[3] + 2 * pady,
initial_extent[4],
initial_extent[5] + 2 * padz)
pad_filter.SetInput(translator.GetOutput())
pad_filter.Update()
# Assign the resulting image to the output
self._output = pad_filter.GetOutput()
if __debug__:
print "\tFinal image extent: " + str(self._output.GetWholeExtent())
print "\tFinal image origin: " + str(self._output.GetOrigin())
def magnify_multiply_imagedata(reader, zSpacing=1.0):
logging.debug("In data.magnify_multiply_imagedata()")
imagedata = reader.GetOutput()
imagedata.UpdateInformation()
spacing = imagedata.GetSpacing()
# dimensions = imagedata.GetDimensions()
# if dimensions[0] > 256 and dimensions[1] > 256:
# spacing = [x/0.5 for x in spacing]
change = vtk.vtkImageChangeInformation()
change.SetInput(imagedata)
change.SetOutputOrigin(imagedata.GetOrigin())
change.SetOutputSpacing(spacing[0], spacing[1], zSpacing)
change.Update()
return vtk.vtkImageData.SafeDownCast(change.GetOutput())
def loadFilesWithSeriesReader(self,imageIOName,files,name):
""" Explicitly use the named imageIO to perform the loading
"""
reader = vtkITK.vtkITKArchetypeImageSeriesScalarReader()
reader.SetArchetype(files[0]);
for f in files:
reader.AddFileName(slicer.util.toVTKString(f))
reader.SetSingleFile(0);
reader.SetOutputScalarTypeToNative()
reader.SetDesiredCoordinateOrientationToNative()
reader.SetUseNativeOriginOn()
if imageIOName == "GDCM":
reader.SetDICOMImageIOApproachToGDCM()
elif imageIOName == "DCMTK":
reader.SetDICOMImageIOApproachToDCMTK()
else:
raise Exception("Invalid imageIOName of %s" % imageIOName)
logging.info("Loading with imageIOName: %s" % imageIOName)
reader.Update()
slicer.modules.reader = reader
if reader.GetErrorCode() != vtk.vtkErrorCode.NoError:
errorStrings = (imageIOName, vtk.vtkErrorCode.GetStringFromErrorCode(reader.GetErrorCode()))
logging.error("Could not read scalar volume using %s approach. Error is: %s" % errorStrings)
return
imageChangeInformation = vtk.vtkImageChangeInformation()
imageChangeInformation.SetInputConnection(reader.GetOutputPort())
imageChangeInformation.SetOutputSpacing( 1, 1, 1 )
imageChangeInformation.SetOutputOrigin( 0, 0, 0 )
imageChangeInformation.Update()
name = slicer.mrmlScene.GenerateUniqueName(slicer.util.toVTKString(name))
volumeNode = slicer.mrmlScene.AddNewNodeByClass("vtkMRMLScalarVolumeNode", name)
volumeNode.SetAndObserveImageData(imageChangeInformation.GetOutputDataObject(0))
slicer.vtkMRMLVolumeArchetypeStorageNode.SetMetaDataDictionaryFromReader(volumeNode, reader)
volumeNode.SetRASToIJKMatrix(reader.GetRasToIjkMatrix())
volumeNode.CreateDefaultDisplayNodes()
slicer.modules.DICOMInstance.reader = reader
slicer.modules.DICOMInstance.imageChangeInformation = imageChangeInformation
return(volumeNode)
def Update(self):
# If a dummy input is defined then, probaby a diagnostic run asking
# for output data type is performed. In such case, just generate a
# blank ImageData object just to be able to determine filter's output
# data type.
if self._padding == (0, 0, 0):
self._output = self._input
return
# XXX: (note the date: Mon Mar 25 22:57:45 CET 2013)
# Ok, when we arrived here, it means that we're doing sometging
# significant.
source = self._input
self._output = vtk.vtkImageData()
padx, pady, padz = self._padding
initial_extent = self._input.GetWholeExtent()
sx, sy, sz = self._input.GetSpacing()
if __debug__:
print "\tInitial image extent: " + str(initial_extent)
print "\tInitial image origin: " + str(self._input.GetOrigin())
print "\tRequested padding: %d, %d, %d" % (padx, pady, padz)
translator = vtk.vtkImageChangeInformation()
translator.SetExtentTranslation(padx, pady, padz)
translator.SetOriginTranslation(-padx*sx, -pady*sy, -padz*sz)
translator.SetInput(source)
# Now we actually pad the image filling the extended canvas with the
# "0" value.
pad_filter = vtk.vtkImageConstantPad()
pad_filter.SetConstant(0)
pad_filter.SetOutputWholeExtent(initial_extent[0], initial_extent[1]+2*padx,
initial_extent[2], initial_extent[3]+2*pady,
initial_extent[4], initial_extent[5]+2*padz)
pad_filter.SetInput(translator.GetOutput())
pad_filter.Update()
# Assign the resulting image to the output
self._output = pad_filter.GetOutput()
if __debug__:
print "\tFinal image extent: " + str(self._output.GetWholeExtent())
print "\tFinal image origin: " + str(self._output.GetOrigin())
def getTimepoint(self, n, onlyDims=0):
"""
Return the nth timepoint
"""
if not self.readers:
self.getReadersFromFilenames()
if self.is3DImage():
if not self.readers:
raise Logging.GUIError(
"Attempt to read bad timepoint",
"Timepoint %d is not defined by the given filenames" % n)
self.reader = self.readers[0]
minZ = n * self.slicesPerTimepoint
maxZ = (n + 1) * self.slicesPerTimepoint - 1
extract = vtk.vtkExtractVOI()
extract.SetInput(self.reader.GetOutput())
extract.SetVOI(0, self.x - 1, 0, self.y - 1, minZ, maxZ)
changeInfo = vtk.vtkImageChangeInformation()
changeInfo.SetInput(extract.GetOutput())
changeInfo.SetOutputOrigin(0, 0, 0)
changeInfo.SetExtentTranslation((0, 0, -minZ))
data = changeInfo.GetOutput()
else:
if n >= len(self.readers):
n = 0
raise Logging.GUIError(
"Attempt to read bad timepoint",
"Timepoint %d is not defined by the given filenames" % n)
self.reader = self.readers[n]
data = self.reader.GetOutput()
if not self.voxelsize:
size = data.GetSpacing()
x, y, z = [size.GetElement(x) for x in range(0, 3)]
self.voxelsize = (x, y, z)
print "Read voxel size", self.voxelsize
if onlyDims:
return
return data
def RollMap( self, baseImage ):
# baseImage.Update()
if self.world_cut == self.map_cut: return baseImage
baseExtent = baseImage.GetExtent()
baseSpacing = baseImage.GetSpacing()
x0 = baseExtent[0]
x1 = baseExtent[1]
newCut = self.NormalizeMapLon( self.world_cut )
delCut = newCut - self.map_cut
# print " %%%%%% Roll Map %%%%%%: world_cut=%.1f, map_cut=%.1f, newCut=%.1f " % ( float(self.world_cut), float(self.map_cut), float(newCut) )
imageLen = x1 - x0 + 1
sliceSize = imageLen * ( delCut / 360.0 )
sliceCoord = int( round( x0 + sliceSize) )
extent = list( baseExtent )
extent[0:2] = [ x0, x0 + sliceCoord - 1 ]
clip0 = vtk.vtkImageClip()
if vtk.VTK_MAJOR_VERSION <= 5: clip0.SetInput( baseImage )
else: clip0.SetInputData( baseImage )
clip0.SetOutputWholeExtent( extent[0], extent[1], extent[2], extent[3], extent[4], extent[5] )
extent[0:2] = [ x0 + sliceCoord, x1 ]
clip1 = vtk.vtkImageClip()
if vtk.VTK_MAJOR_VERSION <= 5: clip1.SetInput( baseImage )
else: clip1.SetInputData( baseImage )
clip1.SetOutputWholeExtent( extent[0], extent[1], extent[2], extent[3], extent[4], extent[5] )
append = vtk.vtkImageAppend()
append.SetAppendAxis( 0 )
append.SetInputConnection ( clip1.GetOutputPort() )
append.AddInputConnection ( clip0.GetOutputPort() )
imageInfo = vtk.vtkImageChangeInformation()
imageInfo.SetInputConnection( append.GetOutputPort() )
imageInfo.SetOutputOrigin( 0.0, 0.0, 0.0 )
imageInfo.SetOutputExtentStart( 0, 0, 0 )
imageInfo.SetOutputSpacing( baseSpacing[0], baseSpacing[1], baseSpacing[2] )
imageInfo.Update()
result = imageInfo.GetOutput()
return result
def RollMap(self, baseImage):
baseImage.Update()
if self.world_cut == self.map_cut: return baseImage
baseExtent = baseImage.GetExtent()
baseSpacing = baseImage.GetSpacing()
x0 = baseExtent[0]
x1 = baseExtent[1]
newCut = NormalizeLon(self.world_cut)
delCut = NormalizeLon(self.map_cut - newCut)
imageLen = x1 - x0 + 1
sliceSize = imageLen * (delCut / 360.0)
sliceCoord = int(round(x0 + sliceSize))
extent = list(baseExtent)
extent[0:2] = [x0, x0 + sliceCoord - 1]
clip0 = vtk.vtkImageClip()
clip0.SetInput(baseImage)
clip0.SetOutputWholeExtent(extent[0], extent[1], extent[2], extent[3],
extent[4], extent[5])
extent[0:2] = [x0 + sliceCoord, x1]
clip1 = vtk.vtkImageClip()
clip1.SetInput(baseImage)
clip1.SetOutputWholeExtent(extent[0], extent[1], extent[2], extent[3],
extent[4], extent[5])
append = vtk.vtkImageAppend()
append.SetAppendAxis(0)
append.AddInput(clip1.GetOutput())
append.AddInput(clip0.GetOutput())
imageInfo = vtk.vtkImageChangeInformation()
imageInfo.SetInputConnection(append.GetOutputPort())
imageInfo.SetOutputOrigin(0.0, 0.0, 0.0)
imageInfo.SetOutputExtentStart(0, 0, 0)
imageInfo.SetOutputSpacing(baseSpacing[0], baseSpacing[1],
baseSpacing[2])
result = imageInfo.GetOutput()
result.Update()
return result
def Execute(self):
if not self.Image:
self.PrintError('Error: no Image.')
fft = vtk.vtkImageFFT()
fft.SetInput(self.Image)
fft.SetDimensionality(self.KSpaceDimensionality)
fft.Update()
origin = self.Image.GetOrigin()
spacing = self.Image.GetSpacing()
dimensions = self.Image.GetDimensions()
kspacing = [1.0/(dimensions[0]*spacing[0]),1.0/(dimensions[1]*spacing[1]),1.0/(dimensions[2]*spacing[2])]
imageInformation = vtk.vtkImageChangeInformation()
imageInformation.SetInput(fft.GetOutput())
imageInformation.SetOutputSpacing(kspacing)
imageInformation.SetOutputOrigin(origin)
imageInformation.Update()
self.KSpace = imageInformation.GetOutput()
def getTimepoint(self, n, onlyDims = 0):
"""
Return the nth timepoint
"""
if not self.readers:
self.getReadersFromFilenames()
if self.is3DImage():
if not self.readers:
raise Logging.GUIError("Attempt to read bad timepoint", "Timepoint %d is not defined by the given filenames" % n)
self.reader = self.readers[0]
minZ = n * self.slicesPerTimepoint
maxZ = (n+1) * self.slicesPerTimepoint - 1
extract = vtk.vtkExtractVOI()
extract.SetInput(self.reader.GetOutput())
extract.SetVOI(0, self.x - 1, 0, self.y - 1, minZ, maxZ)
changeInfo = vtk.vtkImageChangeInformation()
changeInfo.SetInput(extract.GetOutput())
changeInfo.SetOutputOrigin(0, 0, 0)
changeInfo.SetExtentTranslation((0,0,-minZ))
data = changeInfo.GetOutput()
else:
if n >= len(self.readers):
n = 0
raise Logging.GUIError("Attempt to read bad timepoint", "Timepoint %d is not defined by the given filenames" % n)
self.reader = self.readers[n]
data = self.reader.GetOutput()
if not self.voxelsize:
size = data.GetSpacing()
x, y, z = [size.GetElement(x) for x in range(0, 3)]
self.voxelsize = (x, y, z)
print "Read voxel size", self.voxelsize
if onlyDims:
return
return data
def RollMap( self, baseImage ):
baseImage.Update()
if self.world_cut == self.map_cut: return baseImage
baseExtent = baseImage.GetExtent()
baseSpacing = baseImage.GetSpacing()
x0 = baseExtent[0]
x1 = baseExtent[1]
newCut = NormalizeLon( self.world_cut )
delCut = NormalizeLon( self.map_cut - newCut )
imageLen = x1 - x0 + 1
sliceSize = imageLen * ( delCut / 360.0 )
sliceCoord = int( round( x0 + sliceSize) )
extent = list( baseExtent )
extent[0:2] = [ x0, x0 + sliceCoord - 1 ]
clip0 = vtk.vtkImageClip()
clip0.SetInput( baseImage )
clip0.SetOutputWholeExtent( extent[0], extent[1], extent[2], extent[3], extent[4], extent[5] )
extent[0:2] = [ x0 + sliceCoord, x1 ]
clip1 = vtk.vtkImageClip()
clip1.SetInput( baseImage )
clip1.SetOutputWholeExtent( extent[0], extent[1], extent[2], extent[3], extent[4], extent[5] )
append = vtk.vtkImageAppend()
append.SetAppendAxis( 0 )
append.AddInput( clip1.GetOutput() )
append.AddInput( clip0.GetOutput() )
imageInfo = vtk.vtkImageChangeInformation()
imageInfo.SetInputConnection( append.GetOutputPort() )
imageInfo.SetOutputOrigin( 0.0, 0.0, 0.0 )
imageInfo.SetOutputExtentStart( 0, 0, 0 )
imageInfo.SetOutputSpacing( baseSpacing[0], baseSpacing[1], baseSpacing[2] )
result = imageInfo.GetOutput()
result.Update()
return result
def transformVolume(self, inputVolume, outputVolume, transformationMatrix):
# Normalize matrix so it preserve its scaling (diagonal elements are
# equal to 1)
M = self.__normalizeMatrix(transformationMatrix)
reader = vtk.vtkStructuredPointsReader()
reader.SetFileName(inputVolume)
reader.Update()
reader.GetOutput().UpdateInformation()
matrix = vtk.vtkMatrix4x4()
matrix.DeepCopy((
M[0,0], M[0,1], M[0,2], M[0,3],
M[1,0], M[1,1], M[1,2], M[1,3],
M[2,0], M[2,1], M[2,2], M[2,3],
M[3,0], M[3,1], M[3,2], M[3,3]
))
# Extract a slice in the desired orientation
reslice = vtk.vtkImageReslice()
reslice.SetInputConnection(reader.GetOutputPort())
reslice.SetResliceAxes(matrix)
reslice.AutoCropOutputOff()
reslice.SetInterpolationModeToNearestNeighbor()
#reslice.SetInterpolationModeToLinear()
print >>sys.stderr,'M=\n',M
ch = vtk.vtkImageChangeInformation()
ch.SetInput(reslice.GetOutput())
ch.SetOutputOrigin(*OUTPUT_VOLUME_ORIGIN)
ch.SetOutputSpacing(*OUTPUT_VOLUME_SPACING)
ch.Update()
writer = vtk.vtkStructuredPointsWriter()
writer.SetFileTypeToBinary()
writer.SetInput(ch.GetOutput())
writer.SetFileName(outputVolume)
writer.Update()
def getBoundedMap( self, baseImage, dataLocation, map_cut_size ):
baseImage.Update()
baseExtent = baseImage.GetExtent()
baseSpacing = baseImage.GetSpacing()
x0 = baseExtent[0]
x1 = baseExtent[1]
y0 = baseExtent[2]
y1 = baseExtent[3]
imageLen = [ x1 - x0 + 1, y1 - y0 + 1 ]
selectionDim = [ map_cut_size[0]/2, map_cut_size[1]/2 ]
dataXLoc = NormalizeLon( dataLocation[0] )
imageInfo = vtk.vtkImageChangeInformation()
dataYbounds = [ dataLocation[1]-selectionDim[1], dataLocation[1]+selectionDim[1] ]
vertExtent = [ y0, y1 ]
bounded_dims = None
if dataYbounds[0] > -90.0:
yOffset = dataYbounds[0] + 90.0
extOffset = int( round( ( yOffset / 180.0 ) * imageLen[1] ) )
vertExtent[0] = y0 + extOffset
self.y0 = dataYbounds[0]
if dataYbounds[1] < 90.0:
yOffset = 90.0 - dataYbounds[1]
extOffset = int( round( ( yOffset / 180.0 ) * imageLen[1] ) )
vertExtent[1] = y1 - extOffset
if (( dataXLoc > selectionDim[0] ) and ( dataXLoc < ( 360 - selectionDim[0]) )):
cut0 = dataXLoc - selectionDim[0]
sliceSize = imageLen[0] * ( cut0 / 360.0 )
sliceCoord = int( round( x0 + sliceSize) )
extent = list( baseExtent )
extent[0] = x0 + sliceCoord - 1
cut1 = dataXLoc + selectionDim[0]
sliceSize = imageLen[0] * ( cut1 / 360.0 )
sliceCoord = int( round( x0 + sliceSize) )
extent[1] = x0 + sliceCoord
clip = vtk.vtkImageClip()
clip.SetInput( baseImage )
clip.SetOutputWholeExtent( extent[0], extent[1], vertExtent[0], vertExtent[1], extent[4], extent[5] )
self.x0 = cut0
bounded_dims = ( extent[1] - extent[0] + 1, vertExtent[1] - vertExtent[0] + 1 )
imageInfo.SetInputConnection( clip.GetOutputPort() )
else:
cut0 = NormalizeLon( dataXLoc + selectionDim[0] )
sliceSize = imageLen[0] * ( cut0 / 360.0 )
sliceCoord = int( round( x0 + sliceSize) )
extent = list( baseExtent )
extent[0:2] = [ x0, x0 + sliceCoord - 1 ]
clip0 = vtk.vtkImageClip()
clip0.SetInput( baseImage )
clip0.SetOutputWholeExtent( extent[0], extent[1], vertExtent[0], vertExtent[1], extent[4], extent[5] )
size0 = extent[1] - extent[0] + 1
cut1 = NormalizeLon( dataLocation[0] - selectionDim[0] )
sliceSize = imageLen[0] * ( cut1 / 360.0 )
sliceCoord = int( round( x0 + sliceSize) )
extent[0:2] = [ x0 + sliceCoord, x1 ]
clip1 = vtk.vtkImageClip()
clip1.SetInput( baseImage )
clip1.SetOutputWholeExtent( extent[0], extent[1], vertExtent[0], vertExtent[1], extent[4], extent[5] )
size1 = extent[1] - extent[0] + 1
self.x0 = cut1
append = vtk.vtkImageAppend()
append.SetAppendAxis( 0 )
append.AddInput( clip1.GetOutput() )
append.AddInput( clip0.GetOutput() )
bounded_dims = ( size0 + size1, vertExtent[1] - vertExtent[0] + 1 )
imageInfo.SetInputConnection( append.GetOutputPort() )
imageInfo.SetOutputOrigin( 0.0, 0.0, 0.0 )
imageInfo.SetOutputExtentStart( 0, 0, 0 )
imageInfo.SetOutputSpacing( baseSpacing[0], baseSpacing[1], baseSpacing[2] )
result = imageInfo.GetOutput()
result.Update()
return result, bounded_dims
import vtk from vtk.test import Testing from vtk.util.misc import vtkGetDataRoot VTK_DATA_ROOT = vtkGetDataRoot() # Simple volume rendering example. reader = vtk.vtkImageReader() reader.SetDataByteOrderToLittleEndian() reader.SetDataExtent(0, 63, 0, 63, 1, 93) reader.SetFilePrefix(VTK_DATA_ROOT + "/Data/headsq/quarter") reader.SetDataMask(0x7fff) reader.SetDataSpacing(2, 2, 1) reader.SetDataScalarTypeToUnsignedShort() reader.Update() changeFilter = vtk.vtkImageChangeInformation() changeFilter.SetInputConnection(reader.GetOutputPort()) changeFilter.SetOutputOrigin(-63, -63, -46) # Create transfer functions for opacity and color opacityTransferFunction = vtk.vtkPiecewiseFunction() opacityTransferFunction.AddPoint(600, 0.0) opacityTransferFunction.AddPoint(2000, 1.0) colorTransferFunction = vtk.vtkColorTransferFunction() colorTransferFunction.ClampingOff() colorTransferFunction.AddHSVPoint(0.0, 0.01, 1.0, 1.0) colorTransferFunction.AddHSVPoint(1000.0, 0.50, 1.0, 1.0) colorTransferFunction.AddHSVPoint(2000.0, 0.99, 1.0, 1.0) colorTransferFunction.SetColorSpaceToHSV()
def apply(self, segmentMarkupNode, segmentModel, text, textDepth, mode):
self.updateModel(segmentMarkupNode, segmentModel, text, textDepth)
import vtkSegmentationCore
if not segmentMarkupNode:
raise AttributeError(f"{self.__class__.__name__}: segment markup node not set.")
if not segmentModel:
raise AttributeError(f"{self.__class__.__name__}: segment model not set.")
if segmentMarkupNode and segmentModel.GetPolyData().GetNumberOfCells() > 0:
segmentationNode = self.scriptedEffect.parameterSetNode().GetSegmentationNode()
if not segmentationNode:
raise AttributeError(f"{self.__class__.__name__}: Segmentation node not set.")
modifierLabelmap = self.scriptedEffect.defaultModifierLabelmap()
if not modifierLabelmap:
raise AttributeError("{}: ModifierLabelmap not set. This can happen for various reasons:\n"
"No master volume set for segmentation,\n"
"No existing segments for segmentation, or\n"
"No referenceImageGeometry is specified in the segmentation".format(self.__class__.__name__))
WorldToModifierLabelmapIjkTransform = vtk.vtkTransform()
WorldToModifierLabelmapIjkTransformer = vtk.vtkTransformPolyDataFilter()
WorldToModifierLabelmapIjkTransformer.SetTransform(WorldToModifierLabelmapIjkTransform)
WorldToModifierLabelmapIjkTransformer.SetInputConnection(segmentModel.GetPolyDataConnection())
segmentationToSegmentationIjkTransformMatrix = vtk.vtkMatrix4x4()
modifierLabelmap.GetImageToWorldMatrix(segmentationToSegmentationIjkTransformMatrix)
segmentationToSegmentationIjkTransformMatrix.Invert()
WorldToModifierLabelmapIjkTransform.Concatenate(segmentationToSegmentationIjkTransformMatrix)
worldToSegmentationTransformMatrix = vtk.vtkMatrix4x4()
slicer.vtkMRMLTransformNode.GetMatrixTransformBetweenNodes(None, segmentationNode.GetParentTransformNode(),
worldToSegmentationTransformMatrix)
WorldToModifierLabelmapIjkTransform.Concatenate(worldToSegmentationTransformMatrix)
WorldToModifierLabelmapIjkTransformer.Update()
polyToStencil = vtk.vtkPolyDataToImageStencil()
polyToStencil.SetOutputSpacing(1.0, 1.0, 1.0)
polyToStencil.SetInputConnection(WorldToModifierLabelmapIjkTransformer.GetOutputPort())
boundsIjk = WorldToModifierLabelmapIjkTransformer.GetOutput().GetBounds()
modifierLabelmapExtent = self.scriptedEffect.modifierLabelmap().GetExtent()
polyToStencil.SetOutputWholeExtent(modifierLabelmapExtent[0], modifierLabelmapExtent[1],
modifierLabelmapExtent[2], modifierLabelmapExtent[3],
int(round(boundsIjk[4])), int(round(boundsIjk[5])))
polyToStencil.Update()
stencilData = polyToStencil.GetOutput()
stencilExtent = [0, -1, 0, -1, 0, -1]
stencilData.SetExtent(stencilExtent)
stencilToImage = vtk.vtkImageStencilToImage()
stencilToImage.SetInputConnection(polyToStencil.GetOutputPort())
stencilToImage.SetInsideValue(1.0)
stencilToImage.SetOutsideValue(0.0)
stencilToImage.SetOutputScalarType(modifierLabelmap.GetScalarType())
stencilPositioner = vtk.vtkImageChangeInformation()
stencilPositioner.SetInputConnection(stencilToImage.GetOutputPort())
stencilPositioner.SetOutputSpacing(modifierLabelmap.GetSpacing())
stencilPositioner.SetOutputOrigin(modifierLabelmap.GetOrigin())
stencilPositioner.Update()
orientedStencilPositionerOutput = vtkSegmentationCore.vtkOrientedImageData()
orientedStencilPositionerOutput.ShallowCopy(stencilToImage.GetOutput())
imageToWorld = vtk.vtkMatrix4x4()
modifierLabelmap.GetImageToWorldMatrix(imageToWorld)
orientedStencilPositionerOutput.SetImageToWorldMatrix(imageToWorld)
vtkSegmentationCore.vtkOrientedImageDataResample.ModifyImage(
modifierLabelmap, orientedStencilPositionerOutput,
vtkSegmentationCore.vtkOrientedImageDataResample.OPERATION_MAXIMUM)
modeName = self.scriptedEffect.parameter("Mode")
if modeName == "EMBOSS":
mode = slicer.qSlicerSegmentEditorAbstractEffect.ModificationModeAdd
elif modeName == "ENGRAVE":
mode = slicer.qSlicerSegmentEditorAbstractEffect.ModificationModeRemove
else:
logging.error("Invalid mode: "+modeName+" (valid modes: EMBOSS, ENGRAVE)")
self.scriptedEffect.modifySelectedSegmentByLabelmap(modifierLabelmap, mode)
# get plane parameters as space-separated string list
planeParameters = []
if segmentMarkupNode.GetIsPlaneValid():
planeParameters.extend(segmentMarkupNode.GetOriginWorld())
xAxis = [1, 0, 0]
yAxis = [0, 1, 0]
zAxis = [0, 0, 1]
segmentMarkupNode.GetAxesWorld(xAxis, yAxis, zAxis)
planeParameters.extend(xAxis)
planeParameters.extend(yAxis)
planeParameters.extend(zAxis)
planeParameters.extend(segmentMarkupNode.GetPlaneBounds())
planeParametersString = ' '.join(map(str, planeParameters))
segmentID = self.scriptedEffect.parameterSetNode().GetSelectedSegmentID()
segment = segmentationNode.GetSegmentation().GetSegment(segmentID)
segment.SetTag("EngraveEffectPlaneParameters", planeParametersString)
def smoothMultipleSegments(self):
import vtkSegmentationCorePython as vtkSegmentationCore
# Generate merged labelmap of all visible segments
segmentationNode = self.scriptedEffect.parameterSetNode().GetSegmentationNode()
visibleSegmentIds = vtk.vtkStringArray()
segmentationNode.GetDisplayNode().GetVisibleSegmentIDs(visibleSegmentIds)
if visibleSegmentIds.GetNumberOfValues() == 0:
logging.info("Smoothing operation skipped: there are no visible segments")
return
mergedImage = vtkSegmentationCore.vtkOrientedImageData()
if not segmentationNode.GenerateMergedLabelmapForAllSegments(mergedImage,
vtkSegmentationCore.vtkSegmentation.EXTENT_UNION_OF_SEGMENTS_PADDED,
None, visibleSegmentIds):
logging.error('Failed to apply smoothing: cannot get list of visible segments')
return
segmentLabelValues = [] # list of [segmentId, labelValue]
for i in range(visibleSegmentIds.GetNumberOfValues()):
segmentId = visibleSegmentIds.GetValue(i)
segmentLabelValues.append([segmentId, i+1])
# Perform smoothing in voxel space
ici = vtk.vtkImageChangeInformation()
ici.SetInputData(mergedImage)
ici.SetOutputSpacing(1, 1, 1)
ici.SetOutputOrigin(0, 0, 0)
# Convert labelmap to combined polydata
# vtkDiscreteFlyingEdges3D cannot be used here, as in the output of that filter,
# each labeled region is completely disconnected from neighboring regions, and
# for joint smoothing it is essential for the points to move together.
convertToPolyData = vtk.vtkDiscreteMarchingCubes()
convertToPolyData.SetInputConnection(ici.GetOutputPort())
convertToPolyData.SetNumberOfContours(len(segmentLabelValues))
contourIndex = 0
for segmentId, labelValue in segmentLabelValues:
convertToPolyData.SetValue(contourIndex, labelValue)
contourIndex += 1
# Low-pass filtering using Taubin's method
smoothingFactor = self.scriptedEffect.doubleParameter("JointTaubinSmoothingFactor")
smoothingIterations = 100 # according to VTK documentation 10-20 iterations could be enough but we use a higher value to reduce chance of shrinking
passBand = pow(10.0, -4.0*smoothingFactor) # gives a nice range of 1-0.0001 from a user input of 0-1
smoother = vtk.vtkWindowedSincPolyDataFilter()
smoother.SetInputConnection(convertToPolyData.GetOutputPort())
smoother.SetNumberOfIterations(smoothingIterations)
smoother.BoundarySmoothingOff()
smoother.FeatureEdgeSmoothingOff()
smoother.SetFeatureAngle(90.0)
smoother.SetPassBand(passBand)
smoother.NonManifoldSmoothingOn()
smoother.NormalizeCoordinatesOn()
# Extract a label
threshold = vtk.vtkThreshold()
threshold.SetInputConnection(smoother.GetOutputPort())
# Convert to polydata
geometryFilter = vtk.vtkGeometryFilter()
geometryFilter.SetInputConnection(threshold.GetOutputPort())
# Convert polydata to stencil
polyDataToImageStencil = vtk.vtkPolyDataToImageStencil()
polyDataToImageStencil.SetInputConnection(geometryFilter.GetOutputPort())
polyDataToImageStencil.SetOutputSpacing(1,1,1)
polyDataToImageStencil.SetOutputOrigin(0,0,0)
polyDataToImageStencil.SetOutputWholeExtent(mergedImage.GetExtent())
# Convert stencil to image
stencil = vtk.vtkImageStencil()
emptyBinaryLabelMap = vtk.vtkImageData()
emptyBinaryLabelMap.SetExtent(mergedImage.GetExtent())
emptyBinaryLabelMap.AllocateScalars(vtk.VTK_UNSIGNED_CHAR, 1)
vtkSegmentationCore.vtkOrientedImageDataResample.FillImage(emptyBinaryLabelMap, 0)
stencil.SetInputData(emptyBinaryLabelMap)
stencil.SetStencilConnection(polyDataToImageStencil.GetOutputPort())
stencil.ReverseStencilOn()
stencil.SetBackgroundValue(1) # General foreground value is 1 (background value because of reverse stencil)
imageToWorldMatrix = vtk.vtkMatrix4x4()
mergedImage.GetImageToWorldMatrix(imageToWorldMatrix)
for segmentId, labelValue in segmentLabelValues:
threshold.ThresholdBetween(labelValue, labelValue)
stencil.Update()
smoothedBinaryLabelMap = vtkSegmentationCore.vtkOrientedImageData()
smoothedBinaryLabelMap.ShallowCopy(stencil.GetOutput())
smoothedBinaryLabelMap.SetImageToWorldMatrix(imageToWorldMatrix)
# Write results to segments directly, bypassing masking
slicer.vtkSlicerSegmentationsModuleLogic.SetBinaryLabelmapToSegment(smoothedBinaryLabelMap,
segmentationNode, segmentId, slicer.vtkSlicerSegmentationsModuleLogic.MODE_REPLACE, smoothedBinaryLabelMap.GetExtent())
#!/usr/bin/env python
import vtk
from vtk.test import Testing
from vtk.util.misc import vtkGetDataRoot
VTK_DATA_ROOT = vtkGetDataRoot()
# In this example, an image is centered at (0,0,0) before a
# rotation is applied to ensure that the rotation occurs about
# the center of the image.
reader = vtk.vtkPNGReader()
reader.SetDataSpacing(0.8,0.8,1.5)
reader.SetFileName("" + str(VTK_DATA_ROOT) + "/Data/fullhead15.png")
reader.Update()
# first center the image at (0,0,0)
reslice = vtk.vtkImageReslice()
reslice.SetResliceAxesDirectionCosines([0,1,0,-1,0,0,0,0,1])
reslice.SetInputConnection(reader.GetOutputPort())
reslice.SetInformationInput(reader.GetOutput())
# reset the image back to the way it was (you don't have
# to do this, it is just put in as an example)
information2 = vtk.vtkImageChangeInformation()
information2.SetInputConnection(reslice.GetOutputPort())
information2.SetInformationInputData(reader.GetOutput())
viewer = vtk.vtkImageViewer()
viewer.SetInputConnection(information2.GetOutputPort())
viewer.SetColorWindow(2000)
viewer.SetColorLevel(1000)
viewer.Render()
# --- end of script --
def loadTifImage(filename):
step = 1.0
import os, os.path
dir = os.path.split(filename)[0]
name = os.path.split(filename)[1]
for file in os.listdir(dir):
if os.path.splitext(file)[1] == '.log':
logfile = file
break
print 'logfile', dir + '/' + logfile
inFile = open(dir + '/' + logfile, 'r')
line = inFile.readline().split()
eof = False
while not eof:
if len(line) == 0:
line = inFile.readline().split()
if len(line) == 0:
eof = True
if (len(line) == 4) and line[0] == 'Result' and line[
1] == 'Image' and line[2] == 'Width':
resultimagewidth = line[3]
if (len(line) == 4) and line[0] == 'Result' and line[
1] == 'Image' and line[2] == 'Height':
resultimageheight = line[3]
if (len(line) == 3) and line[0] == 'Pixel' and line[1] == 'Size':
pixelsize = line[2]
line = inFile.readline().split()
resultimagewidth = int(resultimagewidth.partition('=')[2])
resultimageheight = int(resultimageheight.partition('=')[2])
spacing = float(pixelsize.partition('=')[2])
if pixelsize.partition('=')[0] == '(um)':
spacing = spacing * 0.001
names = os.listdir(dir)
nboffiles = len(names) - 2
nameonly = os.path.splitext(name)[0]
fileprefix = os.path.join(dir, nameonly.rpartition('_')[0] + '_')
reader = vtk.vtkTIFFReader()
reader.SetFileDimensionality(2)
reader.SetNumberOfScalarComponents(1)
print 'spacing: ', spacing, spacing, spacing * step
print 'dimensions: ', resultimagewidth, resultimageheight, nboffiles
print 'extent: ', 0, resultimagewidth - 1, 0, resultimageheight - 1, 0, nboffiles - 1
print 'bounds: ', 0, resultimagewidth * spacing, 0, resultimageheight * spacing, 0, nboffiles * spacing * step
reader.SetFilePrefix(fileprefix)
if len(nameonly.rpartition('_')[2]) == 2:
reader.SetFilePattern("%s%02d.tif")
elif len(nameonly.rpartition('_')[2]) == 3:
reader.SetFilePattern("%s%03d.tif")
reader.SetDataSpacing(
1.0, 1.0, step
) # bizarre: si je mets (spacing,spacing,spacing*step) et remplace par (1.0,1.0,spacing*step) -> vtkImageChangeInformation
reader.SetDataExtent(0, resultimagewidth - 1, 0, resultimageheight - 1, 0,
nboffiles - 1)
reader.Update()
rescale = vtk.vtkImageChangeInformation()
rescale.SetInput(reader.GetOutput())
rescale.SetOutputOrigin(0.0, 0.0, 0.0)
rescale.SetSpacingScale(spacing, spacing, spacing)
rescale.Update()
return rescale.GetOutput()
def onApply(self):
import vtkSegmentationCorePython as vtkSegmentationCore
# Allow users revert to this state by clicking Undo
self.scriptedEffect.saveStateForUndo()
# This can be a long operation - indicate it to the user
qt.QApplication.setOverrideCursor(qt.Qt.WaitCursor)
if self.segmentMarkupNode and (
self.segmentModel.GetPolyData().GetNumberOfPolys() > 0):
self.observeSegmentation(False)
operationName = self.scriptedEffect.parameter("Operation")
modifierLabelmap = self.scriptedEffect.defaultModifierLabelmap()
segmentationNode = self.scriptedEffect.parameterSetNode(
).GetSegmentationNode()
WorldToModifierLabelmapIjkTransform = vtk.vtkTransform()
WorldToModifierLabelmapIjkTransformer = vtk.vtkTransformPolyDataFilter(
)
WorldToModifierLabelmapIjkTransformer.SetTransform(
WorldToModifierLabelmapIjkTransform)
WorldToModifierLabelmapIjkTransformer.SetInputConnection(
self.segmentModel.GetPolyDataConnection())
segmentationToSegmentationIjkTransformMatrix = vtk.vtkMatrix4x4()
modifierLabelmap.GetImageToWorldMatrix(
segmentationToSegmentationIjkTransformMatrix)
segmentationToSegmentationIjkTransformMatrix.Invert()
WorldToModifierLabelmapIjkTransform.Concatenate(
segmentationToSegmentationIjkTransformMatrix)
worldToSegmentationTransformMatrix = vtk.vtkMatrix4x4()
slicer.vtkMRMLTransformNode.GetMatrixTransformBetweenNodes(
None, segmentationNode.GetParentTransformNode(),
worldToSegmentationTransformMatrix)
WorldToModifierLabelmapIjkTransform.Concatenate(
worldToSegmentationTransformMatrix)
WorldToModifierLabelmapIjkTransformer.Update()
polyToStencil = vtk.vtkPolyDataToImageStencil()
polyToStencil.SetOutputSpacing(1.0, 1.0, 1.0)
polyToStencil.SetInputConnection(
WorldToModifierLabelmapIjkTransformer.GetOutputPort())
boundsIjk = WorldToModifierLabelmapIjkTransformer.GetOutput(
).GetBounds()
modifierLabelmapExtent = self.scriptedEffect.modifierLabelmap(
).GetExtent()
polyToStencil.SetOutputWholeExtent(modifierLabelmapExtent[0],
modifierLabelmapExtent[1],
modifierLabelmapExtent[2],
modifierLabelmapExtent[3],
int(round(boundsIjk[4])),
int(round(boundsIjk[5])))
polyToStencil.Update()
stencilData = polyToStencil.GetOutput()
stencilExtent = [0, -1, 0, -1, 0, -1]
stencilData.SetExtent(stencilExtent)
stencilToImage = vtk.vtkImageStencilToImage()
stencilToImage.SetInputConnection(polyToStencil.GetOutputPort())
if operationName in ("FILL_INSIDE", "ERASE_INSIDE", "SET"):
stencilToImage.SetInsideValue(1.0)
stencilToImage.SetOutsideValue(0.0)
else:
stencilToImage.SetInsideValue(0.0)
stencilToImage.SetOutsideValue(1.0)
stencilToImage.SetOutputScalarType(
modifierLabelmap.GetScalarType())
stencilPositioner = vtk.vtkImageChangeInformation()
stencilPositioner.SetInputConnection(
stencilToImage.GetOutputPort())
stencilPositioner.SetOutputSpacing(modifierLabelmap.GetSpacing())
stencilPositioner.SetOutputOrigin(modifierLabelmap.GetOrigin())
stencilPositioner.Update()
orientedStencilPositionerOuput = vtkSegmentationCore.vtkOrientedImageData(
)
orientedStencilPositionerOuput.ShallowCopy(
stencilToImage.GetOutput())
imageToWorld = vtk.vtkMatrix4x4()
modifierLabelmap.GetImageToWorldMatrix(imageToWorld)
orientedStencilPositionerOuput.SetImageToWorldMatrix(imageToWorld)
vtkSegmentationCore.vtkOrientedImageDataResample.ModifyImage(
modifierLabelmap, orientedStencilPositionerOuput,
vtkSegmentationCore.vtkOrientedImageDataResample.
OPERATION_MAXIMUM)
modMode = slicer.qSlicerSegmentEditorAbstractEffect.ModificationModeAdd
if operationName == "ERASE_INSIDE" or operationName == "ERASE_OUTSIDE":
modMode = slicer.qSlicerSegmentEditorAbstractEffect.ModificationModeRemove
elif operationName == "SET":
modMode = slicer.qSlicerSegmentEditorAbstractEffect.ModificationModeSet
self.scriptedEffect.modifySelectedSegmentByLabelmap(
modifierLabelmap, modMode)
import numpy
n = self.segmentMarkupNode.GetNumberOfFiducials()
# get fiducial positions
fPos = numpy.zeros((n, 3))
for i in xrange(n):
coord = [0.0, 0.0, 0.0]
self.segmentMarkupNode.GetNthFiducialPosition(i, coord)
fPos[i] = coord
segmentID = self.scriptedEffect.parameterSetNode(
).GetSelectedSegmentID()
segment = segmentationNode.GetSegmentation().GetSegment(segmentID)
segment.SetTag("fP", fPos.tostring())
segment.SetTag("fN", n)
self.reset()
self.createNewMarkupNode()
self.fiducialPlacementToggle.setCurrentNode(self.segmentMarkupNode)
self.observeSegmentation(True)
qt.QApplication.restoreOverrideCursor()
def addT2transvisualize(self, T2images, image_pos_pat, image_ori_pat, T2dims, T2spacing, interact):
'''Added to build second reference frame and display T2 overlayed into T1 reference frame'''
# Proceed to build reference frame for display objects based on DICOM coords
[transformed_T2image, transform_cube] = self.dicomTransform(T2images, image_pos_pat, image_ori_pat)
self.T2origin = list(transformed_T2image.GetOrigin())
print "T2 Extent"
self.T2extent = list(transformed_T2image.GetExtent())
print self.T2extent
alignR = int(raw_input('\nAlign right? Yes:1 or align with T1w: !=1 : '))
if alignR:
zf1 = self.T1spacing[2]*self.T1extent[5] + self.T1origin[2]
self.T2origin[2] = zf1 - T2spacing[2]*self.T2extent[5] # this is z-span
else:
self.T2origin[2] = self.T1origin[2]
# Change info origin
transformedInfo_T2image = vtk.vtkImageChangeInformation()
transformedInfo_T2image.SetInputData( transformed_T2image )
transformedInfo_T2image.SetOutputOrigin(self.T2origin)
transformedInfo_T2image.Update()
self.transformed_T2image = transformedInfo_T2image.GetOutput()
# Set up ortogonal planes
self.xImagePlaneWidget.SetInputData( self.transformed_T2image )
self.xImagePlaneWidget.SetSliceIndex(0)
self.yImagePlaneWidget.SetInputData( self.transformed_T2image )
self.yImagePlaneWidget.SetSliceIndex(0)
self.zImagePlaneWidget.SetInputData( self.transformed_T2image )
self.zImagePlaneWidget.SetSliceIndex(0)
# Create a text property for both cube axes
tprop = vtk.vtkTextProperty()
tprop.SetColor(0.5, 0.5, 0)
tprop.ShadowOff()
# Update the reneder window to receive new image !Important*****
self.renderer1.Modified()
self.renWin1.Modified()
# Create a vtkCubeAxesActor2D. Use the outer edges of the bounding box to
# draw the axes. Add the actor to the renderer.
axesT2 = vtk.vtkCubeAxesActor2D()
axesT2.SetInputData(self.transformed_T2image)
axesT2.SetCamera(self.renderer1.GetActiveCamera())
axesT2.SetLabelFormat("%6.4g")
axesT2.SetFlyModeToOuterEdges()
axesT2.SetFontFactor(1.2)
axesT2.SetAxisTitleTextProperty(tprop)
axesT2.SetAxisLabelTextProperty(tprop)
self.renderer1.AddViewProp(axesT2)
### Update T2Images
t_T2images = vtk.vtkImageChangeInformation()
t_T2images.SetInputData( T2images )
t_T2images.SetOutputOrigin(self.T2origin)
t_T2images.Update()
############
if(interact==True):
interactor = self.renWin1.GetInteractor()
interactor.Start()
return
def getBoundedMap( self, baseImage, dataLocation ):
# print " @@@ MapManager: getBoundedMap "
baseExtent = baseImage.GetExtent()
baseSpacing = baseImage.GetSpacing()
x0 = baseExtent[0]
x1 = baseExtent[1]
y0 = baseExtent[2]
y1 = baseExtent[3]
imageLen = [ x1 - x0 + 1, y1 - y0 + 1 ]
selectionDim = [ self.map_cut_size[0]/2, self.map_cut_size[1]/2 ]
dataXLoc = dataLocation[0]
imageInfo = vtk.vtkImageChangeInformation()
dataYbounds = [ dataLocation[1]-selectionDim[1], dataLocation[1]+selectionDim[1] ]
vertExtent = [ y0, y1 ]
bounded_dims = None
if dataYbounds[0] > -90.0:
yOffset = dataYbounds[0] + 90.0
extOffset = int( round( ( yOffset / 180.0 ) * imageLen[1] ) )
vertExtent[0] = y0 + extOffset
self.y0 = dataYbounds[0]
if dataYbounds[1] < 90.0:
yOffset = 90.0 - dataYbounds[1]
extOffset = int( round( ( yOffset / 180.0 ) * imageLen[1] ) )
vertExtent[1] = y1 - extOffset
overlapsBorder = ( self.NormalizeMapLon(dataLocation[0]-selectionDim[0]) > self.NormalizeMapLon(dataLocation[0]+selectionDim[0]) )
if overlapsBorder:
cut0 = self.NormalizeMapLon( dataXLoc + selectionDim[0] )
sliceSize = imageLen[0] * ( ( cut0 - self.map_cut ) / 360.0 )
sliceCoord = int( round( x0 + sliceSize) )
extent = list( baseExtent )
extent[0:2] = [ x0, x0 + sliceCoord - 1 ]
clip0 = vtk.vtkImageClip()
clip0.ClipDataOn()
clip0.SetInput( baseImage )
clip0.SetOutputWholeExtent( extent[0], extent[1], vertExtent[0], vertExtent[1], extent[4], extent[5] )
size0 = extent[1] - extent[0] + 1
self.x0 = dataLocation[0] - selectionDim[0]
cut1 = self.NormalizeMapLon( self.x0 )
sliceSize = imageLen[0] * ( ( cut1 - self.map_cut )/ 360.0 )
sliceCoord = int( round( x0 + sliceSize) )
extent[0:2] = [ x0 + sliceCoord, x1 ]
clip1 = vtk.vtkImageClip()
clip1.ClipDataOn()
if vtk.VTK_MAJOR_VERSION <= 5: clip1.SetInput( baseImage )
else: clip1.SetInputData( baseImage )
clip1.SetOutputWholeExtent( extent[0], extent[1], vertExtent[0], vertExtent[1], extent[4], extent[5] )
size1 = extent[1] - extent[0] + 1
# print "Set Corner pos: %s, cuts: %s " % ( str(self.x0), str( (cut0, cut1) ) )
append = vtk.vtkImageAppend()
append.SetAppendAxis( 0 )
append.AddInputConnection( clip1.GetOutputPort() )
append.AddInputConnection( clip0.GetOutputPort() )
bounded_dims = ( size0 + size1, vertExtent[1] - vertExtent[0] + 1 )
imageInfo.SetInputConnection( append.GetOutputPort() )
else:
self.x0 = dataXLoc - selectionDim[0]
cut0 = self.NormalizeMapLon( self.x0 )
sliceSize = imageLen[0] * ( ( cut0 - self.map_cut ) / 360.0 )
sliceCoord = int( round( x0 + sliceSize) )
extent = list( baseExtent )
extent[0] = x0 + sliceCoord - 1
cut1 = self.NormalizeMapLon( dataXLoc + selectionDim[0] )
sliceSize = imageLen[0] * ( ( cut1 - self.map_cut ) / 360.0 )
sliceCoord = int( round( x0 + sliceSize) )
extent[1] = x0 + sliceCoord
clip = vtk.vtkImageClip()
clip.ClipDataOn()
if vtk.VTK_MAJOR_VERSION <= 5: clip.SetInput( baseImage )
else: clip.SetInputData( baseImage )
clip.SetOutputWholeExtent( extent[0], extent[1], vertExtent[0], vertExtent[1], extent[4], extent[5] )
bounded_dims = ( extent[1] - extent[0] + 1, vertExtent[1] - vertExtent[0] + 1 )
# print "Set Corner pos: %s, dataXLoc: %s " % ( str(self.x0), str( (dataXLoc, selectionDim[0]) ) )
clip.Update()
imageInfo.SetInputConnection( clip.GetOutputPort() )
imageInfo.SetOutputOrigin( 0.0, 0.0, 0.0 )
imageInfo.SetOutputExtentStart( 0, 0, 0 )
imageInfo.SetOutputSpacing( baseSpacing[0], baseSpacing[1], baseSpacing[2] )
imageInfo.Update()
result = imageInfo.GetOutput()
return result, bounded_dims
#!/usr/bin/env python
import vtk
from vtk.util.misc import vtkGetDataRoot
VTK_DATA_ROOT = vtkGetDataRoot()
# Image pipeline
reader = vtk.vtkPNGReader()
reader.SetFileName("" + str(VTK_DATA_ROOT) + "/Data/fullhead15.png")
clip = vtk.vtkImageClip()
clip.SetInputConnection(reader.GetOutputPort())
clip.SetOutputWholeExtent(80, 230, 80, 230, 0, 0)
clip.ClipDataOff()
gradient = vtk.vtkImageGradientMagnitude()
gradient.SetDimensionality(2)
gradient.SetInputConnection(clip.GetOutputPort())
gradient.HandleBoundariesOff()
slide = vtk.vtkImageChangeInformation()
slide.SetInputConnection(gradient.GetOutputPort())
slide.SetExtentTranslation(-100, -100, 0)
viewer = vtk.vtkImageViewer()
viewer.SetInputConnection(slide.GetOutputPort())
viewer.SetColorWindow(-1000)
viewer.SetColorLevel(500)
viewer.Render()
#skipping source
# --- end of script --
def buildBaseMap(self):
if self.baseMapActor <> None:
self.renderer.RemoveActor(self.baseMapActor)
world_map = None
map_border_size = 20
self.y0 = -90.0
self.x0 = 0.0
dataPosition = None
if world_map == None:
self.map_file = defaultMapFile
self.map_cut = defaultMapCut
else:
self.map_file = world_map[0].name
self.map_cut = world_map[1]
self.world_cut = -1
if (self.roi <> None):
roi_size = [self.roi[1] - self.roi[0], self.roi[3] - self.roi[2]]
map_cut_size = [
roi_size[0] + 2 * map_border_size,
roi_size[1] + 2 * map_border_size
]
if map_cut_size[0] > 360.0: map_cut_size[0] = 360.0
if map_cut_size[1] > 180.0: map_cut_size[1] = 180.0
else:
map_cut_size = [360, 180]
if self.world_cut == -1:
if (self.roi <> None):
if roi_size[0] > 180:
self.ComputeCornerPosition()
self.world_cut = self.NormalizeMapLon(self.x0)
else:
dataPosition = [(self.roi[1] + self.roi[0]) / 2.0,
(self.roi[3] + self.roi[2]) / 2.0]
else:
dataPosition = [
180, 0
] # [ ( self.roi[1] + self.roi[0] ) / 2.0, ( self.roi[3] + self.roi[2] ) / 2.0 ]
else:
self.world_cut = self.map_cut
self.imageInfo = vtk.vtkImageChangeInformation()
image_reader = vtk.vtkJPEGReader()
image_reader.SetFileName(self.map_file)
image_reader.Update()
baseImage = image_reader.GetOutput()
new_dims, scale = None, None
if dataPosition == None:
old_dims = baseImage.GetDimensions()
baseImage = self.RollMap(baseImage)
new_dims = baseImage.GetDimensions()
scale = [360.0 / new_dims[0], 180.0 / new_dims[1], 1]
else:
baseImage, new_dims = self.getBoundedMap(baseImage, dataPosition,
map_cut_size,
map_border_size)
scale = [
map_cut_size[0] / new_dims[0], map_cut_size[1] / new_dims[1], 1
]
self.baseMapActor = vtk.vtkImageActor()
self.baseMapActor.SetOrigin(0.0, 0.0, 0.0)
self.baseMapActor.SetScale(scale)
self.baseMapActor.SetOrientation(0.0, 0.0, 0.0)
self.baseMapActor.SetOpacity(self.map_opacity[0])
mapCorner = [self.x0, self.y0]
self.baseMapActor.SetPosition(mapCorner[0], mapCorner[1], 0.1)
if vtk.VTK_MAJOR_VERSION <= 5: self.baseMapActor.SetInput(baseImage)
else: self.baseMapActor.SetInputData(baseImage)
self.mapCenter = [
self.x0 + map_cut_size[0] / 2.0, self.y0 + map_cut_size[1] / 2.0
]
self.renderer.AddActor(self.baseMapActor)
#!/usr/bin/env python
import vtk
from vtk.test import Testing
from vtk.util.misc import vtkGetDataRoot
VTK_DATA_ROOT = vtkGetDataRoot()
# Image pipeline
reader = vtk.vtkPNGReader()
reader.SetFileName("" + str(VTK_DATA_ROOT) + "/Data/fullhead15.png")
clip = vtk.vtkImageClip()
clip.SetInputConnection(reader.GetOutputPort())
clip.SetOutputWholeExtent(80,230,80,230,0,0)
clip.ClipDataOff()
gradient = vtk.vtkImageGradientMagnitude()
gradient.SetDimensionality(2)
gradient.SetInputConnection(clip.GetOutputPort())
gradient.HandleBoundariesOff()
slide = vtk.vtkImageChangeInformation()
slide.SetInputConnection(gradient.GetOutputPort())
slide.SetExtentTranslation(-100,-100,0)
viewer = vtk.vtkImageViewer()
viewer.SetInputConnection(slide.GetOutputPort())
viewer.SetColorWindow(-1000)
viewer.SetColorLevel(500)
viewer.Render()
#skipping source
# --- end of script --
import vtk from vtk.test import Testing from vtk.util.misc import vtkGetDataRoot VTK_DATA_ROOT = vtkGetDataRoot() # Simple volume rendering example. reader = vtk.vtkImageReader() reader.SetDataByteOrderToLittleEndian() reader.SetDataExtent(0, 63, 0, 63, 1, 93) reader.SetFilePrefix(VTK_DATA_ROOT + "/Data/headsq/quarter") reader.SetDataMask(0x7fff) reader.SetDataSpacing(2, 2, 1) reader.SetDataScalarTypeToUnsignedShort() reader.Update() changeFilter = vtk.vtkImageChangeInformation() changeFilter.SetInputConnection(reader.GetOutputPort()) changeFilter.SetOutputOrigin(-63, -63, -46) # Create transfer functions for opacity and color opacityTransferFunction = vtk.vtkPiecewiseFunction() opacityTransferFunction.AddPoint(600, 0.0) opacityTransferFunction.AddPoint(2000, 1.0) colorTransferFunction = vtk.vtkColorTransferFunction() colorTransferFunction.ClampingOff() colorTransferFunction.AddHSVPoint(0.0, 0.01, 1.0, 1.0) colorTransferFunction.AddHSVPoint(1000.0, 0.50, 1.0, 1.0) colorTransferFunction.AddHSVPoint(2000.0, 0.99, 1.0, 1.0) colorTransferFunction.SetColorSpaceToHSV()
def cutSurfaceWithModel(self, segmentMarkupNode, segmentModel):
import vtkSegmentationCorePython as vtkSegmentationCore
if not segmentMarkupNode:
raise AttributeError("{}: segment markup node not set.".format(
self.__class__.__name__))
if not segmentModel:
raise AttributeError("{}: segment model not set.".format(
self.__class__.__name__))
if segmentMarkupNode and segmentModel.GetPolyData().GetNumberOfPolys(
) > 0:
operationName = self.scriptedEffect.parameter("Operation")
segmentationNode = self.scriptedEffect.parameterSetNode(
).GetSegmentationNode()
if not segmentationNode:
raise AttributeError("{}: Segmentation node not set.".format(
self.__class__.__name__))
modifierLabelmap = self.scriptedEffect.defaultModifierLabelmap()
if not modifierLabelmap:
raise AttributeError(
"{}: ModifierLabelmap not set. This can happen for various reasons:\n"
"No master volume set for segmentation,\n"
"No existing segments for segmentation, or\n"
"No referenceImageGeometry is specified in the segmentation"
.format(self.__class__.__name__))
WorldToModifierLabelmapIjkTransform = vtk.vtkTransform()
WorldToModifierLabelmapIjkTransformer = vtk.vtkTransformPolyDataFilter(
)
WorldToModifierLabelmapIjkTransformer.SetTransform(
WorldToModifierLabelmapIjkTransform)
WorldToModifierLabelmapIjkTransformer.SetInputConnection(
segmentModel.GetPolyDataConnection())
segmentationToSegmentationIjkTransformMatrix = vtk.vtkMatrix4x4()
modifierLabelmap.GetImageToWorldMatrix(
segmentationToSegmentationIjkTransformMatrix)
segmentationToSegmentationIjkTransformMatrix.Invert()
WorldToModifierLabelmapIjkTransform.Concatenate(
segmentationToSegmentationIjkTransformMatrix)
worldToSegmentationTransformMatrix = vtk.vtkMatrix4x4()
slicer.vtkMRMLTransformNode.GetMatrixTransformBetweenNodes(
None, segmentationNode.GetParentTransformNode(),
worldToSegmentationTransformMatrix)
WorldToModifierLabelmapIjkTransform.Concatenate(
worldToSegmentationTransformMatrix)
WorldToModifierLabelmapIjkTransformer.Update()
polyToStencil = vtk.vtkPolyDataToImageStencil()
polyToStencil.SetOutputSpacing(1.0, 1.0, 1.0)
polyToStencil.SetInputConnection(
WorldToModifierLabelmapIjkTransformer.GetOutputPort())
boundsIjk = WorldToModifierLabelmapIjkTransformer.GetOutput(
).GetBounds()
modifierLabelmapExtent = self.scriptedEffect.modifierLabelmap(
).GetExtent()
polyToStencil.SetOutputWholeExtent(modifierLabelmapExtent[0],
modifierLabelmapExtent[1],
modifierLabelmapExtent[2],
modifierLabelmapExtent[3],
int(round(boundsIjk[4])),
int(round(boundsIjk[5])))
polyToStencil.Update()
stencilData = polyToStencil.GetOutput()
stencilExtent = [0, -1, 0, -1, 0, -1]
stencilData.SetExtent(stencilExtent)
stencilToImage = vtk.vtkImageStencilToImage()
stencilToImage.SetInputConnection(polyToStencil.GetOutputPort())
if operationName in ("FILL_INSIDE", "ERASE_INSIDE", "SET"):
stencilToImage.SetInsideValue(1.0)
stencilToImage.SetOutsideValue(0.0)
else:
stencilToImage.SetInsideValue(0.0)
stencilToImage.SetOutsideValue(1.0)
stencilToImage.SetOutputScalarType(
modifierLabelmap.GetScalarType())
stencilPositioner = vtk.vtkImageChangeInformation()
stencilPositioner.SetInputConnection(
stencilToImage.GetOutputPort())
stencilPositioner.SetOutputSpacing(modifierLabelmap.GetSpacing())
stencilPositioner.SetOutputOrigin(modifierLabelmap.GetOrigin())
stencilPositioner.Update()
orientedStencilPositionerOutput = vtkSegmentationCore.vtkOrientedImageData(
)
orientedStencilPositionerOutput.ShallowCopy(
stencilToImage.GetOutput())
imageToWorld = vtk.vtkMatrix4x4()
modifierLabelmap.GetImageToWorldMatrix(imageToWorld)
orientedStencilPositionerOutput.SetImageToWorldMatrix(imageToWorld)
vtkSegmentationCore.vtkOrientedImageDataResample.ModifyImage(
modifierLabelmap, orientedStencilPositionerOutput,
vtkSegmentationCore.vtkOrientedImageDataResample.
OPERATION_MAXIMUM)
modMode = slicer.qSlicerSegmentEditorAbstractEffect.ModificationModeAdd
if operationName == "ERASE_INSIDE" or operationName == "ERASE_OUTSIDE":
modMode = slicer.qSlicerSegmentEditorAbstractEffect.ModificationModeRemove
elif operationName == "SET":
modMode = slicer.qSlicerSegmentEditorAbstractEffect.ModificationModeSet
self.scriptedEffect.modifySelectedSegmentByLabelmap(
modifierLabelmap, modMode)
# get fiducial positions as space-separated list
import numpy
n = segmentMarkupNode.GetNumberOfFiducials()
fPos = []
for i in range(n):
coord = [0.0, 0.0, 0.0]
segmentMarkupNode.GetNthFiducialPosition(i, coord)
fPos.extend(coord)
fPosString = ' '.join(map(str, fPos))
segmentID = self.scriptedEffect.parameterSetNode(
).GetSelectedSegmentID()
segment = segmentationNode.GetSegmentation().GetSegment(segmentID)
segment.SetTag("SurfaceCutEffectMarkupPositions", fPosString)
#!/usr/bin/env python
import vtk
from vtk.test import Testing
from vtk.util.misc import vtkGetDataRoot
VTK_DATA_ROOT = vtkGetDataRoot()
# In this example, an image is centered at (0,0,0) before a
# rotation is applied to ensure that the rotation occurs about
# the center of the image.
reader = vtk.vtkPNGReader()
reader.SetDataSpacing(0.8, 0.8, 1.5)
reader.SetFileName("" + str(VTK_DATA_ROOT) + "/Data/fullhead15.png")
# first center the image at (0,0,0)
information = vtk.vtkImageChangeInformation()
information.SetInputConnection(reader.GetOutputPort())
information.CenterImageOn()
reslice = vtk.vtkImageReslice()
reslice.SetInputConnection(information.GetOutputPort())
reslice.SetResliceAxesDirectionCosines(
[0.866025, -0.5, 0, 0.5, 0.866025, 0, 0, 0, 1])
reslice.SetInterpolationModeToCubic()
# reset the image back to the way it was (you don't have
# to do this, it is just put in as an example)
information2 = vtk.vtkImageChangeInformation()
information2.SetInputConnection(reslice.GetOutputPort())
reader.Update()
information2.SetInformationInputData(reader.GetOutput())
viewer = vtk.vtkImageViewer()
viewer.SetInputConnection(information2.GetOutputPort())
viewer.SetColorWindow(2000)
def createData(self, currentTimepoint): """ Create a test dataset within the parameters defined """ x,y,z = self.parameters["X"], self.parameters["Y"], self.parameters["Z"] if self.modified: print "Creating the time series data" self.createTimeSeries() if self.parameters["CreateAll"]: n = min(self.parameters["CacheAmount"], self.parameters["Time"]) for i in range(0, n): if i == currentTimepoint: print "Won't create timepoint %d, it'll be last"%i continue self.createData(i) print "\n\nGenerating timepoint %d"%currentTimepoint if currentTimepoint in self.imageCache: print "Returning cached image" return self.imageCache[currentTimepoint] print "Allocating image" if self.parameters["CreateNoise"]: print "Creating background noise" noiseSource = vtk.vtkImageNoiseSource() noiseSource.SetWholeExtent(0,x-1,0,y-1,0,z-1) noiseSource.SetMinimum(self.parameters["BackgroundNoiseMin"]) noiseSource.SetMaximum(self.parameters["BackgroundNoiseMax"]) castFilter = vtk.vtkImageCast() castFilter.SetOutputScalarTypeToUnsignedChar() castFilter.SetInputConnection(noiseSource.GetOutputPort()) information = vtk.vtkImageChangeInformation() information.SetInputConnection(castFilter.GetOutputPort()) information.SetOutputSpacing(self.spacing) image = information.GetOutput() image.Update() else: image = vtk.vtkImageData() image.SetScalarTypeToUnsignedChar() x,y,z = self.parameters["X"], self.parameters["Y"], self.parameters["Z"] image.SetDimensions((x,y,z)) image.AllocateScalars() image.SetSpacing(self.spacing) print "Initializing image" for iz in range(0,z): for iy in range(0,y): for ix in range(0,x): image.SetScalarComponentFromDouble(ix,iy,iz,0,0) if self.parameters["CreateNoise"]: noisePercentage = self.parameters["ShotNoiseAmount"] noiseAmount = (noisePercentage/100.0) * (x*y*z) print "Creating shot noise" else: noiseAmount = 0 shotNoiseMin = self.parameters["ShotNoiseMin"] shotNoiseMax = self.parameters["ShotNoiseMax"] shotNoiseDistr = self.parameters["ShotNoiseDistribution"] while noiseAmount > 0: rx,ry,rz = random.randint(0,x-1), random.randint(0,y-1), random.randint(0,z-1) shotInt = self.generateDistributionValue(shotNoiseDistr, shotNoiseMin, shotNoiseMax) image.SetScalarComponentFromDouble(rx,ry,rz,0,shotInt) noiseAmount -= 1 #shiftx, shifty, shiftz = self.shifts[currentTimepoint] print "Creating objects",currentTimepoint for oIter, (objN, (rx,ry,rz), size, objInt) in enumerate(self.objects[currentTimepoint]): #rx += shiftx #ry += shifty #rz += shiftz (rx,ry,rz), realSize, intList, voxelList = self.createObjectAt(image, rx,ry,rz, size, objInt) objMean, objStd, objStdErr = lib.Math.meanstdeverr(intList) # Change possible new size and com to object self.objects[currentTimepoint][oIter] = (objN, (rx,ry,rz), realSize, (objMean, objStdErr), voxelList) if self.parameters["ObjectsCreateSource"]: locator = vtk.vtkOBBTree() locator.SetDataSet(self.polydata) locator.BuildLocator() pointLocator = vtk.vtkPointLocator() pointLocator.SetDataSet(self.polydata) pointLocator.BuildLocator() objPolyTP = [] for objN, (cx, cy, cz), size, meanInt, voxelList in self.objects[currentTimepoint]: cxs = cx * self.spacing[0] cys = cy * self.spacing[1] czs = cz * self.spacing[2] locatorInside = locator.InsideOrOutside((cxs,cys,czs)) if locatorInside == -1: inside = 1 else: inside = 0 percVoxelsInside = 0.0 numIn = 0 for (vx,vy,vz) in voxelList: vxs = vx * self.spacing[0] vys = vy * self.spacing[1] vzs = vz * self.spacing[2] locatorInside = locator.InsideOrOutside((vxs,vys,vzs)) if locatorInside == -1: numIn += 1 percVoxelsInside = float(numIn) / len(voxelList) objid = pointLocator.FindClosestPoint((cxs, cys, czs)) x2,y2,z2 = self.polydata.GetPoint(objid) x2 /= self.spacing[0] y2 /= self.spacing[1] z2 /= self.spacing[2] distToSurf = self.distance((cx,cy,cz), (x2,y2,z2), self.voxelSize) distToCom = self.distance((cx,cy,cz), self.cellCOM, self.voxelSize) objPolyTP.append((objN, (cx,cy,cz), distToSurf, distToCom, inside, percVoxelsInside)) self.objPolydata[currentTimepoint] = objPolyTP n = len(self.imageCache.items()) if n > self.parameters["CacheAmount"]: items = self.imageCache.keys() items.sort() print "Removing ", items[0], "from cache" self.imageCache[items[0]].ReleaseData() del self.imageCache[items[0]] self.imageCache[currentTimepoint] = image self.progressObj.setProgress(currentTimepoint/self.parameters["Time"]) self.updateProgress(None, "ProgressEvent") return image
def volume(vol,voxsz=(1.0,1.0,1.0),affine=None,center_origin=1,info=1,maptype=0,trilinear=1,iso=0,iso_thr=100,opacitymap=None,colormap=None):
''' Create a volume and return a volumetric actor using volumetric rendering.
This function has many different interesting capabilities. The maptype, opacitymap and colormap are the most crucial parameters here.
Parameters:
----------------
vol : array, shape (N, M, K), dtype uint8
an array representing the volumetric dataset that we want to visualize using volumetric rendering
voxsz : sequence of 3 floats
default (1., 1., 1.)
affine : array, shape (4,4), default None
as given by volumeimages
center_origin : int {0,1}, default 1
it considers that the center of the volume is the
point (-vol.shape[0]/2.0+0.5,-vol.shape[1]/2.0+0.5,-vol.shape[2]/2.0+0.5)
info : int {0,1}, default 1
if 1 it prints out some info about the volume, the method and the dataset.
trilinear: int {0,1}, default 1
Use trilinear interpolation, default 1, gives smoother rendering. If you want faster interpolation use 0 (Nearest).
maptype : int {0,1}, default 0,
The maptype is a very important parameter which affects the raycasting algorithm in use for the rendering.
The options are:
If 0 then vtkVolumeTextureMapper2D is used.
If 1 then vtkVolumeRayCastFunction is used.
iso : int {0,1} default 0,
If iso is 1 and maptype is 1 then we use vtkVolumeRayCastIsosurfaceFunction which generates an isosurface at
the predefined iso_thr value. If iso is 0 and maptype is 1 vtkVolumeRayCastCompositeFunction is used.
iso_thr : int, default 100,
if iso is 1 then then this threshold in the volume defines the value which will be used to create the isosurface.
opacitymap : array, shape (N,2), default None.
The opacity map assigns a transparency coefficient to every point in the volume.
The default value uses the histogram of the volume to calculate the opacitymap.
colormap : array, shape (N,4), default None.
The color map assigns a color value to every point in the volume.
When None from the histogram it uses a red-blue colormap.
Returns:
----------
vtkVolume
Notes:
--------
What is the difference between TextureMapper2D and RayCastFunction?
Coming soon... See VTK user's guide [book] & The Visualization Toolkit [book] and VTK's online documentation & online docs.
What is the difference between RayCastIsosurfaceFunction and RayCastCompositeFunction?
Coming soon... See VTK user's guide [book] & The Visualization Toolkit [book] and VTK's online documentation & online docs.
What about trilinear interpolation?
Coming soon... well when time permits really ... :-)
Examples:
------------
First example random points
>>> from dipy.viz import fos
>>> import numpy as np
>>> vol=100*np.random.rand(100,100,100)
>>> vol=vol.astype('uint8')
>>> print vol.min(), vol.max()
>>> r = fos.ren()
>>> v = fos.volume(vol)
>>> fos.add(r,v)
>>> fos.show(r)
Second example with a more complicated function
>>> from dipy.viz import fos
>>> import numpy as np
>>> x, y, z = np.ogrid[-10:10:20j, -10:10:20j, -10:10:20j]
>>> s = np.sin(x*y*z)/(x*y*z)
>>> r = fos.ren()
>>> v = fos.volume(s)
>>> fos.add(r,v)
>>> fos.show(r)
If you find this function too complicated you can always use mayavi.
Please do not forget to use the -wthread switch in ipython if you are running mayavi.
>>> from enthought.mayavi import mlab
>>> import numpy as np
>>> x, y, z = np.ogrid[-10:10:20j, -10:10:20j, -10:10:20j]
>>> s = np.sin(x*y*z)/(x*y*z)
>>> mlab.pipeline.volume(mlab.pipeline.scalar_field(s))
>>> mlab.show()
More mayavi demos are available here:
http://code.enthought.com/projects/mayavi/docs/development/html/mayavi/mlab.html
'''
if vol.ndim!=3:
raise ValueError('3d numpy arrays only please')
if info :
print('Datatype',vol.dtype,'converted to uint8' )
vol=np.interp(vol,[vol.min(),vol.max()],[0,255])
vol=vol.astype('uint8')
if opacitymap==None:
bin,res=np.histogram(vol.ravel())
res2=np.interp(res,[vol.min(),vol.max()],[0,1])
opacitymap=np.vstack((res,res2)).T
opacitymap=opacitymap.astype('float32')
'''
opacitymap=np.array([[ 0.0, 0.0],
[50.0, 0.9]])
'''
if info:
print 'opacitymap', opacitymap
if colormap==None:
bin,res=np.histogram(vol.ravel())
res2=np.interp(res,[vol.min(),vol.max()],[0,1])
zer=np.zeros(res2.shape)
colormap=np.vstack((res,res2,zer,res2[::-1])).T
colormap=colormap.astype('float32')
'''
colormap=np.array([[0.0, 0.5, 0.0, 0.0],
[64.0, 1.0, 0.5, 0.5],
[128.0, 0.9, 0.2, 0.3],
[196.0, 0.81, 0.27, 0.1],
[255.0, 0.5, 0.5, 0.5]])
'''
if info:
print 'colormap', colormap
im = vtk.vtkImageData()
im.SetScalarTypeToUnsignedChar()
im.SetDimensions(vol.shape[0],vol.shape[1],vol.shape[2])
#im.SetOrigin(0,0,0)
#im.SetSpacing(voxsz[2],voxsz[0],voxsz[1])
im.AllocateScalars()
for i in range(vol.shape[0]):
for j in range(vol.shape[1]):
for k in range(vol.shape[2]):
im.SetScalarComponentFromFloat(i,j,k,0,vol[i,j,k])
if affine != None:
aff = vtk.vtkMatrix4x4()
aff.DeepCopy((affine[0,0],affine[0,1],affine[0,2],affine[0,3],affine[1,0],affine[1,1],affine[1,2],affine[1,3],affine[2,0],affine[2,1],affine[2,2],affine[2,3],affine[3,0],affine[3,1],affine[3,2],affine[3,3]))
#aff.DeepCopy((affine[0,0],affine[0,1],affine[0,2],0,affine[1,0],affine[1,1],affine[1,2],0,affine[2,0],affine[2,1],affine[2,2],0,affine[3,0],affine[3,1],affine[3,2],1))
#aff.DeepCopy((affine[0,0],affine[0,1],affine[0,2],127.5,affine[1,0],affine[1,1],affine[1,2],-127.5,affine[2,0],affine[2,1],affine[2,2],-127.5,affine[3,0],affine[3,1],affine[3,2],1))
reslice = vtk.vtkImageReslice()
reslice.SetInput(im)
#reslice.SetOutputDimensionality(2)
#reslice.SetOutputOrigin(127,-145,147)
reslice.SetResliceAxes(aff)
#reslice.SetOutputOrigin(-127,-127,-127)
#reslice.SetOutputExtent(-127,128,-127,128,-127,128)
#reslice.SetResliceAxesOrigin(0,0,0)
#print 'Get Reslice Axes Origin ', reslice.GetResliceAxesOrigin()
#reslice.SetOutputSpacing(1.0,1.0,1.0)
reslice.SetInterpolationModeToLinear()
#reslice.UpdateWholeExtent()
#print 'reslice GetOutputOrigin', reslice.GetOutputOrigin()
#print 'reslice GetOutputExtent',reslice.GetOutputExtent()
#print 'reslice GetOutputSpacing',reslice.GetOutputSpacing()
changeFilter=vtk.vtkImageChangeInformation()
changeFilter.SetInput(reslice.GetOutput())
#changeFilter.SetInput(im)
if center_origin:
changeFilter.SetOutputOrigin(-vol.shape[0]/2.0+0.5,-vol.shape[1]/2.0+0.5,-vol.shape[2]/2.0+0.5)
print 'ChangeFilter ', changeFilter.GetOutputOrigin()
opacity = vtk.vtkPiecewiseFunction()
for i in range(opacitymap.shape[0]):
opacity.AddPoint(opacitymap[i,0],opacitymap[i,1])
color = vtk.vtkColorTransferFunction()
for i in range(colormap.shape[0]):
color.AddRGBPoint(colormap[i,0],colormap[i,1],colormap[i,2],colormap[i,3])
if(maptype==0):
property = vtk.vtkVolumeProperty()
property.SetColor(color)
property.SetScalarOpacity(opacity)
if trilinear:
property.SetInterpolationTypeToLinear()
else:
prop.SetInterpolationTypeToNearest()
if info:
print('mapper VolumeTextureMapper2D')
mapper = vtk.vtkVolumeTextureMapper2D()
if affine == None:
mapper.SetInput(im)
else:
#mapper.SetInput(reslice.GetOutput())
mapper.SetInput(changeFilter.GetOutput())
if (maptype==1):
property = vtk.vtkVolumeProperty()
property.SetColor(color)
property.SetScalarOpacity(opacity)
property.ShadeOn()
if trilinear:
property.SetInterpolationTypeToLinear()
else:
prop.SetInterpolationTypeToNearest()
if iso:
isofunc=vtk.vtkVolumeRayCastIsosurfaceFunction()
isofunc.SetIsoValue(iso_thr)
else:
compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
if info:
print('mapper VolumeRayCastMapper')
mapper = vtk.vtkVolumeRayCastMapper()
if iso:
mapper.SetVolumeRayCastFunction(isofunc)
if info:
print('Isosurface')
else:
mapper.SetVolumeRayCastFunction(compositeFunction)
#mapper.SetMinimumImageSampleDistance(0.2)
if info:
print('Composite')
if affine == None:
mapper.SetInput(im)
else:
#mapper.SetInput(reslice.GetOutput())
mapper.SetInput(changeFilter.GetOutput())
#Return mid position in world space
#im2=reslice.GetOutput()
#index=im2.FindPoint(vol.shape[0]/2.0,vol.shape[1]/2.0,vol.shape[2]/2.0)
#print 'Image Getpoint ' , im2.GetPoint(index)
volum = vtk.vtkVolume()
volum.SetMapper(mapper)
volum.SetProperty(property)
if info :
print 'Origin', volum.GetOrigin()
print 'Orientation', volum.GetOrientation()
print 'OrientationW', volum.GetOrientationWXYZ()
print 'Position', volum.GetPosition()
print 'Center', volum.GetCenter()
print 'Get XRange', volum.GetXRange()
print 'Get YRange', volum.GetYRange()
print 'Get ZRange', volum.GetZRange()
print 'Volume data type', vol.dtype
return volum
def smoothMultipleSegments(self, maskImage=None, maskExtent=None):
import vtkSegmentationCorePython as vtkSegmentationCore
self.showStatusMessage(f'Joint smoothing ...')
# Generate merged labelmap of all visible segments
segmentationNode = self.scriptedEffect.parameterSetNode(
).GetSegmentationNode()
visibleSegmentIds = vtk.vtkStringArray()
segmentationNode.GetDisplayNode().GetVisibleSegmentIDs(
visibleSegmentIds)
if visibleSegmentIds.GetNumberOfValues() == 0:
logging.info(
"Smoothing operation skipped: there are no visible segments")
return
mergedImage = slicer.vtkOrientedImageData()
if not segmentationNode.GenerateMergedLabelmapForAllSegments(
mergedImage, vtkSegmentationCore.vtkSegmentation.
EXTENT_UNION_OF_SEGMENTS_PADDED, None, visibleSegmentIds):
logging.error(
'Failed to apply smoothing: cannot get list of visible segments'
)
return
segmentLabelValues = [] # list of [segmentId, labelValue]
for i in range(visibleSegmentIds.GetNumberOfValues()):
segmentId = visibleSegmentIds.GetValue(i)
segmentLabelValues.append([segmentId, i + 1])
# Perform smoothing in voxel space
ici = vtk.vtkImageChangeInformation()
ici.SetInputData(mergedImage)
ici.SetOutputSpacing(1, 1, 1)
ici.SetOutputOrigin(0, 0, 0)
# Convert labelmap to combined polydata
# vtkDiscreteFlyingEdges3D cannot be used here, as in the output of that filter,
# each labeled region is completely disconnected from neighboring regions, and
# for joint smoothing it is essential for the points to move together.
convertToPolyData = vtk.vtkDiscreteMarchingCubes()
convertToPolyData.SetInputConnection(ici.GetOutputPort())
convertToPolyData.SetNumberOfContours(len(segmentLabelValues))
contourIndex = 0
for segmentId, labelValue in segmentLabelValues:
convertToPolyData.SetValue(contourIndex, labelValue)
contourIndex += 1
# Low-pass filtering using Taubin's method
smoothingFactor = self.scriptedEffect.doubleParameter(
"JointTaubinSmoothingFactor")
smoothingIterations = 100 # according to VTK documentation 10-20 iterations could be enough but we use a higher value to reduce chance of shrinking
passBand = pow(
10.0, -4.0 * smoothingFactor
) # gives a nice range of 1-0.0001 from a user input of 0-1
smoother = vtk.vtkWindowedSincPolyDataFilter()
smoother.SetInputConnection(convertToPolyData.GetOutputPort())
smoother.SetNumberOfIterations(smoothingIterations)
smoother.BoundarySmoothingOff()
smoother.FeatureEdgeSmoothingOff()
smoother.SetFeatureAngle(90.0)
smoother.SetPassBand(passBand)
smoother.NonManifoldSmoothingOn()
smoother.NormalizeCoordinatesOn()
# Extract a label
threshold = vtk.vtkThreshold()
threshold.SetInputConnection(smoother.GetOutputPort())
# Convert to polydata
geometryFilter = vtk.vtkGeometryFilter()
geometryFilter.SetInputConnection(threshold.GetOutputPort())
# Convert polydata to stencil
polyDataToImageStencil = vtk.vtkPolyDataToImageStencil()
polyDataToImageStencil.SetInputConnection(
geometryFilter.GetOutputPort())
polyDataToImageStencil.SetOutputSpacing(1, 1, 1)
polyDataToImageStencil.SetOutputOrigin(0, 0, 0)
polyDataToImageStencil.SetOutputWholeExtent(mergedImage.GetExtent())
# Convert stencil to image
stencil = vtk.vtkImageStencil()
emptyBinaryLabelMap = vtk.vtkImageData()
emptyBinaryLabelMap.SetExtent(mergedImage.GetExtent())
emptyBinaryLabelMap.AllocateScalars(vtk.VTK_UNSIGNED_CHAR, 1)
vtkSegmentationCore.vtkOrientedImageDataResample.FillImage(
emptyBinaryLabelMap, 0)
stencil.SetInputData(emptyBinaryLabelMap)
stencil.SetStencilConnection(polyDataToImageStencil.GetOutputPort())
stencil.ReverseStencilOn()
stencil.SetBackgroundValue(
1
) # General foreground value is 1 (background value because of reverse stencil)
imageToWorldMatrix = vtk.vtkMatrix4x4()
mergedImage.GetImageToWorldMatrix(imageToWorldMatrix)
# TODO: Temporarily setting the overwrite mode to OverwriteVisibleSegments is an approach that should be change once additional
# layer control options have been implemented. Users may wish to keep segments on separate layers, and not allow them to be separated/merged automatically.
# This effect could leverage those options once they have been implemented.
oldOverwriteMode = self.scriptedEffect.parameterSetNode(
).GetOverwriteMode()
self.scriptedEffect.parameterSetNode().SetOverwriteMode(
slicer.vtkMRMLSegmentEditorNode.OverwriteVisibleSegments)
for segmentId, labelValue in segmentLabelValues:
threshold.ThresholdBetween(labelValue, labelValue)
stencil.Update()
smoothedBinaryLabelMap = slicer.vtkOrientedImageData()
smoothedBinaryLabelMap.ShallowCopy(stencil.GetOutput())
smoothedBinaryLabelMap.SetImageToWorldMatrix(imageToWorldMatrix)
self.scriptedEffect.modifySegmentByLabelmap(
segmentationNode, segmentId, smoothedBinaryLabelMap,
slicer.qSlicerSegmentEditorAbstractEffect.ModificationModeSet,
False)
self.scriptedEffect.parameterSetNode().SetOverwriteMode(
oldOverwriteMode)
def getBoundedMap(self, baseImage, dataLocation, map_cut_size,
map_border_size):
baseImage.Update()
baseExtent = baseImage.GetExtent()
baseSpacing = baseImage.GetSpacing()
x0 = baseExtent[0]
x1 = baseExtent[1]
y0 = baseExtent[2]
y1 = baseExtent[3]
imageLen = [x1 - x0 + 1, y1 - y0 + 1]
selectionDim = [map_cut_size[0] / 2, map_cut_size[1] / 2]
dataXLoc = dataLocation[0]
imageInfo = vtk.vtkImageChangeInformation()
dataYbounds = [
dataLocation[1] - selectionDim[1],
dataLocation[1] + selectionDim[1]
]
vertExtent = [y0, y1]
bounded_dims = None
if dataYbounds[0] > -90.0:
yOffset = dataYbounds[0] + 90.0
extOffset = int(round((yOffset / 180.0) * imageLen[1]))
vertExtent[0] = y0 + extOffset
self.y0 = dataYbounds[0]
if dataYbounds[1] < 90.0:
yOffset = 90.0 - dataYbounds[1]
extOffset = int(round((yOffset / 180.0) * imageLen[1]))
vertExtent[1] = y1 - extOffset
overlapsBorder = (
self.NormalizeMapLon(dataLocation[0] - selectionDim[0]) >
self.NormalizeMapLon(dataLocation[0] + selectionDim[0]))
if overlapsBorder:
cut0 = self.NormalizeMapLon(dataXLoc + selectionDim[0])
sliceSize = imageLen[0] * ((cut0 - self.map_cut) / 360.0)
sliceCoord = int(round(x0 + sliceSize))
extent = list(baseExtent)
extent[0:2] = [x0, x0 + sliceCoord - 1]
clip0 = vtk.vtkImageClip()
clip0.SetInput(baseImage)
clip0.SetOutputWholeExtent(extent[0], extent[1], vertExtent[0],
vertExtent[1], extent[4], extent[5])
size0 = extent[1] - extent[0] + 1
self.x0 = dataLocation[0] - selectionDim[0]
cut1 = self.NormalizeMapLon(self.x0)
sliceSize = imageLen[0] * ((cut1 - self.map_cut) / 360.0)
sliceCoord = int(round(x0 + sliceSize))
extent[0:2] = [x0 + sliceCoord, x1]
clip1 = vtk.vtkImageClip()
clip1.SetInput(baseImage)
clip1.SetOutputWholeExtent(extent[0], extent[1], vertExtent[0],
vertExtent[1], extent[4], extent[5])
size1 = extent[1] - extent[0] + 1
# print "Set Corner pos: %s, cuts: %s " % ( str(self.x0), str( (cut0, cut1) ) )
append = vtk.vtkImageAppend()
append.SetAppendAxis(0)
append.AddInput(clip1.GetOutput())
append.AddInput(clip0.GetOutput())
bounded_dims = (size0 + size1, vertExtent[1] - vertExtent[0] + 1)
imageInfo.SetInputConnection(append.GetOutputPort())
else:
self.x0 = dataXLoc - selectionDim[0]
cut0 = self.NormalizeMapLon(self.x0)
sliceSize = imageLen[0] * ((cut0 - self.map_cut) / 360.0)
sliceCoord = int(round(x0 + sliceSize))
extent = list(baseExtent)
extent[0] = x0 + sliceCoord - 1
cut1 = self.NormalizeMapLon(dataXLoc + selectionDim[0])
sliceSize = imageLen[0] * ((cut1 - self.map_cut) / 360.0)
sliceCoord = int(round(x0 + sliceSize))
extent[1] = x0 + sliceCoord
clip = vtk.vtkImageClip()
clip.SetInput(baseImage)
clip.SetOutputWholeExtent(extent[0], extent[1], vertExtent[0],
vertExtent[1], extent[4], extent[5])
bounded_dims = (extent[1] - extent[0] + 1,
vertExtent[1] - vertExtent[0] + 1)
# print "Set Corner pos: %s, dataXLoc: %s " % ( str(self.x0), str( (dataXLoc, selectionDim[0]) ) )
imageInfo.SetInputConnection(clip.GetOutputPort())
imageInfo.SetOutputOrigin(0.0, 0.0, 0.0)
imageInfo.SetOutputExtentStart(0, 0, 0)
imageInfo.SetOutputSpacing(baseSpacing[0], baseSpacing[1],
baseSpacing[2])
result = imageInfo.GetOutput()
result.Update()
return result, bounded_dims
def dicomTransform(self, image, image_pos_pat, image_ori_pat):
""" dicomTransform: transforms an image to a DICOM coordinate frame
INPUTS:
=======
image: (vtkImageData) Input image to Transform
image_pos_pat: (list(dicomInfo[0x0020,0x0032].value))) Image position patient Dicom Tag
image_ori_pat: (list(dicomInfo[0x0020,0x0037].value)) Image oreintation patient Dicom Tag
OUTPUTS:
=======
transformed_image (vtkImageData) Transformed imaged mapped to dicom coords frame
transform (vtkTransform) Transform used
"""
# If one considers the localizer plane as a "viewport" onto the DICOM 3D coordinate space, then that viewport is described by its origin, its row unit vector, column unit vector and a normal unit vector (derived from the row and column vectors by taking the cross product). Now if one moves the origin to 0,0,0 and rotates this viewing plane such that the row vector is in the +X direction, the column vector the +Y direction, and the normal in the +Z direction, then one has a situation where the X coordinate now represents a column offset in mm from the localizer's top left hand corner, and the Y coordinate now represents a row offset in mm from the localizer's top left hand corner, and the Z coordinate can be ignored. One can then convert the X and Y mm offsets into pixel offsets using the pixel spacing of the localizer imag
# Initialize Image orienation
"Image Orientation Patient Matrix"
IO = matrix( [[0, 0,-1, 1],
[1, 0, 0, 1],
[0,-1, 0, 1],
[0, 0, 0, 1]])
# Assign the 6-Image orientation patient coordinates (from Dicomtags)
IO[0,0] = image_ori_pat[0]; IO[0,1] = image_ori_pat[1]; IO[0,2] = image_ori_pat[2];
IO[1,0] = image_ori_pat[3]; IO[1,1] = image_ori_pat[4]; IO[1,2] = 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[2,0] = IO_col3[0]; IO[2,1] = 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]
"Compute Volume Origin"
origin = IP*IO.I
# 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()
# Change info
# Flip along Y-Z-axis: VTK uses computer graphics convention where the first pixel in memory is shown
# in the lower left of the displayed image.
flipZ_image = vtk.vtkImageFlip()
flipZ_image.SetInput(image)
flipZ_image.SetFilteredAxis(2)
flipZ_image.Update()
flipY_image = vtk.vtkImageFlip()
flipY_image.SetInput(flipZ_image.GetOutput())
flipY_image.SetFilteredAxis(1)
flipY_image.Update()
# Change info origin
flipY_origin_image = vtk.vtkImageChangeInformation()
flipY_origin_image.SetInput( flipY_image.GetOutput() );
flipY_origin_image.SetOutputOrigin(origin[0,0], origin[0,1], origin[0,2])
flipY_origin_image.Update()
transformed_image = flipY_origin_image.GetOutput()
transformed_image.UpdateInformation()
self.dims = transformed_image.GetDimensions()
print "Image Dimensions"
print self.dims
(xMin, xMax, yMin, yMax, zMin, zMax) = transformed_image.GetWholeExtent()
print "Image Extension"
print xMin, xMax, yMin, yMax, zMin, zMax
self.spacing = transformed_image.GetSpacing()
print "Image Spacing"
print self.spacing
self.origin = transformed_image.GetOrigin()
print "Image Origin"
print self.origin
return transformed_image, transform_cube
def buildBaseMap(self):
if self.baseMapActor <> None: self.renderer.RemoveActor( self.baseMapActor )
world_map = None
map_border_size = 20
self.y0 = -90.0
self.x0 = 0.0
dataPosition = None
if world_map == None:
self.map_file = defaultMapFile
self.map_cut = defaultMapCut
else:
self.map_file = world_map[0].name
self.map_cut = world_map[1]
self.world_cut = -1
if (self.roi <> None):
roi_size = [ self.roi[1] - self.roi[0], self.roi[3] - self.roi[2] ]
scale = (self.roi[1] - self.roi[0])/300.0
border_size = map_border_size * scale
map_cut_size = [ roi_size[0] + 2*border_size, roi_size[1] + 2*border_size ]
if map_cut_size[0] > 360.0: map_cut_size[0] = 360.0
if map_cut_size[1] > 180.0: map_cut_size[1] = 180.0
else:
map_cut_size = [ 360, 180 ]
if self.world_cut == -1:
if (self.roi <> None):
if roi_size[0] > 180:
self.ComputeCornerPosition()
self.world_cut = self.NormalizeMapLon( self.x0 )
else:
dataPosition = [ ( self.roi[1] + self.roi[0] ) / 2.0, ( self.roi[3] + self.roi[2] ) / 2.0 ]
else:
dataPosition = [ 180, 0 ] # [ ( self.roi[1] + self.roi[0] ) / 2.0, ( self.roi[3] + self.roi[2] ) / 2.0 ]
else:
self.world_cut = self.map_cut
self.imageInfo = vtk.vtkImageChangeInformation()
image_reader = vtk.vtkJPEGReader()
image_reader.SetFileName( self.map_file )
image_reader.Update()
baseImage = image_reader.GetOutput()
new_dims, scale = None, None
if dataPosition == None:
old_dims = baseImage.GetDimensions()
baseImage = self.RollMap( baseImage )
new_dims = baseImage.GetDimensions()
scale = [ 360.0/new_dims[0], 180.0/new_dims[1], 1 ]
else:
baseImage, new_dims = self.getBoundedMap( baseImage, dataPosition, map_cut_size, border_size )
scale = [ map_cut_size[0]/new_dims[0], map_cut_size[1]/new_dims[1], 1 ]
self.baseMapActor = vtk.vtkImageActor()
self.baseMapActor.SetOrigin( 0.0, 0.0, 0.0 )
self.baseMapActor.SetScale( scale )
self.baseMapActor.SetOrientation( 0.0, 0.0, 0.0 )
self.baseMapActor.SetOpacity( self.map_opacity[0] )
mapCorner = [ self.x0, self.y0 ]
# self.xcenter = self.x0
# self.ycenter = self.y0
# self.adjustCamera( baseImage )
self.baseMapActor.SetPosition( mapCorner[0], mapCorner[1], 0.1 )
if vtk.VTK_MAJOR_VERSION <= 5: self.baseMapActor.SetInput(baseImage)
else: self.baseMapActor.SetInputData(baseImage)
self.mapCenter = [ self.x0 + map_cut_size[0]/2.0, self.y0 + map_cut_size[1]/2.0 ]
self.renderer.AddActor( self.baseMapActor )
