def ComputeDistanceMap(self, image):
"""Compute the Euclidean distance transform of an image"""
# experimental, in-place scipy work
logging.info("Computing Euclidean distance transform...")
n = image.get_array()
n[:] = scipy.ndimage.morphology.distance_transform_edt(n).astype(
n.dtype)
# image.GetPointData().GetScalars().Modified()
image.ScalarsModified()
logging.info("Distance transform applied")
return image
# _filter = vtk.vtkImageEuclideanDistance()
# _filter.SetInput(image.GetRealImage())
# _filter.AddObserver('ProgressEvent', self.HandleVTKProgressEvent)
# _filter.SetProgressText("Computing distance transform...")
logging.info("Distance transform applied")
# _cast = vtk.vtkImageCast()
# _cast.SetInput(_filter.GetOutput())
# _cast.SetOutputScalarType(image.GetScalarType())
# _cast.Update()
return MVImage.MVImage(_cast.GetOutputPort(), input=image)
def DownsampleImage(self, image, nbits=8):
"""Downsamples an image"""
image.SetReleaseDataFlag(1)
# get the min and max values from the image
(minval, maxval) = image.GetScalarRange()
# create an 8-bit version of this image
_filter = vtk.vtkImageShiftScale()
_filter.SetInput(image.GetRealImage())
_filter.SetShift(-minval)
try:
if nbits == 8:
_filter.SetScale(255.0 / (maxval - minval))
elif nbits == 16:
_filter.SetScale(65535.0 / (maxval - minval))
except ZeroDivisionError:
logging.exception("DownsampleImage")
_filter.SetScale(1.0)
if nbits == 8:
_filter.SetOutputScalarTypeToUnsignedChar()
elif nbits == 16:
_filter.SetOutputScalarTypeToShort()
elif nbits == 32:
_filter.SetOutputScalarTypeToFloat()
elif nbits == 64:
_filter.SetOutputScalarTypeToDouble()
_filter.AddObserver('ProgressEvent', self.HandleVTKProgressEvent)
_filter.SetProgressText("Downsampling to %d-bit..." % nbits)
logging.info("Image downsampled to {0}-bit".format(nbits))
_filter.Update()
return MVImage.MVImage(_filter.GetOutputPort(), input=image)
def AnisotropicFilter(self,
image,
num_iterations,
diffusion_threshold,
diffusion_factor,
faces_on=True,
edges_on=True,
corners_on=True):
"""Returns a edge-preserving smoothed version of image"""
image.SetReleaseDataFlag(1)
_filter = vtk.vtkImageAnisotropicDiffusion3D()
_filter.SetNumberOfIterations(int(num_iterations))
_filter.SetDiffusionThreshold(float(diffusion_threshold))
_filter.SetDiffusionFactor(float(diffusion_factor))
_filter.SetFaces(int(faces_on))
_filter.SetEdges(int(edges_on))
_filter.SetCorners(int(corners_on))
# we need this here because there are two paths into this routine
if isinstance(image, MVImage.MVImage):
real_image = image.GetRealImage()
else:
real_image = image
_filter.SetInput(real_image)
_filter.SetProgressText("Smoothing image...")
_filter.AddObserver('ProgressEvent', self.HandleVTKProgressEvent)
logging.info("Anisotropic filter applied")
_filter.Update()
return MVImage.MVImage(_filter.GetOutputPort(), input=image)
def ImageInvert(self, image):
"""Inverts an image greylevel values"""
# image.SetReleaseDataFlag(1)
_filter = vtkImageInvertFilter()
_filter.SetInput(image.GetRealImage())
_filter.AddObserver('ProgressEvent', self.HandleVTKProgressEvent)
_filter.SetProgressText("Inverting...")
logging.info("Image inverted")
return MVImage.MVImage(_filter.GetOutputPort(), input=image)
def onRescaleImageButton(self, event):
image = component.getUtility(ICurrentImage)
_filter = self.Get_filter()
if _filter is None:
return
with wx.BusyCursor():
self.GetMicroView().SetInput(
MVImage.MVImage(_filter.GetOutputPort(), input=image))
def ConvertToGrayScale(self, image):
"""Convert Image to grayscale representation"""
image.SetReleaseDataFlag(1)
_filter = vtkImageMagnitude2()
_filter.SetInput(image.GetRealImage())
_filter.AddObserver('ProgressEvent', self.HandleVTKProgressEvent)
_filter.SetProgressText("Converting to grayscale...")
logging.info("Image converted to grayscale")
_filter.Update()
return MVImage.MVImage(_filter.GetOutputPort(), input=image)
def ImageFlip(self, image, axis):
"""Flips image about a given axis, without doubling memory"""
# image.SetReleaseDataFlag(1)
_filter = vtkImageInPlaceMirrorFilter()
_filter.SetAxis(axis)
_filter.SetInputConnection(image.GetOutputPort())
_filter.SetProgressText("Flipping image...")
_filter.AddObserver('ProgressEvent', self.HandleVTKProgressEvent)
logging.info("Image flipped")
_filter.Update()
return MVImage.MVImage(_filter.GetOutputPort(), input=image)
def OpenCloseImageFilter(self, image, settings):
"""Open or close an image"""
image.SetReleaseDataFlag(1)
_filter = vtk.vtkImageOpenClose3D()
_filter.SetInput(image.GetRealImage())
_filter.AddObserver('ProgressEvent', self.HandleVTKProgressEvent)
_filter.SetProgressText("Opening/Closing...")
_filter.SetKernelSize(settings['KernelSizeX'], settings['KernelSizeY'],
settings['KernelSizeZ'])
_filter.SetOpenValue(settings['OpenValue'])
_filter.SetCloseValue(settings['CloseValue'])
logging.info("Open/close filter applied")
return MVImage.MVImage(_filter.GetOutputPort(), input=image)
def ImageThreshold(self, image, threshold_value):
"""Threshold an image"""
image.SetReleaseDataFlag(1)
_filter = vtk.vtkImageThreshold()
_filter.ReplaceInOn()
_filter.ReplaceOutOn()
_filter.SetInValue(1)
_filter.SetOutValue(0)
_filter.SetOutputScalarType(3)
_filter.SetInput(image.GetRealImage())
_filter.ThresholdByUpper(threshold_value)
_filter.AddObserver('ProgressEvent', self.HandleVTKProgressEvent)
_filter.SetProgressText("Thresholding...")
logging.info("Image thresholded")
return MVImage.MVImage(_filter.GetOutputPort(), input=image)
def ImageGradientMagnitudeFilter(self, image):
"""Returns the image gradient magnitude of image"""
image.SetReleaseDataFlag(1)
_filter = vtk.vtkImageGradientMagnitude()
# we need this here because there are two paths into this routine
if isinstance(image, MVImage.MVImage):
real_image = image.GetRealImage()
else:
real_image = image
_filter.SetInput(real_image)
_filter.SetProgressText("Calculating Image gradient magnitude...")
_filter.AddObserver('ProgressEvent', self.HandleVTKProgressEvent)
logging.info("Image gradient magnitude applied")
_filter.Update()
return MVImage.MVImage(_filter.GetOutputPort(), input=image)
def GaussianFilter(self, image, radius=3, image3d=True):
"""Returns a Gaussian-smoothed version of image"""
n = image.get_array()
dims = n.shape
if image3d or len(dims) == 2 or dims[0] == 1:
# use VTK here - multithreaded performance
image.SetReleaseDataFlag(1)
_filter = vtk.vtkImageGaussianSmooth()
_filter.SetDimensionality(3)
_filter.SetRadiusFactor(radius)
_filter.SetInput(image.GetRealImage())
_filter.SetProgressText("Applying Gaussian filter...")
_filter.AddObserver('ProgressEvent', self.HandleVTKProgressEvent)
_filter.Update()
image = MVImage.MVImage(_filter.GetOutputPort(), input=image)
else:
# apply slice-by-slice filter
for z in range(dims[0]):
event.notify(
ProgressEvent("Applying slice-by-slice Gaussian filter...",
float(z) / dims[0]))
n[z, :] = scipy.ndimage.filters.gaussian_filter(n[z, :],
sigma=radius)
# image.GetPointData().GetScalars().Modified()
image.ScalarsModified()
event.notify(
ProgressEvent("Applying slice-by-slice Gaussian filter...",
1.0))
logging.info("Gaussian filter applied with radius={0}".format(radius))
return image
def MedianFilter(self, image, kernel_size=3, image3d=True):
"""Returns a median-filtered version of image"""
image.SetReleaseDataFlag(1)
ks = int(kernel_size)
ksx, ksy, ksz = ks, ks, ks
dims = image.GetDimensions()
if dims[2] == 1 or image3d == False:
ksz = 1
_filter = vtk.vtkImageMedian3D()
_filter.SetKernelSize(ksx, ksy, ksz)
_filter.SetInput(image.GetRealImage())
_filter.SetProgressText("Median filtering image...")
_filter.AddObserver('ProgressEvent', self.HandleVTKProgressEvent)
logging.info(
"Median filter applied with radius={0}".format(kernel_size))
_filter.Update()
return MVImage.MVImage(_filter.GetOutputPort(), input=image)