def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkImageGradientMagnitude(), 'Processing.',
('vtkImageData',), ('vtkImageData',),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
def BuildVTKGradientBasedFeatureImage(self):
cast = vtk.vtkImageCast()
cast.SetInputData(self.Image)
cast.SetOutputScalarTypeToFloat()
cast.Update()
gradientMagnitude = vtk.vtkImageGradientMagnitude()
gradientMagnitude.SetInputConnection(cast.GetOutputPort())
gradientMagnitude.SetDimensionality(self.Dimensionality)
gradientMagnitude.Update()
imageAdd = vtk.vtkImageMathematics()
imageAdd.SetInputConnection(gradientMagnitude.GetOutputPort())
imageAdd.SetOperationToAddConstant()
imageAdd.SetConstantC(1.0)
imageAdd.Update()
imageInvert = vtk.vtkImageMathematics()
imageInvert.SetInputConnection(imageAdd.GetOutputPort())
imageInvert.SetOperationToInvert()
imageInvert.SetConstantC(1E20)
imageInvert.DivideByZeroToCOn()
imageInvert.Update()
self.FeatureImage = vtk.vtkImageData()
self.FeatureImage.DeepCopy(imageInvert.GetOutput())
def BuildVTKGradientBasedFeatureImage(self):
cast = vtk.vtkImageCast()
cast.SetInputData(self.Image)
cast.SetOutputScalarTypeToFloat()
cast.Update()
gradientMagnitude = vtk.vtkImageGradientMagnitude()
gradientMagnitude.SetInputConnection(cast.GetOutputPort())
gradientMagnitude.SetDimensionality(self.Dimensionality)
gradientMagnitude.Update()
imageAdd = vtk.vtkImageMathematics()
imageAdd.SetInputConnection(gradientMagnitude.GetOutputPort())
imageAdd.SetOperationToAddConstant()
imageAdd.SetConstantC(1.0)
imageAdd.Update()
imageInvert = vtk.vtkImageMathematics()
imageInvert.SetInputConnection(imageAdd.GetOutputPort())
imageInvert.SetOperationToInvert()
imageInvert.SetConstantC(1E20)
imageInvert.DivideByZeroToCOn()
imageInvert.Update()
self.FeatureImage = vtk.vtkImageData()
self.FeatureImage.DeepCopy(imageInvert.GetOutput())
def vtkVOIdata(self, volum = 'GAUSSIAN'):
""" Modification du volume d'interet """
#-----------------------------------------
# Creation de la VOI
#-----------------------------------------
self.vtkVolum = vtk.vtkExtractVOI()
self.vtkVolum.SetInput(self.vtkVolumAll.GetOutput())
self.vtkVolum.SetVOI(self.VOI_pt1[0], self.VOI_pt2[0], \
self.VOI_pt1[1], self.VOI_pt2[1], \
self.VOI_pt1[2], self.VOI_pt2[2])
self.vtkVolumBlur = vtk.vtkImageGaussianSmooth()
#-----------------------------------------
# Creation du volume sur volume filtre gaussien
#-----------------------------------------
if volum == 'GAUSSIAN':
self.vtkVolumBlur.SetInputConnection(self.vtkVolum.GetOutputPort())
#-----------------------------------------
# Creation du volume sur volume filtre gradient + gaussien
#-----------------------------------------
if volum == 'GRADIENT':
self.vtkVolumGrad = vtk.vtkImageGradientMagnitude()
self.vtkVolumGrad.SetDimensionality(3)
self.vtkVolumGrad.HandleBoundariesOn()
self.vtkVolumGrad.SetInputConnection(self.vtkVolum.GetOutputPort())
self.vtkVolumBlur.SetInputConnection(self.vtkVolumGrad.GetOutputPort())
self.vtkVolumBlur.SetStandardDeviation(self.valGaussianFilter)
self.vtkVolumBlur.Update()
self.vtkVolumRange = self.vtkVolumBlur.GetOutput().GetScalarRange()
print " Range from Volume Of Interest : ", self.vtkVolumRange
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(self,
module_manager,
vtk.vtkImageGradientMagnitude(),
'Processing.', ('vtkImageData', ),
('vtkImageData', ),
replaceDoc=True,
inputFunctions=None,
outputFunctions=None)
def __init__(self, inputs = (1, 1)):
"""
Initialization
"""
ProcessingFilter.ProcessingFilter.__init__(self, inputs)
self.vtkfilter = vtk.vtkImageGradientMagnitude()
self.vtkfilter.SetDimensionality(3)
self.vtkfilter.AddObserver("ProgressEvent", lib.messenger.send)
lib.messenger.connect(self.vtkfilter, 'ProgressEvent', self.updateProgress)
self.eventDesc = "Performing edge detection (gradient magnitude)"
self.filterDesc = "Computes gradient magnitude of each pixel/voxel\nInput: Grayscale image\nOutput: Grayscale image"
def __init__(self, module_manager):
# initialise our base class
ModuleBase.__init__(self, module_manager)
self._imageGradientMagnitude = vtk.vtkImageGradientMagnitude()
self._imageGradientMagnitude.SetDimensionality(3)
module_utils.setup_vtk_object_progress(self, self._imageGradientMagnitude,
'Calculating gradient magnitude')
NoConfigModuleMixin.__init__(
self,
{'Module (self)' : self,
'vtkImageGradientMagnitude' : self._imageGradientMagnitude})
self.sync_module_logic_with_config()
def __init__(self, module_manager):
# initialise our base class
ModuleBase.__init__(self, module_manager)
self._imageGradientMagnitude = vtk.vtkImageGradientMagnitude()
self._imageGradientMagnitude.SetDimensionality(3)
module_utils.setup_vtk_object_progress(
self, self._imageGradientMagnitude,
'Calculating gradient magnitude')
NoConfigModuleMixin.__init__(
self, {
'Module (self)': self,
'vtkImageGradientMagnitude': self._imageGradientMagnitude
})
self.sync_module_logic_with_config()
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 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)
#!/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 --
#!/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 --
def gradientMagnitude2D(image):
gradient = vtk.vtkImageGradientMagnitude()
gradient.SetInput(image)
gradient.SetDimensionality(2)
gradient.HandleBoundariesOn()
return gradient.GetOutput()
def Execute(self):
if self.GaussFiltering:
gauss = vtk.vtkImageGaussianSmooth()
gauss.SetInput(self.Image)
gauss.SetStandardDeviations(self.StandardDeviations)
gauss.SetRadiusFactors(self.RadiusFactors)
if self.Shape.find('2d') != -1:
gauss.SetDimensionality(2)
elif self.Shape.find('3d') != -1:
gauss.SetDimensionality(3)
else:
gauss.SetDimensionality(3)
gauss.Update()
self.Image = gauss.GetOutput()
scalarRange = [0.0,0.0]
if self.FWHMRegion == 'image':
scalarRange = self.Image.GetScalarRange()
elif self.FWHMRegion == 'midline':
extent = self.Image.GetWholeExtent()
newYExtent = extent[2]+(extent[3]-extent[2])/2
clip = vtk.vtkImageClip()
clip.SetInput(self.Image)
clip.SetOutputWholeExtent(extent[0],extent[1],newYExtent,newYExtent,extent[4],extent[5])
clip.ClipDataOn()
clip.Update()
scalarRange = clip.GetOutput().GetScalarRange()
self.FWHMLevel = (scalarRange[1] - scalarRange[0]) * self.FWHMRatio + scalarRange[0]
if self.FWHMBackground != None:
self.FWHMLevel = (scalarRange[1] - self.FWHMBackground) * self.FWHMRatio + self.FWHMBackground
if self.Method == 'levelsets':
if self.Shape.find('2d') != -1:
gradientMagnitude = vtk.vtkImageGradientMagnitude()
gradientMagnitude.SetDimensionality(2)
elif self.Shape.find('3d') != -1:
if self.FeatureImageType == 'gradient':
gradientMagnitude = vtkvmtk.vtkvmtkGradientMagnitudeImageFilter()
elif self.FeatureImageType == 'upwind':
gradientMagnitude = vtkvmtk.vtkvmtkUpwindGradientMagnitudeImageFilter()
gradientMagnitude.SetUpwindFactor(self.UpwindFactor)
else:
self.PrintError('Unsupported feature image type: choices are "gradient", "upwind".')
return
else:
gradientMagnitude = vtk.vtkImageGradientMagnitude()
gradientMagnitude.SetInput(self.Image)
gradientMagnitude.Update()
boundedReciprocal = vtkvmtk.vtkvmtkBoundedReciprocalImageFilter()
boundedReciprocal.SetInput(gradientMagnitude.GetOutput())
boundedReciprocal.Update()
self.FeatureImage = vtk.vtkImageData()
self.FeatureImage.DeepCopy(boundedReciprocal.GetOutput())
levelSetsFilter = None
if self.Shape.find('2d') != -1:
levelSetsFilter = vtkvmtk.vtkvmtkGeodesicActiveContourLevelSet2DImageFilter()
elif self.Shape.find('3d') != -1:
levelSetsFilter = vtkvmtk.vtkvmtkGeodesicActiveContourLevelSetImageFilter()
else:
levelSetsFilter = vtkvmtk.vtkvmtkGeodesicActiveContourLevelSetImageFilter()
levelSetsFilter.SetInput(self.Image)
levelSetsFilter.SetFeatureImage(boundedReciprocal.GetOutput())
levelSetsFilter.SetDerivativeSigma(0.0)
levelSetsFilter.SetAutoGenerateSpeedAdvection(1)
levelSetsFilter.SetNumberOfIterations(self.LevelSetsIterations)
levelSetsFilter.SetPropagationScaling(0.0)
levelSetsFilter.SetCurvatureScaling(self.CurvatureScaling)
levelSetsFilter.SetAdvectionScaling(1.0)
levelSetsFilter.SetIsoSurfaceValue(self.FWHMLevel)
levelSetsFilter.SetInterpolateSurfaceLocation(1)
levelSetsFilter.SetMaximumRMSError(1E-10)
levelSetsFilter.Update()
self.LevelSets = vtk.vtkImageData()
self.LevelSets.DeepCopy(levelSetsFilter.GetOutput())
contourFilter = vtk.vtkMarchingContourFilter()
contourFilter.SetInput(self.LevelSets)
contourFilter.SetValue(0,0.0)
contourFilter.Update()
self.Contour = contourFilter.GetOutput()
elif self.Method == 'fwhm':
contourFilter = vtk.vtkMarchingContourFilter()
contourFilter.SetInput(self.Image)
contourFilter.SetValue(0,self.FWHMLevel)
contourFilter.Update()
self.Contour = contourFilter.GetOutput()
else:
self.PrintError('Unsupported method: choices are "levelsets", "fwhm".')
return
if self.Smoothing:
smoothingFilter = vtk.vtkWindowedSincPolyDataFilter()
smoothingFilter.SetInput(self.Contour)
smoothingFilter.SetNumberOfIterations(self.SmoothingIterations)
smoothingFilter.SetPassBand(self.SmoothingPassBand)
smoothingFilter.Update()
self.Contour = smoothingFilter.GetOutput()
measurementFilter = None
if self.Shape is 'thickplane2d':
measurementFilter = femri2DPlaneThickness()
elif self.Shape is 'cylinder2d':
measurementFilter = femri2DCylinderThickness()
elif self.Shape is 'hollowcylinder2d':
measurementFilter = femri2DHollowCylinderThickness()
elif self.Shape is 'cylinder3d':
measurementFilter = femri3DCylinderThickness()
else:
self.PrintError('Unsupported shape: choices are "thickplane2d", "cylinder2d", "hollowcylinder2d", "cylinder3d".')
return
measurementFilter.Contour = self.Contour
measurementFilter.Center = self.Center
measurementFilter.TiltingAngle = math.radians(self.TiltingAngle)
measurementFilter.RotationAngle = math.radians(self.RotationAngle)
measurementFilter.Execute()
if self.Shape is 'hollowcylinder2d':
measurementFilter.ComputeAreas()
self.InnerArea = measurementFilter.InnerArea
self.OuterArea = measurementFilter.OuterArea
self.Thickness = measurementFilter.Thickness
self.Thickness3D = measurementFilter.Thickness3D
self.Locations = measurementFilter.Locations
self.Contour = measurementFilter.Contour
self.OutputText('\n')
self.OutputText('Thickness: ' + str(self.Thickness) + '\n')
self.OutputText('Thickness3D: ' + str(self.Thickness3D) + '\n')
self.OutputText('Locations: ' + str(self.Locations) + '\n')
if self.Shape is 'hollowcylinder2d':
self.OutputText('InnerArea: ' + str(self.InnerArea) + '\n')
self.OutputText('OuterArea: ' + str(self.OuterArea) + '\n')
self.OutputText('\n')
## # represent the array scalar (TIME_LATE)
## calc.AddVectorVariable("s", "Gradients", 0)
## # Divide scalar by max (applies division to all components of the array)
## calc.SetFunction("norm(s)")
## # The output array will be called resArray
## calc.SetResultArrayName("resArray")
## calc.Update()
vtkResample = vtk.vtkCompositeDataProbeFilter()
#vtkResample.SetSource( calc.GetOutput() )
vtkResample.SetSource( vtkFemReader.GetOutput() )
vtkResample.SetInput( vtkImageReader.GetOutput() )
vtkResample.Update()
# compute gradient of resampled image
vtkGradMagn = vtk.vtkImageGradientMagnitude()
vtkGradMagn.SetInput( vtkResample.GetOutput() )
vtkGradMagn.Update()
# convert efield to V/cm
shifter = vtk.vtkImageShiftScale()
#shifter.SetShift(shift)
shifter.SetScale(.01)
#shifter.SetOutputScalarTypeToUnsignedChar()
shifter.SetInput(vtkGradMagn.GetOutput() )
#shifter.ReleaseDataFlagOff()
shifter.Update()
# write to disk
outputimage = shifter.GetOutput()
#outputimage.SetScalarArrayName("arrayname")
