def execute(self, inputs=(1, 1), update=0, last=0):
"""
Execute filter in input image and return output image.
"""
if not lib.ProcessingFilter.ProcessingFilter.execute(self, inputs):
return None
image = self.getInput(1)
image = self.convertVTKtoITK(image)
squared = self.parameters["Squared"]
imageSpacing = self.parameters["ImageSpacing"]
invert = itk.InvertIntensityImageFilter[image, image].New()
danielsson = itk.DanielssonDistanceMapImageFilter[image, image].New()
invert.SetInput(image)
self.filter = danielsson
self.filter.AddObserver(itk.ProgressEvent(), self.pc.GetPointer())
self.filter.SetInput(invert.GetOutput())
self.filter.SetSquaredDistance(squared)
self.filter.SetUseImageSpacing(imageSpacing)
outputImage = self.filter.GetOutput()
outputImage.Update()
return outputImage
def execute(self, inputs, update = 0, last = 0):
"""
Execute the filter with given inputs and return the output
"""
if not lib.ProcessingFilter.ProcessingFilter.execute(self, inputs):
return None
image = self.getInput(1)
image = self.convertVTKtoITK(image)
if self.parameters["2D"]:
type,dim = self.getITKImageType(image)
self.filter = itk.SliceBySliceImageFilter[image,image].New()
fillHoles = eval("itk.GrayscaleFillholeImageFilter.I%s2I%s2.New()"%(type,type))
self.filter.SetFilter(fillHoles)
self.filter.SetInput(image)
else:
self.filter = itk.GrayscaleFillholeImageFilter[image,image].New()
self.filter.AddObserver(itk.ProgressEvent(),self.pc)
self.filter.SetInput(image)
output = self.filter.GetOutput()
output.Update()
return output
def execute(self, inputs=(1, 1), update=0, last=0):
"""
Execute filter in input image and return output image
"""
if not lib.ProcessingFilter.ProcessingFilter.execute(self, inputs):
return None
self.eventDesc = "Binary thinning image"
inputImage = self.getInput(1)
inputImage = self.convertVTKtoITK(inputImage)
largestRegion = inputImage.GetLargestPossibleRegion()
dim = largestRegion.GetImageDimension()
if dim == 3 and largestRegion.GetSize().GetElement(2) == 1:
dim = 2
extracted = 1
itkType = self.getITKImageType(inputImage)[0]
extractFilter = eval("itk.ExtractImageFilter.I%s3I%s2.New()" %
(type, type))
region = itk.ImageRegion._3()
size = itk.Size._3()
index = itk.Index._3()
for i in range(2):
size.SetElement(i, largestRegion.GetSize().GetElement(i))
index.SetElement(i, largestRegion.GetIndex().GetElement(i))
size.SetElement(2, 0)
index.SetElement(2, 0)
region.SetSize(size)
region.SetIndex(index)
extractFilter.SetExtractionRegion(region)
extractFilter.SetInput(inputImage)
input = extractFilter.GetOutput()
input.Update()
else:
extracted = 0
input = inputImage
if dim == 2:
self.filter = itk.BinaryThinningImageFilter[input, input].New()
else:
self.filter = itk.BinaryThinning3DImageFilter[input, input].New()
self.filter.AddObserver(itk.ProgressEvent(), self.pc.GetPointer())
self.filter.SetInput(input)
outputImage = self.filter.GetOutput()
outputImage.Update()
return outputImage
def get_label_object_attributes(dataset, progress_callback=None):
"""Compute shape attributes of integer-labeled objects in a dataset. Returns
an ITK shape label map. An optional progress_callback function can be passed
in. This callback is expected to take one argument, a floating-point number
in the range [0, 1] that represents the progress amount. It returns a value
indicating whether the caller should be cancelled.
"""
try:
import itk
# Get an ITK image from the data set
itk_image = convert_vtk_to_itk_image(dataset)
itk_image_type = type(itk_image)
# Get an appropriate LabelImageToShapelLabelMapFilter type for the
# input.
inputTypes = [
x[0] for x in list(itk.LabelImageToShapeLabelMapFilter.keys())
] # noqa
filterTypeIndex = inputTypes.index(itk_image_type)
if filterTypeIndex < 0:
raise Exception("No suitable filter type for input type %s" %
type(itk_image_type))
# Now take the connected components results and compute things like
# volume and surface area.
shape_filter = \
list(itk.LabelImageToShapeLabelMapFilter.values())[filterTypeIndex].New() # noqa
shape_filter.SetInput(itk_image)
def progress_func():
progress = shape_filter.GetProgress()
if progress_callback is not None:
abort = progress_callback(progress)
if abort:
shape_filter.AbortGenerateDataOn()
progress_observer = itk.PyCommand.New()
progress_observer.SetCommandCallable(progress_func)
shape_filter.AddObserver(itk.ProgressEvent(), progress_observer)
try:
shape_filter.Update()
except RuntimeError:
return None
label_map = shape_filter.GetOutput()
return label_map
except Exception as exc:
print("Problem encountered while running label_object_attributes")
raise (exc)
def initialize(self):
self.filter = self.DiffeoRegistrationFilterType.New(
StandardDeviations=self.STANDARD_DEVIATIONS)
# Print iteration updates
if (self.verbose):
def print_iteration():
print(f'Iteration: {self.filter.GetElapsedIterations()}'
f' Metric: {self.filter.GetMetric()}'
f' RMS Change: {self.filter.GetRMSChange()}')
self.filter.AddObserver(itk.ProgressEvent(), print_iteration)
def observe_filter_progress(transform, filter, start_pct, end_pct):
assert start_pct < end_pct
pct_diff = end_pct - start_pct
def progress_func():
progress = filter.GetProgress()
transform.progress.value = start_pct + int(progress * pct_diff)
if transform.canceled:
filter.AbortGenerateDataOn()
import itk
progress_observer = itk.PyCommand.New()
progress_observer.SetCommandCallable(progress_func)
filter.AddObserver(itk.ProgressEvent(), progress_observer)
def New(self, *args, **kargs):
import itk
itk.set_inputs(self, args, kargs)
# now, try to add observer to display progress
if "auto_progress" in kargs.keys():
if kargs["auto_progress"] in [True, 1]:
callback = itk.terminal_progress_callback
elif kargs["auto_progress"] == 2:
callback = itk.simple_progress_callback
else:
callback = None
elif itkConfig.ProgressCallback:
callback = itkConfig.ProgressCallback
else:
callback = None
if callback and not issubclass(self.__class__, itk.Command):
try:
name = self.__class__.__name__
def progress():
# self and callback are kept referenced with a closure
callback(name, self.GetProgress())
self.AddObserver(itk.ProgressEvent(), progress)
except AttributeError:
# as this feature is designed for prototyping, it's not really a
# problem if an object doesn't have progress reporter, so adding
# reporter can silently fail
pass
except Exception:
# it seems that something else has gone wrong...
# silently fail to maintain backward compatibility
pass
if itkConfig.NotInPlace and "SetInPlace" in dir(self):
self.SetInPlace(False)
if itk.auto_pipeline.current is not None:
itk.auto_pipeline.current.connect(self)
return self
def register(self,
template_mesh: MeshType,
target_mesh: MeshType,
filepath: str = None,
verbose=False,
max_iterations=MAX_ITERATIONS) -> (TransformType, MeshType):
template_image = self.mesh_to_image(template_mesh)
target_image = self.mesh_to_image(target_mesh, template_image)
self.filter.SetFixedImage(template_image)
self.filter.SetMovingImage(target_image)
self.filter.SetNumberOfIterations(max_iterations)
def print_iteration():
metric = self.filter.GetMetric()
print(f'{metric}')
if (verbose):
self.filter.AddObserver(itk.ProgressEvent(), print_iteration)
# Run registration
self.filter.Update()
# Update template mesh to match target
transform = self.TransformType.New()
transform.SetDisplacementField(self.filter.GetOutput())
# TODO pythonic style
TransformFilterType = \
itk.TransformMeshFilter[self.MeshType,
self.MeshType,
itk.Transform[itk.F,self.Dimension,self.Dimension]]
transform_filter = TransformFilterType.New(Input=template_mesh,
Transform=transform)
transform_filter.Update()
if filepath is not None:
itk.meshwrite(transform_filter.GetOutput(), filepath)
if (verbose):
print(f'Wrote resulting mesh to {filepath}')
return (transform, transform_filter.GetOutput())
def New(self, *args, **kargs):
import sys, itk
itk.set_inputs(self, args, kargs)
# now, try to add observer to display progress
if "auto_progress" in kargs.keys():
if kargs["auto_progress"] in [True, 1]:
callback = itk.terminal_progress_callback
elif kargs["auto_progress"] == 2:
callback = itk.simple_progress_callback
else:
callback = None
elif itkConfig.ProgressCallback:
callback = itkConfig.ProgressCallback
else:
callback = None
if callback:
try:
name = self.__class__.__name__
def progress():
# self and callback are kept referenced with a closure
callback(name, self.GetProgress())
self.AddObserver(itk.ProgressEvent(), progress)
except:
# it seems that something goes wrong...
# as this feature is designed for prototyping, it's not really a problem
# if an object don't have progress reporter, so adding reporter can silently fail
pass
if itkConfig.NotInPlace and "SetInPlace" in dir(self):
self.SetInPlace(False)
if itk.auto_pipeline.current != None:
itk.auto_pipeline.current.connect(self)
return self
def execute(self, inputs=(1, 1), update=0, last=0):
"""
Execute filter in input image and return output image
"""
if not lib.ProcessingFilter.ProcessingFilter.execute(self, inputs):
return None
self.eventDesc = "Mean filter"
inputImage = self.getInput(1)
inputImage = self.convertVTKtoITK(inputImage)
self.filter = itk.MeanImageFilter[inputImage, inputImage].New()
self.filter.AddObserver(itk.ProgressEvent(), self.pc.GetPointer())
radiusX = self.parameters["X"]
radiusY = self.parameters["Y"]
radiusZ = self.parameters["Z"]
spacing = inputImage.GetSpacing()
dim = inputImage.GetLargestPossibleRegion().GetImageDimension()
if self.parameters["UseImageSpacing"]:
radiusX = int(radiusX * (1.0 / spacing.GetElement(0)) + 0.5)
radiusY = int(radiusY * (1.0 / spacing.GetElement(1)) + 0.5)
if dim > 2:
radiusZ = int(radiusZ * (1.0 / spacing.GetElement(2)) + 0.5)
if dim == 2:
self.filter.SetRadius((radiusX, radiusY))
elif dim == 3:
self.filter.SetRadius((radiusX, radiusY, radiusZ))
self.filter.SetInput(inputImage)
outputImage = self.filter.GetOutput()
if update:
outputImage.Update()
return outputImage
def execute(self, inputs=(1, 1), update=0, last=0):
"""
Execute filter in input image and return output image
"""
if not lib.ProcessingFilter.ProcessingFilter.execute(self, inputs):
return None
self.eventDesc = "Dynamic thresholding image"
inputImage = self.getInput(1)
inputImage = self.convertVTKtoITK(inputImage)
dynamicThresholdFilter = itk.DynamicThreshold3DImageFilter[
inputImage, inputImage].New()
self.filter = dynamicThresholdFilter
dynamicThresholdFilter.AddObserver(itk.ProgressEvent(), self.pc)
dynamicThresholdFilter.SetRadius(self.parameters["X"],
self.parameters["Y"],
self.parameters["Z"])
dynamicThresholdFilter.SetThreshold(self.parameters["Threshold"])
if self.parameters["StatisticsType"] == MEAN:
dynamicThresholdFilter.SetStatisticsTypeMean()
else:
dynamicThresholdFilter.SetStatisticsTypeMedian()
if self.parameters["UseImageSpacing"]:
dynamicThresholdFilter.SetUseImageSpacingOn()
else:
dynamicThresholdFilter.SetUseImageSpacingOff()
dynamicThresholdFilter.SetInput(inputImage)
outputImage = dynamicThresholdFilter.GetOutput()
if update:
outputImage.Update()
return outputImage
# http://www.apache.org/licenses/LICENSE-2.0.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import itk
Dimension = 2
PixelType = itk.UC
ImageType = itk.Image[PixelType, Dimension]
source = itk.GaussianImageSource[ImageType].New()
size = itk.Size[Dimension]()
size.Fill(128)
source.SetSize(size)
sigma = itk.FixedArray[itk.D, Dimension]()
sigma.Fill(45.0)
source.SetSigma(sigma)
def myCommand():
print('Progress: ' + str(source.GetProgress()))
source.AddObserver(itk.ProgressEvent(), myCommand)
source.Update()
def connected_components(dataset, background_value=0, progress_callback=None):
try:
import numpy as np
import itk
except Exception as exc:
print("Could not import necessary module(s)")
print(exc)
if np.issubdtype(dataset.active_scalars.dtype, np.floating):
raise Exception(
"Connected Components works only on images with integral types.")
# Add a try/except around the ITK portion. ITK exceptions are
# passed up to the Python layer, so we can at least report what
# went wrong with the script, e.g,, unsupported image type.
try:
# Get the ITK image. The input is assumed to have an integral type.
# Take care of casting to an unsigned short image so we can store up
# to 65,535 connected components (the number of connected components
# is limited to the maximum representable number in the voxel type
# of the input image in the ConnectedComponentsFilter).
array = dataset.active_scalars.astype(np.uint16)
itk_image = itk.GetImageViewFromArray(array)
itk_image.SetSpacing(dataset.spacing)
itk_image_type = type(itk_image)
# ConnectedComponentImageFilter
connected_filter = itk.ConnectedComponentImageFilter[
itk_image_type, itk_image_type].New()
connected_filter.SetBackgroundValue(background_value)
connected_filter.SetInput(itk_image)
if progress_callback is not None:
def connected_progress_func():
progress = connected_filter.GetProgress()
abort = progress_callback(progress * 0.5)
connected_filter.SetAbortGenerateData(abort)
connected_observer = itk.PyCommand.New()
connected_observer.SetCommandCallable(connected_progress_func)
connected_filter.AddObserver(itk.ProgressEvent(),
connected_observer)
# Relabel filter. This will compress the label numbers to a
# continugous range between 1 and n where n is the number of
# labels. It will also sort the components from largest to
# smallest, where the largest component has label 1, the
# second largest has label 2, and so on...
relabel_filter = itk.RelabelComponentImageFilter[itk_image_type,
itk_image_type].New()
relabel_filter.SetInput(connected_filter.GetOutput())
relabel_filter.SortByObjectSizeOn()
if progress_callback is not None:
def relabel_progress_func():
progress = relabel_filter.GetProgress()
abort = progress_callback(progress * 0.5 + 0.5)
relabel_filter.SetAbortGenerateData(abort)
relabel_observer = itk.PyCommand.New()
relabel_observer.SetCommandCallable(relabel_progress_func)
relabel_filter.AddObserver(itk.ProgressEvent(), relabel_observer)
try:
relabel_filter.Update()
except RuntimeError:
return
itk_image_data = relabel_filter.GetOutput()
label_buffer = itk.PyBuffer[itk_image_type].GetArrayFromImage(
itk_image_data)
# Flip the labels so that the largest component has the highest label
# value, e.g., the labeling ordering by size goes from [1, 2, ... N] to
# [N, N-1, N-2, ..., 1]. Note that zero is the background value, so we
# do not want to change it.
import numpy as np
minimum = 1 # Minimum label is always 1, background is 0
maximum = np.max(label_buffer)
# Try more memory-efficient approach
gt_zero = label_buffer > 0
label_buffer[gt_zero] = minimum - label_buffer[gt_zero] + maximum
# Transpose the data to Fortran indexing
dataset.active_scalars = label_buffer.transpose([2, 1, 0])
except Exception as exc:
print("Problem encountered while running ConnectedComponents")
raise exc
def setup_itk_object_progress(dvModule,
obj,
nameOfObject,
progressText,
objEvals=None,
module_manager=None):
"""
@param dvModlue: instance containing binding to obj. Usually this
is a DeVIDE module. If not, remember to pass module_manager
parameter.
@param obj: The ITK object that needs to be progress updated.
@param module_manager: If set, will be used as binding to
module_manager. If set to None, dvModule._module_manager will be
used. This can be used in cases when obj is NOT a member of a
DeVIDE module, iow when dvModule is not a DeVIDE module.
"""
# objEvals is on optional TUPLE of obj attributes that will be called
# at each progress callback and filled into progressText via the Python
# % operator. In other words, all string attributes in objEvals will be
# eval'ed on the object instance and these values will be filled into
# progressText, which has to contain the necessary number of format tokens
# first we have to find the attribute of dvModule that binds
# to obj. We _don't_ want to have a binding to obj hanging around
# in our callable, because this means that the ITK object can never
# be destroyed. Instead we look up the binding everytime the callable
# is invoked by making use of getattr on the devideModule binding.
# find attribute string of obj in dvModule
di = dvModule.__dict__.items()
objAttrString = None
for key, value in di:
if value is obj:
objAttrString = key
break
if not objAttrString:
raise Exception, 'Could not determine attribute string for ' \
'object %s.' % (obj.__class__.__name__)
if module_manager is None:
mm = dvModule._module_manager
else:
mm = module_manager
# sanity check objEvals
if type(objEvals) != type(()) and objEvals != None:
raise TypeError, 'objEvals should be a tuple or None.'
def commandCallable():
# setup for and get values of all requested objEvals
values = []
if type(objEvals) == type(()):
for objEval in objEvals:
values.append(eval('dvModule.%s.%s' %
(objAttrString, objEval)))
values = tuple(values)
# do the actual callback
mm.generic_progress_callback(
getattr(dvModule, objAttrString), nameOfObject,
getattr(dvModule, objAttrString).GetProgress(),
progressText % values)
# get rid of all bindings
del values
pc = itk.PyCommand.New()
pc.SetCommandCallable(commandCallable)
res = obj.AddObserver(itk.ProgressEvent(), pc)
elif itkConfig.ProgressCallback:
callback = itkConfig.ProgressCallback
else:
callback = None
if callback:
import itk
try:
def progress():
# newItkObject and callback are kept referenced with a closure
callback(self.__name__, newItkObject.GetProgress())
command = itk.PyCommand.New()
command.SetCommandCallable(progress)
newItkObject.AddObserver(itk.ProgressEvent(), command.GetPointer())
except:
# it seems that something goes wrong...
# as this feature is designed for prototyping, it's not really a problem
# if an object don't have progress reporter, so adding reporter can silently fail
pass
if itkConfig.NotInPlace:
if "SetInPlace" in dir(newItkObject):
newItkObject.SetInPlace(False)
return newItkObject
def image(input):
try:
def execute(self, inputs=(2, 2), update=0, last=0):
"""
Execute filter using speed image and feature image
@return Returns result active contour and result level set from which
the active contour is extracted from
"""
if not lib.ProcessingFilter.ProcessingFilter.execute(self, inputs):
return None
self.progressObj.setProgress(0.0)
lib.ProcessingFilter.ProcessingFilter.updateProgress(
self, None, "ProgressEvent")
initialModel = self.getInput(1)
featureImage = self.getInput(2)
initialModel = self.convertVTKtoITK(initialModel, cast=types.FloatType)
featureImage = self.convertVTKtoITK(featureImage, cast=types.FloatType)
dim = featureImage.GetLargestPossibleRegion().GetImageDimension()
imagetype = eval("itk.Image.F%d" % dim)
if "itkImageF" not in str(initialModel.__class__):
initialModel = self.castITKImage(initialModel, imagetype)
if "itkImageF" not in str(featureImage.__class__):
featureImage = self.castITKImage(featureImage, imagetype)
self.propagationScaling = self.parameters["PropagationScaling"]
self.curvatureScaling = self.parameters["CurvatureScaling"]
self.advectionScaling = self.parameters["AdvectionScaling"]
self.maxRMSError = self.parameters["MaxRMSError"]
self.iterations = self.parameters["Iterations"]
self.smooth = itk.CurvatureAnisotropicDiffusionImageFilter[
imagetype, imagetype].New()
self.smooth.SetTimeStep(0.0625)
self.smooth.SetNumberOfIterations(8)
self.smooth.SetConductanceParameter(0.5)
self.smooth.SetInput(featureImage)
self.gradient = itk.GradientMagnitudeRecursiveGaussianImageFilter[
imagetype, imagetype].New()
self.gradient.SetSigma(1.0)
self.gradient.SetInput(self.smooth.GetOutput())
self.sigmoid = itk.SigmoidImageFilter[imagetype, imagetype].New()
self.sigmoid.SetOutputMinimum(0.0)
self.sigmoid.SetOutputMaximum(1.0)
self.sigmoid.SetAlpha(self.parameters["Alpha"])
self.sigmoid.SetBeta(self.parameters["Beta"])
self.sigmoid.SetInput(self.gradient.GetOutput())
seedPoints = self.parameters["Seed"]
seeds = eval("itk.VectorContainer.UILSNF%d.New()" % dim)
seeds.Initialize()
initDist = self.parameters["InitialDistance"]
seedValue = -initDist
for i, seed in enumerate(seedPoints):
seedPos = eval("itk.Index._%d()" % dim)
seedPos[0] = seed[0]
seedPos[1] = seed[1]
if dim == 3:
seedPos[2] = seed[2]
node = eval("itk.LevelSetNode.F%d()" % dim)
node.SetValue(seedValue)
node.SetIndex(seedPos)
seeds.InsertElement(i, node)
fastMarch = itk.FastMarchingImageFilter[imagetype, imagetype].New()
fastMarch.SetTrialPoints(seeds)
fastMarch.SetSpeedConstant(1.0)
fastMarch.SetOutputSize(
initialModel.GetLargestPossibleRegion().GetSize())
fastMarch.SetOutputSpacing(initialModel.GetSpacing())
fastMarch.SetOutputOrigin(initialModel.GetOrigin())
pc = itk.PyCommand.New()
pc.SetCommandCallable(self.updateProgress)
self.filter = eval(
"itk.GeodesicActiveContourLevelSetImageFilter.IF%dIF%dF.New()" %
(dim, dim))
self.filter.SetPropagationScaling(self.propagationScaling)
self.filter.SetCurvatureScaling(self.curvatureScaling)
self.filter.SetAdvectionScaling(self.advectionScaling)
self.filter.SetMaximumRMSError(self.maxRMSError)
self.filter.SetInput(fastMarch.GetOutput())
self.filter.SetFeatureImage(self.sigmoid.GetOutput())
self.filter.SetNumberOfIterations(self.iterations)
self.filter.AddObserver(itk.ProgressEvent(), pc)
start = time.clock()
self.filter.Update()
end = time.clock()
duration = end - start
print "Geodesic Active Contour Level Set filter took %.2f s" % (
duration)
print "Max. no. iterations: %d" % (self.filter.GetNumberOfIterations())
print "Max. RMS error: %.3f" % (self.filter.GetMaximumRMSError())
print "No. elapsed iterations: %d" % (
self.filter.GetElapsedIterations())
print "RMS change: %.3f" % (self.filter.GetRMSChange())
self.zeroCrossing = itk.ZeroCrossingImageFilter[imagetype,
imagetype].New()
self.zeroCrossing.SetBackgroundValue(0)
self.zeroCrossing.SetForegroundValue(255)
self.zeroCrossing.SetInput(self.filter.GetOutput())
data = self.zeroCrossing.GetOutput()
data.Update()
#self.dataUnit.getSettings().set("BitDepth", 32)
self.dataUnit.getSettings().set("BitDepth", 8)
data = self.castITKImage(data, eval("itk.Image.UC%d" % dim))
self.progressObj.setProgress(1.0)
lib.ProcessingFilter.ProcessingFilter.updateProgress(
self, None, "ProgressEvent")
return data
inputImage)
preprocFilter.SetInput(inputImage)
def PreprocessingCommand():
progress = int(100 * preprocFilter.GetProgress())
if progress > PreprocessingCommand.progress:
PreprocessingCommand.progress = progress
print('\rProgress: {}%'.format(progress), end='')
sys.stdout.flush()
PreprocessingCommand.progress = -1
print('Running preprocessing...')
preprocFilter.AddObserver(itk.ProgressEvent(), PreprocessingCommand)
preprocFilter.Update()
print('')
# Write the result
print('Writing out {}'.format(outputPreprocessedFileName))
itk.imwrite(preprocFilter.GetOutput(), outputPreprocessedFileName)
# Create enhancmenet filters
Dimension = 3
EigenPixelType = itk.Vector[itk.F, Dimension]
EigenImageType = itk.Image[EigenPixelType, Dimension]
MaskType = itk.Image[itk.UC, Dimension]
FloatImageType = itk.Image[itk.F, Dimension]
eigenFilterType = itk.KrcahEigenToScalarImageFilter[EigenImageType,
FloatImageType, MaskType]
eigenFilterType = itk.DescoteauxEigenToScalarImageFilter[EigenImageType,
FloatImageType,
MaskType]
eigenFilter = eigenFilterType.New()
multiscaleFilter = itk.MultiScaleHessianEnhancementImageFilter.New(inputImage)
multiscaleFilter.SetInput(inputImage)
multiscaleFilter.SetEigenToScalarImageFilter(eigenFilter)
multiscaleFilter.SetSigmaArray(sigmaArray)
# Run the filter
def MyCommand():
progress = int(100 * multiscaleFilter.GetProgress())
if progress > MyCommand.progress:
MyCommand.progress = progress
print('\rProgress: {}%'.format(progress), end='')
sys.stdout.flush()
MyCommand.progress = -1
print('Running multiScaleFilter...')
multiscaleFilter.AddObserver(itk.ProgressEvent(), MyCommand)
multiscaleFilter.Update()
print('')
# Write the result
print('Writing results to {}'.format(outputMeasureFileName))
itk.imwrite(multiscaleFilter.GetOutput(), outputMeasureFileName)
def execute(self, inputs=(1, 1), update=0, last=0):
"""
Execute filter in input image and return output image
"""
if not lib.ProcessingFilter.ProcessingFilter.execute(self, inputs):
return None
self.eventDesc = "Correcting illumination"
inputImage = self.getInput(1)
inputImage = self.convertVTKtoITK(inputImage)
origOrigin = inputImage.GetOrigin()
origSpacing = inputImage.GetSpacing()
origSize = inputImage.GetLargestPossibleRegion().GetSize()
shrinkImage = inputImage
if self.parameters["ShrinkFactor"] > 1:
shrinkFilter = itk.ShrinkImageFilter[inputImage, inputImage].New()
shrinkFilter.SetInput(inputImage)
shrinkFilter.SetShrinkFactors(self.parameters["ShrinkFactor"])
shrinkImage = shrinkFilter.GetOutput()
shrinkImage.Update()
shrinkRegion = shrinkImage.GetLargestPossibleRegion()
dim = shrinkRegion.GetImageDimension()
maskImage = eval("itk.Image.UC%d.New()" % dim)
maskImage.SetRegions(shrinkRegion)
maskImage.Allocate()
maskImage.FillBuffer(1)
self.filter = itk.N3MRIBiasFieldCorrectionImageFilter[shrinkImage,
maskImage].New()
self.filter.SetInput(shrinkImage)
self.filter.SetMaskImage(maskImage)
self.filter.SetMaximumNumberOfIterations(
self.parameters["MaxIterations"])
self.filter.SetNumberOfFittingLevels(
self.parameters["NumFittingLevels"])
self.filter.AddObserver(itk.ProgressEvent(), self.pc.GetPointer())
self.filter.Update()
if self.parameters["ShrinkFactor"] > 1:
biasField = self.filter.GetBiasField()
resample = itk.ResampleImageFilter[biasField, biasField].New()
interpolator = eval(
"itk.LinearInterpolateImageFunction.IF%dD.New()" % dim)
castToFloat = itk.CastImageFilter[inputImage, biasField].New()
divider = itk.DivideImageFilter[biasField, biasField,
biasField].New()
castToOrig = itk.CastImageFilter[biasField, inputImage].New()
resample.SetInput(biasField)
resample.SetDefaultPixelValue(1.0)
resample.SetOutputOrigin(origOrigin)
resample.SetOutputSpacing(origSpacing)
resample.SetSize(origSize)
resample.SetInterpolator(interpolator.GetPointer())
castToFloat.SetInput(inputImage)
divider.SetInput1(castToFloat.GetOutput())
divider.SetInput2(resample.GetOutput())
castToOrig.SetInput(divider.GetOutput())
outputImage = castToOrig.GetOutput()
outputImage.Update()
else:
outputImage = self.filter.GetOutput()
return outputImage
