def ipl_open(image_in, open):
ipl_open_settings(open)
extent = image_in.GetExtent()
clip = vtk.vtkImageReslice()
clip.SetInput(image_in)
clip.SetOutputExtent(extent[0] - open - 2, extent[1] + open + 2,
extent[2] - open - 2, extent[3] + open + 2,
extent[4] - open - 2, extent[5] + open + 2)
clip.MirrorOn()
clip.Update()
erode = vtk.vtkImageContinuousErode3D()
erode.SetInputConnection(clip.GetOutputPort())
erode.SetKernelSize(2 * open + 1, 2 * open + 1, 2 * open + 1)
erode.Update()
#Kernel size is twice the dilation distance plus one for the center voxel
dilate = vtk.vtkImageContinuousDilate3D()
dilate.SetInputConnection(erode.GetOutputPort())
dilate.SetKernelSize(2 * open + 1, 2 * open + 1, 2 * open + 1)
dilate.Update()
voi = vtk.vtkExtractVOI()
voi.SetInput(dilate.GetOutput())
voi.SetVOI(extent[0], extent[1], extent[2], extent[3], extent[4],
extent[5])
voi.Update()
image_out = voi.GetOutput()
return image_out
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkImageContinuousErode3D(), 'Processing.',
('vtkImageData',), ('vtkImageData',),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
def __init__(self, module_manager):
# initialise our base class
ModuleBase.__init__(self, module_manager)
self._imageDilate = vtk.vtkImageContinuousDilate3D()
self._imageErode = vtk.vtkImageContinuousErode3D()
self._imageErode.SetInput(self._imageDilate.GetOutput())
module_utils.setup_vtk_object_progress(self, self._imageDilate,
'Performing greyscale 3D dilation')
module_utils.setup_vtk_object_progress(self, self._imageErode,
'Performing greyscale 3D erosion')
self._config.kernelSize = (3, 3, 3)
configList = [
('Kernel size:', 'kernelSize', 'tuple:int,3', 'text',
'Size of the kernel in x,y,z dimensions.')]
ScriptedConfigModuleMixin.__init__(
self, configList,
{'Module (self)' : self,
'vtkImageContinuousDilate3D' : self._imageDilate,
'vtkImageContinuousErode3D' : self._imageErode})
self.sync_module_logic_with_config()
def ipl_maskaimpeel(image_in1, image_in2, peel_iter):
ipl_maskaimpeel_settings(peel_iter)
extent = image_in1.GetExtent()
voi = vtk.vtkExtractVOI()
voi.SetInput(image_in1)
voi.SetVOI(extent[0], extent[1], extent[2], extent[3], extent[4],
extent[5])
voi.Update()
shift = vtk.vtkImageShiftScale()
shift.SetInputConnection(voi.GetOutputPort())
shift.SetOutputScalarTypeToUnsignedChar()
shift.Update()
mask = vtk.vtkImageMask()
mask.SetImageInput(image_in2)
mask.SetMaskInput(shift.GetOutput())
mask.SetMaskedOutputValue(0)
mask.Update()
if peel_iter != 0:
erode = vtk.vtkImageContinuousErode3D()
erode.SetInputConnection(mask.GetOutputPort())
erode.SetKernelSize(peel_iter + 1, peel_iter + 1, peel_iter + 1)
erode.Update()
mask = erode
image_out = mask.GetOutput()
return image_out
def ipl_erosion(image_in, erode_distance):
ipl_erosion_settings(erode_distance)
extent = image_in.GetExtent()
#Actual distance of pixel erosion
distance = erode_distance + 1
pad = vtk.vtkImageReslice()
pad.SetInput(image_in)
pad.SetOutputExtent(extent[0], extent[1], extent[2], extent[3], extent[4],
extent[5])
pad.Update()
#Kernel size is twice the dilation distance plus one for the center voxel
erode = vtk.vtkImageContinuousErode3D()
erode.SetInputConnection(pad.GetOutputPort())
erode.SetKernelSize(2 * distance + 1, 2 * distance + 1, 2 * distance + 1)
erode.Update()
voi = vtk.vtkExtractVOI()
voi.SetInput(erode.GetOutput())
voi.SetVOI(extent[0] + distance, extent[1] - distance,
extent[2] + distance, extent[3] - distance,
extent[4] + distance, extent[5] - distance)
voi.Update()
image_out = voi.GetOutput()
return image_out
def __init__(self):
"""
Initialization
"""
MorphologicalFilter.__init__(self)
self.vtkfilter = vtk.vtkImageContinuousErode3D()
self.vtkfilter.AddObserver('ProgressEvent', lib.messenger.send)
lib.messenger.connect(self.vtkfilter, "ProgressEvent", self.updateProgress)
self.filterDesc = "Replaces each pixel/voxel with minimum value inside kernel\nInput: Grayscale/Binary image\nOutput: Grayscale/Binary image"
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(self,
module_manager,
vtk.vtkImageContinuousErode3D(),
'Processing.', ('vtkImageData', ),
('vtkImageData', ),
replaceDoc=True,
inputFunctions=None,
outputFunctions=None)
def __init__(self, module_manager):
# initialise our base class
ModuleBase.__init__(self, module_manager)
# main morph gradient
self._imageDilate = vtk.vtkImageContinuousDilate3D()
self._imageErode = vtk.vtkImageContinuousErode3D()
self._imageMath = vtk.vtkImageMathematics()
self._imageMath.SetOperationToSubtract()
self._imageMath.SetInput1(self._imageDilate.GetOutput())
self._imageMath.SetInput2(self._imageErode.GetOutput())
# inner gradient
self._innerImageMath = vtk.vtkImageMathematics()
self._innerImageMath.SetOperationToSubtract()
self._innerImageMath.SetInput1(None) # has to take image
self._innerImageMath.SetInput2(self._imageErode.GetOutput())
# outer gradient
self._outerImageMath = vtk.vtkImageMathematics()
self._outerImageMath.SetOperationToSubtract()
self._outerImageMath.SetInput1(self._imageDilate.GetOutput())
self._outerImageMath.SetInput2(None) # has to take image
module_utils.setup_vtk_object_progress(
self, self._imageDilate, 'Performing greyscale 3D dilation')
module_utils.setup_vtk_object_progress(
self, self._imageErode, 'Performing greyscale 3D erosion')
module_utils.setup_vtk_object_progress(
self, self._imageMath, 'Subtracting erosion from '
'dilation')
module_utils.setup_vtk_object_progress(
self, self._innerImageMath, 'Subtracting erosion from '
'image (inner)')
module_utils.setup_vtk_object_progress(
self, self._outerImageMath, 'Subtracting image from '
'dilation (outer)')
self._config.kernelSize = (3, 3, 3)
configList = [('Kernel size:', 'kernelSize', 'tuple:int,3', 'text',
'Size of the kernel in x,y,z dimensions.')]
ScriptedConfigModuleMixin.__init__(
self, configList, {
'Module (self)': self,
'vtkImageContinuousDilate3D': self._imageDilate,
'vtkImageContinuousErode3D': self._imageErode,
'vtkImageMathematics': self._imageMath
})
self.sync_module_logic_with_config()
def __init__(self):
"""
Initialization
"""
MorphologicalFilter.__init__(self)
self.vtkfilter = vtk.vtkImageContinuousErode3D()
self.vtkfilter.AddObserver('ProgressEvent', lib.messenger.send)
lib.messenger.connect(self.vtkfilter, "ProgressEvent",
self.updateProgress)
self.filterDesc = "Replaces each pixel/voxel with minimum value inside kernel\nInput: Grayscale/Binary image\nOutput: Grayscale/Binary image"
def erode(self, neighbours=(2, 2, 2)):
"""Replace a voxel with the minimum over an ellipsoidal neighborhood of voxels.
If `neighbours` of an axis is 1, no processing is done on that axis.
See example script: |erode_dilate.py|_
"""
ver = vtk.vtkImageContinuousErode3D()
ver.SetInputData(self._data)
ver.SetKernelSize(neighbours[0], neighbours[1], neighbours[2])
ver.Update()
return self._update(ver.GetOutput())
def __init__(self, module_manager):
# initialise our base class
ModuleBase.__init__(self, module_manager)
NoConfigModuleMixin.__init__(self)
# these will be our markers
self._inputPoints = None
# we can't connect the image input directly to the masksource,
# so we have to keep track of it separately.
self._inputImage = None
self._inputImageObserverID = None
# we need to modify the mask (I) as well. The problem with a
# ProgrammableFilter is that you can't request GetOutput() before
# the input has been set...
self._maskSource = vtk.vtkProgrammableSource()
self._maskSource.SetExecuteMethod(self._maskSourceExecute)
# we'll use this to synthesise a volume according to the seed points
self._markerSource = vtk.vtkProgrammableSource()
self._markerSource.SetExecuteMethod(self._markerSourceExecute)
# second input is J (the marker)
# we'll use this to change the markerImage into something we can use
self._imageThreshold = vtk.vtkImageThreshold()
# everything equal to or above 1.0 will be "on"
self._imageThreshold.ThresholdByUpper(1.0)
self._imageThresholdObserverID = self._imageThreshold.AddObserver(
'EndEvent', self._observerImageThreshold)
self._viewFrame = self._createViewFrame(
{'Module (self)' : self})
# we're not going to give imageErode any input... that's going to
# to happen manually in the execute_module function :)
self._imageErode = vtk.vtkImageContinuousErode3D()
self._imageErode.SetKernelSize(3,3,3)
module_utils.setup_vtk_object_progress(self, self._imageErode,
'Performing greyscale 3D erosion')
self._sup = vtk.vtkImageMathematics()
self._sup.SetOperationToMax()
self._sup.SetInput1(self._imageErode.GetOutput())
self._sup.SetInput2(self._maskSource.GetStructuredPointsOutput())
# pass the data down to the underlying logic
self.config_to_logic()
# and all the way up from logic -> config -> view to make sure
self.syncViewWithLogic()
def __init__(self, module_manager):
# initialise our base class
ModuleBase.__init__(self, module_manager)
NoConfigModuleMixin.__init__(self)
# these will be our markers
self._inputPoints = None
# we can't connect the image input directly to the masksource,
# so we have to keep track of it separately.
self._inputImage = None
self._inputImageObserverID = None
# we need to modify the mask (I) as well. The problem with a
# ProgrammableFilter is that you can't request GetOutput() before
# the input has been set...
self._maskSource = vtk.vtkProgrammableSource()
self._maskSource.SetExecuteMethod(self._maskSourceExecute)
# we'll use this to synthesise a volume according to the seed points
self._markerSource = vtk.vtkProgrammableSource()
self._markerSource.SetExecuteMethod(self._markerSourceExecute)
# second input is J (the marker)
# we'll use this to change the markerImage into something we can use
self._imageThreshold = vtk.vtkImageThreshold()
# everything equal to or above 1.0 will be "on"
self._imageThreshold.ThresholdByUpper(1.0)
self._imageThresholdObserverID = self._imageThreshold.AddObserver(
'EndEvent', self._observerImageThreshold)
self._viewFrame = self._createViewFrame({'Module (self)': self})
# we're not going to give imageErode any input... that's going to
# to happen manually in the execute_module function :)
self._imageErode = vtk.vtkImageContinuousErode3D()
self._imageErode.SetKernelSize(3, 3, 3)
module_utils.setup_vtk_object_progress(
self, self._imageErode, 'Performing greyscale 3D erosion')
self._sup = vtk.vtkImageMathematics()
self._sup.SetOperationToMax()
self._sup.SetInput1(self._imageErode.GetOutput())
self._sup.SetInput2(self._maskSource.GetStructuredPointsOutput())
# pass the data down to the underlying logic
self.config_to_logic()
# and all the way up from logic -> config -> view to make sure
self.syncViewWithLogic()
#!/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.vtkImageReader()
reader.SetDataByteOrderToLittleEndian()
reader.SetDataExtent(0,63,0,63,1,93)
reader.SetFilePrefix("" + str(VTK_DATA_ROOT) + "/Data/headsq/quarter")
reader.SetDataMask(0x7fff)
dilate = vtk.vtkImageContinuousDilate3D()
dilate.SetInputConnection(reader.GetOutputPort())
dilate.SetKernelSize(11,11,1)
erode = vtk.vtkImageContinuousErode3D()
erode.SetInputConnection(dilate.GetOutputPort())
erode.SetKernelSize(11,11,1)
viewer = vtk.vtkImageViewer()
viewer.SetInputConnection(erode.GetOutputPort())
viewer.SetColorWindow(2000)
viewer.SetColorLevel(1000)
viewer.Render()
# --- end of script --
#!/usr/bin/env python
import vtk
from vtk.util.misc import vtkGetDataRoot
VTK_DATA_ROOT = vtkGetDataRoot()
# Image pipeline
reader = vtk.vtkImageReader()
reader.SetDataByteOrderToLittleEndian()
reader.SetDataExtent(0, 63, 0, 63, 1, 93)
reader.SetFilePrefix("" + str(VTK_DATA_ROOT) + "/Data/headsq/quarter")
reader.SetDataMask(0x7fff)
dilate = vtk.vtkImageContinuousDilate3D()
dilate.SetInputConnection(reader.GetOutputPort())
dilate.SetKernelSize(11, 11, 1)
erode = vtk.vtkImageContinuousErode3D()
erode.SetInputConnection(dilate.GetOutputPort())
erode.SetKernelSize(11, 11, 1)
viewer = vtk.vtkImageViewer()
viewer.SetInputConnection(erode.GetOutputPort())
viewer.SetColorWindow(2000)
viewer.SetColorLevel(1000)
viewer.Render()
# --- end of script --
def erode(image,kernel):
erode = vtk.vtkImageContinuousErode3D()
erode.SetInput(image)
erode.SetKernelSize(kernel[0],kernel[1],kernel[2])
erode.Update()
return erode.GetOutput()
def __init__(self, module_manager):
# initialise our base class
ModuleBase.__init__(self, module_manager)
# main morph gradient
self._imageDilate = vtk.vtkImageContinuousDilate3D()
self._imageErode = vtk.vtkImageContinuousErode3D()
self._imageMath = vtk.vtkImageMathematics()
self._imageMath.SetOperationToSubtract()
self._imageMath.SetInput1(self._imageDilate.GetOutput())
self._imageMath.SetInput2(self._imageErode.GetOutput())
# inner gradient
self._innerImageMath = vtk.vtkImageMathematics()
self._innerImageMath.SetOperationToSubtract()
self._innerImageMath.SetInput1(None) # has to take image
self._innerImageMath.SetInput2(self._imageErode.GetOutput())
# outer gradient
self._outerImageMath = vtk.vtkImageMathematics()
self._outerImageMath.SetOperationToSubtract()
self._outerImageMath.SetInput1(self._imageDilate.GetOutput())
self._outerImageMath.SetInput2(None) # has to take image
module_utils.setup_vtk_object_progress(self, self._imageDilate,
'Performing greyscale 3D dilation')
module_utils.setup_vtk_object_progress(self, self._imageErode,
'Performing greyscale 3D erosion')
module_utils.setup_vtk_object_progress(self, self._imageMath,
'Subtracting erosion from '
'dilation')
module_utils.setup_vtk_object_progress(self, self._innerImageMath,
'Subtracting erosion from '
'image (inner)')
module_utils.setup_vtk_object_progress(self, self._outerImageMath,
'Subtracting image from '
'dilation (outer)')
self._config.kernelSize = (3, 3, 3)
configList = [
('Kernel size:', 'kernelSize', 'tuple:int,3', 'text',
'Size of the kernel in x,y,z dimensions.')]
ScriptedConfigModuleMixin.__init__(
self, configList,
{'Module (self)' : self,
'vtkImageContinuousDilate3D' : self._imageDilate,
'vtkImageContinuousErode3D' : self._imageErode,
'vtkImageMathematics' : self._imageMath})
self.sync_module_logic_with_config()
