def SetImageTransform(self, transform):
self._ImageTransform = transform
if not transform:
self._ImageReslice1.SetResliceTransform(None)
self._ImageReslice2.SetResliceTransform(None)
self._RayCastReslice.SetResliceTransform(None)
elif transform.IsA('vtkLinearTransform'):
self._ImageReslice1.SetResliceTransform(
transform.GetLinearInverse())
self._ImageReslice2.SetResliceTransform(
transform.GetLinearInverse())
self._RayCastReslice.SetResliceTransform(
transform.GetLinearInverse())
elif transform.IsA('vtkHomogeneousTransform'):
self._ImageReslice1.SetResliceTransform(
transform.GetHomogeneousInverse())
self._ImageReslice2.SetResliceTransform(
transform.GetHomogeneousInverse())
self._RayCastReslice.SetResliceTransform(
transform.GetHomogeneousInverse())
else:
tgrid = self._TransformToGrid
tgrid.SetInput(transform.GetInverse())
gridt = vtk.vtkGridTransform()
gridt.SetInterpolationModeToCubic()
gridt.SetDisplacementGrid(tgrid.GetOutput())
self._ImageReslice1.SetResliceTransform(transform.GetInverse())
self._ImageReslice2.SetResliceTransform(transform.GetInverse())
self._RayCastReslice.SetResliceTransform(transform.GetInverse())
self._ImplicitVolume.SetTransform(
self._ImageReslice1.GetResliceTransform())
def onExportGrid(self):
"""Converts the current thin plate transform to a grid"""
state = self.registrationState()
# since the transform is ras-to-ras, we find the extreme points
# in ras space of the fixed (target) volume and fix the unoriented
# box around it. Sample the grid transform at the resolution of
# the fixed volume, which may be a bit overkill but it should aways
# work without too much loss.
rasBounds = [
0,
] * 6
state.fixed.GetRASBounds(rasBounds)
from math import floor, ceil
origin = map(int, map(floor, rasBounds[::2]))
maxes = map(int, map(ceil, rasBounds[1::2]))
boundSize = [m - o for m, o in zip(maxes, origin)]
spacing = state.fixed.GetSpacing()
samples = [ceil(b / s) for b, s in zip(boundSize, spacing)]
extent = [
0,
] * 6
extent[::2] = [
0,
] * 3
extent[1::2] = samples
extent = map(int, extent)
toGrid = vtk.vtkTransformToGrid()
toGrid.SetGridOrigin(origin)
toGrid.SetGridSpacing(state.fixed.GetSpacing())
toGrid.SetGridExtent(extent)
toGrid.SetInput(
state.transform.GetTransformFromParent()) # same in VTKv 5 & 6
toGrid.Update()
gridTransform = vtk.vtkGridTransform()
if vtk.VTK_MAJOR_VERSION < 6:
gridTransform.SetDisplacementGrid(
toGrid.GetOutput()) # different in VTKv 5 & 6
else:
gridTransform.SetDisplacementGridData(toGrid.GetOutput())
gridNode = slicer.vtkMRMLGridTransformNode()
gridNode.SetAndObserveTransformFromParent(gridTransform)
gridNode.SetName(state.transform.GetName() + "-grid")
slicer.mrmlScene.AddNode(gridNode)
def onExportGrid(self):
"""Converts the current thin plate transform to a grid"""
state = self.registationState()
# since the transform is ras-to-ras, we find the extreme points
# in ras space of the fixed (target) volume and fix the unoriented
# box around it. Sample the grid transform at the resolution of
# the fixed volume, which may be a bit overkill but it should aways
# work without too much loss.
rasBounds = [0,]*6
state.fixed.GetRASBounds(rasBounds)
from math import floor, ceil
origin = map(int,map(floor,rasBounds[::2]))
maxes = map(int,map(ceil,rasBounds[1::2]))
boundSize = [m - o for m,o in zip(maxes,origin) ]
spacing = state.fixed.GetSpacing()
samples = [ceil(b / s) for b,s in zip(boundSize,spacing)]
extent = [0,]*6
extent[::2] = [0,]*3
extent[1::2] = samples
extent = map(int,extent)
toGrid = vtk.vtkTransformToGrid()
toGrid.SetGridOrigin(origin)
toGrid.SetGridSpacing(state.fixed.GetSpacing())
toGrid.SetGridExtent(extent)
toGrid.SetInput(state.transform.GetTransformFromParent()) # same in VTKv 5 & 6
toGrid.Update()
gridTransform = vtk.vtkGridTransform()
if vtk.VTK_MAJOR_VERSION < 6:
gridTransform.SetDisplacementGrid(toGrid.GetOutput()) # different in VTKv 5 & 6
else:
gridTransform.SetDisplacementGridData(toGrid.GetOutput())
gridNode = slicer.vtkMRMLGridTransformNode()
gridNode.SetAndObserveTransformFromParent(gridTransform)
gridNode.SetName(state.transform.GetName()+"-grid")
slicer.mrmlScene.AddNode(gridNode)
p2.SetPoint(4, 96, 159, 0) p2.SetPoint(5, 159, 159, 0) p2.SetPoint(6, 159, 96, 0) p2.SetPoint(7, 96, 96, 0) thinPlate = vtk.vtkThinPlateSplineTransform() thinPlate.SetSourceLandmarks(p2) thinPlate.SetTargetLandmarks(p1) thinPlate.SetBasisToR2LogR() # convert the thin plate spline into a grid transformToGrid = vtk.vtkTransformToGrid() transformToGrid.SetInput(thinPlate) transformToGrid.SetGridSpacing(16, 16, 1) transformToGrid.SetGridOrigin(-0.5, -0.5, 0) transformToGrid.SetGridExtent(0, 16, 0, 16, 0, 0) transformToGrid.Update() transform = vtk.vtkGridTransform() transform.SetDisplacementGridConnection(transformToGrid.GetOutputPort()) transform.SetInterpolationModeToCubic() # you must invert the transform before passing it to vtkImageReslice transform.Inverse() # apply the grid warp to the image reslice = vtk.vtkImageReslice() reslice.SetInputConnection(blend.GetOutputPort()) reslice.SetResliceTransform(transform) reslice.SetInterpolationModeToLinear() # set the window/level to 255.0/127.5 to view full range viewer = vtk.vtkImageViewer() viewer.SetInputConnection(reslice.GetOutputPort()) viewer.SetColorWindow(255.0) viewer.SetColorLevel(127.5) viewer.SetZSlice(0)
p1.InsertNextPoint(100,100,-50) p2.InsertNextPoint(100,100,-50) p1.InsertNextPoint(100,100,50) p2.InsertNextPoint(100,100,50) transform = vtk.vtkThinPlateSplineTransform() transform.SetSourceLandmarks(p1) transform.SetTargetLandmarks(p2) transform.SetBasisToR() gridThinPlate = vtk.vtkTransformToGrid() gridThinPlate.SetInput(transform) gridThinPlate.SetGridExtent(0,64,0,64,0,50) gridThinPlate.SetGridSpacing(3.2,3.2,3.0) gridThinPlate.SetGridOrigin(-102.4,-102.4,-75) gridThinPlate.SetGridScalarTypeToUnsignedChar() gridThinPlate.Update() gridTransform = vtk.vtkGridTransform() gridTransform.SetDisplacementGridData(gridThinPlate.GetOutput()) gridTransform.SetDisplacementShift(gridThinPlate.GetDisplacementShift()) gridTransform.SetDisplacementScale(gridThinPlate.GetDisplacementScale()) reslice = vtk.vtkImageReslice() reslice.SetInputConnection(reader.GetOutputPort()) reslice.SetResliceTransform(gridTransform) reslice.SetInterpolationModeToLinear() reslice.SetOutputSpacing(1,1,1) viewer = vtk.vtkImageViewer() viewer.SetInputConnection(reslice.GetOutputPort()) viewer.SetZSlice(70) viewer.SetColorWindow(2000) viewer.SetColorLevel(1000) viewer.SetSize(200,200) viewer.Render()
a12.RotateY(90) a12.GetProperty().SetColor(0.9,0.9,0) #[a12 GetProperty] SetRepresentationToWireframe ren12 = vtk.vtkRenderer() ren12.SetViewport(0.0,0.0,0.25,0.5) ren12.ResetCamera(-0.5,0.5,-0.5,0.5,-1,1) ren12.AddActor(a12) renWin.AddRenderer(ren12) #-------------------------- # grid transform, cubic interpolation gridTrans = vtk.vtkTransformToGrid() gridTrans.SetInput(t1) gridTrans.SetGridOrigin(-1.5,-1.5,-1.5) gridTrans.SetGridExtent(0,60,0,60,0,60) gridTrans.SetGridSpacing(0.05,0.05,0.05) t2 = vtk.vtkGridTransform() t2.SetDisplacementGridConnection(gridTrans.GetOutputPort()) t2.SetInterpolationModeToCubic() f21 = vtk.vtkTransformPolyDataFilter() f21.SetInputConnection(ap.GetOutputPort()) f21.SetTransform(t2) m21 = vtk.vtkDataSetMapper() m21.SetInputConnection(f21.GetOutputPort()) a21 = vtk.vtkActor() a21.SetMapper(m21) a21.RotateY(90) a21.GetProperty().SetColor(1,0,0) #[a21 GetProperty] SetRepresentationToWireframe ren21 = vtk.vtkRenderer() ren21.SetViewport(0.25,0.5,0.50,1.0) ren21.ResetCamera(-0.5,0.5,-0.5,0.5,-1,1)
def VTKImageTransform(x,dx,dy,numret=False,reverse=False,origsize=None,
cubic=False,interp=True,scalex=1,scaley=1,constant=0,wrap=False,
mirror=False):
maxdx = max([int(max(abs(dx.ravel()))+1),(dx.shape[1]-x.shape[1])])
maxdy = max([int(max(abs(dy.ravel()))+1),(dx.shape[0]-x.shape[0])])
dx = dx.astype(np.float32)
dy = dy.astype(np.float32)
if scalex > 1:
xx = np.arange(x.shape[1])
dx = (xx[np.newaxis,::]+dx).astype(np.float32)
dy = VTKGrowN(dy,scalex,1,numret=True)
dx = VTKGrowN(dx,scalex,1,numret=True)
dx = (dx-np.arange(scalex*x.shape[1])[np.newaxis,::]).\
astype(np.float32)
if scaley > 1:
yy = np.arange(x.shape[0])
dy = (yy[::,np.newaxis]+dy).astype(np.float32)
dy = VTKGrowN(dy,1,scaley,numret=True)
dx = VTKGrowN(dx,1,scaley,numret=True)
dy = (dy-np.arange(scaley*x.shape[0])[::,np.newaxis]).\
astype(np.float32)
if type(x) == np.ndarray: i = NumToVTKImage(x)
else: i = x
if type(dx) == np.ndarray: tx = NumToVTKImage(dx)
else: tx = dx
if type(dy) == np.ndarray: ty = NumToVTKImage(dy)
else: ty = dy
dm = ty.GetDimensions()
dz = np.zeros(dy.shape,dy.dtype)
tz = NumToVTKImage(dz)
a = vtk.vtkImageAppendComponents()
a.AddInputData(tx)
a.AddInputData(ty)
a.AddInputData(tz)
a.Update()
t = a.GetOutput()
r = vtk.vtkGridTransform()
r.SetDisplacementGridData(t)
r.Update()
s = vtk.vtkImageReslice()
s.WrapOff()
s.MirrorOn()
if interp:
s.InterpolateOn()
if cubic: s.SetInterpolationModeToCubic()
else: s.SetInterpolationModeToLinear()
s.SetOutputDimensionality(2)
if reverse:
r.SetInterpolationModeToLinear()
r.SetInverseTolerance(0.001)
r.SetInverseIterations(1000)
r.DebugOff()
ir = r.GetInverse()
ir.SetInterpolationModeToLinear()
ir.SetInverseTolerance(0.001)
ir.SetInverseIterations(1000)
ir.GlobalWarningDisplayOff()
s.SetResliceTransform(ir)
s.AutoCropOutputOff()
if origsize: s.SetOutputExtent(0,origsize[1]-1,0,origsize[0]-1,0,0)
else: s.SetOutputExtent(0,scalex*dm[0]-1,0,scaley*dm[1]-1,0,0)
else:
r.SetInterpolationModeToCubic()
r.SetInverseTolerance(0.001)
r.SetInverseIterations(1000)
r.GlobalWarningDisplayOff()
s.SetOutputExtent(0,scalex*dm[0]-1,0,scaley*dm[1]-1,0,0)
s.AutoCropOutputOff()
s.SetResliceTransform(r)
if mirror: ip = vtk.vtkImageMirrorPad()
elif wrap: ip = vtk.vtkImageWrapPad()
else: ip = vtk.vtkImageConstantPad(); ip.SetConstant(constant)
ip.SetOutputWholeExtent(0-maxdx,dm[0]-1+maxdx,0-maxdy,dm[1]-1+maxdy,0,0)
ip.SetInputData(i)
ip.Update()
s.SetInputData(ip.GetOutput())
o=s.GetOutput()
s.Update()
if numret: ri = VTKImageToNum(o)
else: ri = o
return ri
