def compare_png_images(self, image1_filename, image2_filename,
threshold=16, allow_shift=False):
"""Compare two PNG images on disc. No two pixels may differ with more
than the default threshold.
"""
import vtk
r1 = vtk.vtkPNGReader()
r1.SetFileName(image1_filename)
r1.Update()
r2 = vtk.vtkPNGReader()
r2.SetFileName(image2_filename)
r2.Update()
# there's a bug in VTK 5.0.1 where input images of unequal size
# (depending on which input is larger) will cause a segfault
# see http://www.vtk.org/Bug/bug.php?op=show&bugid=3586
# se we check for that situation and bail if it's the case
if r1.GetOutput().GetDimensions() != r2.GetOutput().GetDimensions():
em = 'Input images %s and %s are not of equal size.' % \
(image1_filename, image2_filename)
raise RuntimeError, em
# sometimes PNG files have an ALPHA component we have to chuck away
# do this for both images
ec1 = vtk.vtkImageExtractComponents()
ec1.SetComponents(0,1,2)
ec1.SetInput(r1.GetOutput())
ec2 = vtk.vtkImageExtractComponents()
ec2.SetComponents(0,1,2)
ec2.SetInput(r2.GetOutput())
idiff = vtk.vtkImageDifference()
idiff.SetThreshold(threshold)
if allow_shift:
idiff.AllowShiftOn()
else:
idiff.AllowShiftOff()
idiff.SetImage(ec1.GetOutput())
idiff.SetInputConnection(ec2.GetOutputPort())
idiff.Update()
return idiff.GetThresholdedError()
def __init__(self, source, component):
"""
Initialization
"""
DataSource.__init__(self)
self.source = source
self.component = component
self.extract = vtk.vtkImageExtractComponents()
self.extract.SetComponents(self.component)
self.setPath = source.setPath
self.getPath = source.getPath
self.setMask = source.setMask
self.getSpacing = source.getSpacing
self.getVoxelSize = source.getVoxelSize
self.setResampleDimensions = source.setResampleDimensions
self.getOriginalScalarRange = source.getOriginalScalarRange
self.getOriginalDimensions = source.getOriginalDimensions
self.getResampleFactors = source.getResampleFactors
self.getResampledVoxelSize = source.getResampledVoxelSize
self.getResampleDimensions = source.getResampleDimensions
self.setIntensityScale = source.setIntensityScale
self.getIntensityScaledData = source.getIntensityScaledData
self.getResampledData = source.getResampledData
self.getEmissionWavelength = source.getEmissionWavelength
self.getExcitationWavelength = source.getExcitationWavelength
self.getNumericalAperture = source.getNumericalAperture
self.getDataSetCount = source.getDataSetCount
self.getFileName = source.getFileName
self.getDimensions = source.getDimensions
self.getScalarRange = source.getScalarRange
self.ctf = None
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkImageExtractComponents(), 'Processing.',
('vtkImageData',), ('vtkImageData',),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
def onApply(self):
inputVolume = self.inputSelector.currentNode()
outputVolume = self.outputSelector.currentNode()
# check for input data
if not (inputVolume and outputVolume):
slicer.util.errorDisplay('Input and output volumes are required for conversion', windowTitle='Luminance')
return
# check that data has enough components
inputImage = inputVolume.GetImageData()
if not inputImage or inputImage.GetNumberOfScalarComponents() < 3:
slicer.util.errorDisplay('Input does not have enough components for conversion',
windowTitle='Vector to Scalar Volume')
return
# run the filter
# - extract the RGB portions
extract = vtk.vtkImageExtractComponents()
extract.SetComponents(0,1,2)
luminance = vtk.vtkImageLuminance()
extract.SetInputConnection(inputVolume.GetImageDataConnection())
luminance.SetInputConnection(extract.GetOutputPort())
luminance.Update()
ijkToRAS = vtk.vtkMatrix4x4()
inputVolume.GetIJKToRASMatrix(ijkToRAS)
outputVolume.SetIJKToRASMatrix(ijkToRAS)
outputVolume.SetImageDataConnection(luminance.GetOutputPort())
# make the output volume appear in all the slice views
selectionNode = slicer.app.applicationLogic().GetSelectionNode()
selectionNode.SetReferenceActiveVolumeID(outputVolume.GetID())
slicer.app.applicationLogic().PropagateVolumeSelection(0)
def __init__(self, module_manager):
ModuleBase.__init__(self, module_manager)
self._extract = vtk.vtkImageExtractComponents()
module_utils.setup_vtk_object_progress(self, self._extract,
'Extracting components.')
self._config.component1 = 0
self._config.component2 = 1
self._config.component3 = 2
self._config.numberOfComponents = 1
self._config.fileLowerLeft = False
configList = [
('Component 1:', 'component1', 'base:int', 'text',
'Zero-based index of first component to extract.'),
('Component 2:', 'component2', 'base:int', 'text',
'Zero-based index of second component to extract.'),
('Component 3:', 'component3', 'base:int', 'text',
'Zero-based index of third component to extract.'),
('Number of components:', 'numberOfComponents', 'base:int',
'choice',
'Number of components to extract. Only this number of the '
'above-specified component indices will be used.',
('1', '2', '3'))]
ScriptedConfigModuleMixin.__init__(
self, configList,
{'Module (self)' : self,
'vtkImageExtractComponents' : self._extract})
self.sync_module_logic_with_config()
def __init__(self, binsCount, reader):
self.Reader = reader
self.BinsCount = binsCount
self.BinStep = 0
self.ScalarRange = [0, 0]
self.FreqArray = vtk.vtkDataArray.CreateDataArray(vtk.VTK_INT)
self.FreqArray.SetNumberOfComponents(1)
extract = vtk.vtkImageExtractComponents()
extract.SetInputConnection(self.Reader.GetOutputPort())
extract.SetComponents(0)
extract.Update()
extract.GetOutput().GetScalarRange(self.ScalarRange)
self.BinStep = (self.ScalarRange[1] - self.ScalarRange[0]) / self.BinsCount
histo = vtk.vtkImageAccumulate()
histo.SetInputConnection(extract.GetOutputPort())
histo.SetComponentExtent(0, self.BinsCount, 0, 0, 0, 0)
histo.SetComponentOrigin(self.ScalarRange[0], 0, 0)
histo.SetComponentSpacing(self.BinStep, 0, 0)
histo.SetIgnoreZero(False)
histo.Update()
for j in range(0, self.BinsCount):
compValue = histo.GetOutput().GetPointData().GetScalars().GetValue(j)
self.FreqArray.InsertNextTuple1(compValue)
lastBinValue = self.FreqArray.GetComponent(self.BinsCount - 1, 0)
binValue = histo.GetOutput().GetPointData().GetScalars().GetValue(self.BinsCount)
self.FreqArray.SetComponent(self.BinsCount - 1, 0, lastBinValue + binValue)
def removeAlpha(file):
freader = vtk.vtkPNGReader()
freader.SetFileName(file)
removealpha = vtk.vtkImageExtractComponents()
removealpha.SetComponents(0,1,2)
removealpha.SetInputConnection(freader.GetOutputPort())
removealpha.Update()
return removealpha.GetOutput()
def compute(self, vertexShader, fragmentShader, keys={}, iterations=1):
"""Perform an iterated filter"""
import time
startTime = time.time()
logging.info('-'*40)
logging.info('Processing started')
import ShaderComputation
sceneShader = ShaderComputation.SceneShader.getInstance()
sceneShader.resetFieldSamplers()
sceneShader.updateFieldSamplers()
volume0Texture = sceneShader.fieldSamplersByNodeID[self.volume0.GetID()]
outputTextures = {}
outputTextures[0] = sceneShader.fieldSamplersByNodeID[self.outputVolume.GetID()]
outputTextures[1] = sceneShader.fieldSamplersByNodeID[self.iterationVolume.GetID()]
self.volumeTextures = [volume0Texture,] + outputTextures.values()
logging.info('%f Acquired renderer' % (time.time() - startTime))
for iteration in range(iterations):
# build the source
keys['iteration'] = iteration
if iteration == 0:
keys['inputTextureUnit'] = volume0Texture.textureUnit
keys['inputTextureUnitIdentifier'] = volume0Texture.textureUnitIdentifier()
else:
keys['inputTextureUnit'] = outputTextures[(iteration+1)%2].textureUnit
keys['inputTextureUnitIdentifier'] = outputTextures[(iteration+1)%2].textureUnitIdentifier()
sceneShader.shaderComputation.SetVertexShaderSource(vertexShader % keys)
samplersSource = sceneShader.textureUnitDeclarationSource()
for volumeTexture in self.volumeTextures:
samplersSource += volumeTexture.fieldSampleSource()
shaders = self.header + samplersSource + fragmentShader
sceneShader.shaderComputation.SetFragmentShaderSource(shaders % keys)
# set the target
targetTextureImage = outputTextures[iteration%2].textureImage
self.iteration(sceneShader, targetTextureImage)
logging.info('%f iteration %d' % (time.time() - startTime, iteration))
#print(sceneShader.shaderComputation.GetFragmentShaderSource())
#break
sceneShader.render()
if True or self.readBackToVolumeNode:
targetTextureImage.ReadBack()
logging.info('%f readback finished' % (time.time() - startTime))
extractComponents = vtk.vtkImageExtractComponents()
extractComponents.SetInputData(targetTextureImage.GetImageData())
extractComponents.Update()
self.outputVolume.SetAndObserveImageData(extractComponents.GetOutputDataObject(0))
else:
sceneShader.render()
logging.info('%f computation finished' % (time.time() - startTime))
logging.info('-'*40)
def runConversionMethodSingleComponent(self, inputVolumeNode, outputVolumeNode, componentToExtract):
ijkToRAS = vtk.vtkMatrix4x4()
inputVolumeNode.GetIJKToRASMatrix(ijkToRAS)
outputVolumeNode.SetIJKToRASMatrix(ijkToRAS)
extract = vtk.vtkImageExtractComponents()
extract.SetInputConnection(inputVolumeNode.GetImageDataConnection())
extract.SetComponents(componentToExtract)
extract.Update()
outputVolumeNode.SetImageDataConnection(extract.GetOutputPort())
def computeImageHessian(
image=None,
image_filename=None,
verbose=0):
myVTK.myPrint(verbose, "*** computeImageHessian ***")
image = myVTK.initImage(image, image_filename, verbose-1)
image_dimensionality = myVTK.computeImageDimensionality(
image=image,
verbose=verbose-1)
image_gradient = vtk.vtkImageGradient()
if (vtk.vtkVersion.GetVTKMajorVersion() >= 6):
image_gradient.SetInputData(image)
else:
image_gradient.SetInput(image)
image_gradient.SetDimensionality(image_dimensionality)
image_gradient.Update()
image_w_gradient = image_gradient.GetOutput()
image_append_components = vtk.vtkImageAppendComponents()
for k_dim in xrange(image_dimensionality):
image_extract_components = vtk.vtkImageExtractComponents()
if (vtk.vtkVersion.GetVTKMajorVersion() >= 6):
image_extract_components.SetInputData(image_w_gradient)
else:
image_extract_components.SetInput(image_w_gradient)
image_extract_components.SetComponents(k_dim)
image_extract_components.Update()
image_w_gradient_component = image_extract_components.GetOutput()
image_gradient = vtk.vtkImageGradient()
if (vtk.vtkVersion.GetVTKMajorVersion() >= 6):
image_gradient.SetInputData(image_w_gradient_component)
else:
image_gradient.SetInput(image_w_gradient_component)
image_gradient.SetDimensionality(image_dimensionality)
image_gradient.Update()
image_w_hessian_component = image_gradient.GetOutput()
if (vtk.vtkVersion.GetVTKMajorVersion() >= 6):
image_append_components.AddInputData(image_w_hessian_component)
else:
image_append_components.AddInput(image_w_hessian_component)
image_append_components.Update()
image_w_hessian = image_append_components.GetOutput()
name = image.GetPointData().GetScalars().GetName()
image.GetPointData().AddArray(image_w_gradient.GetPointData().GetArray(name+"Gradient"))
image.GetPointData().AddArray(image_w_hessian.GetPointData().GetArray(name+"GradientGradient"))
image.GetPointData().SetActiveScalars(name+"GradientGradient")
return image
def __init__(self):
"""
Initialization
"""
lib.ProcessingFilter.ProcessingFilter.__init__(self, (1, 1))
self.vtkfilter = vtk.vtkImageExtractComponents()
self.vtkfilter.AddObserver("ProgressEvent", lib.messenger.send)
lib.messenger.connect(self.vtkfilter, 'ProgressEvent', self.updateProgress)
self.descs = {"Component1": "Component #1", "Component2": "Component #2", "Component3": "Component #3"}
self.filterDesc = "Extracts the red and/or green and/or blue components of an RGB color image into separate greyscale channels\nInput: RGB image\nOutput: 3 grayscale images"
def runConversionMethodLuminance(self, inputVolumeNode, outputVolumeNode):
ijkToRAS = vtk.vtkMatrix4x4()
inputVolumeNode.GetIJKToRASMatrix(ijkToRAS)
outputVolumeNode.SetIJKToRASMatrix(ijkToRAS)
extract = vtk.vtkImageExtractComponents()
extract.SetInputConnection(inputVolumeNode.GetImageDataConnection())
extract.SetComponents(0, 1, 2)
luminance = vtk.vtkImageLuminance()
luminance.SetInputConnection(extract.GetOutputPort())
luminance.Update()
outputVolumeNode.SetImageDataConnection(luminance.GetOutputPort())
def frequencyPassFilter(self, lowcutoff=None, highcutoff=None, order=3):
"""
Low-pass and high-pass filtering become trivial in the frequency domain.
A portion of the pixels/voxels are simply masked or attenuated.
This function applies a high pass Butterworth filter that attenuates the
frequency domain image with the function
|G_Of_Omega|
The gradual attenuation of the filter is important.
A simple high-pass filter would simply mask a set of pixels in the frequency domain,
but the abrupt transition would cause a ringing effect in the spatial domain.
:param list lowcutoff: the cutoff frequencies
:param list highcutoff: the cutoff frequencies
:param int order: order determines sharpness of the cutoff curve
"""
#https://lorensen.github.io/VTKExamples/site/Cxx/ImageProcessing/IdealHighPass
fft = vtk.vtkImageFFT()
fft.SetInputData(self._data)
fft.Update()
out = fft.GetOutput()
if highcutoff:
butterworthLowPass = vtk.vtkImageButterworthLowPass()
butterworthLowPass.SetInputData(out)
butterworthLowPass.SetCutOff(highcutoff)
butterworthLowPass.SetOrder(order)
butterworthLowPass.Update()
out = butterworthLowPass.GetOutput()
if lowcutoff:
butterworthHighPass = vtk.vtkImageButterworthHighPass()
butterworthHighPass.SetInputData(out)
butterworthHighPass.SetCutOff(lowcutoff)
butterworthHighPass.SetOrder(order)
butterworthHighPass.Update()
out = butterworthHighPass.GetOutput()
butterworthRfft = vtk.vtkImageRFFT()
butterworthRfft.SetInputData(out)
butterworthRfft.Update()
butterworthReal = vtk.vtkImageExtractComponents()
butterworthReal.SetInputData(butterworthRfft.GetOutput())
butterworthReal.SetComponents(0)
butterworthReal.Update()
caster = vtk.vtkImageCast()
caster.SetOutputScalarTypeToUnsignedChar()
caster.SetInputData(butterworthReal.GetOutput())
caster.Update()
return self._update(caster.GetOutput())
def runConversionMethodLuminance(self, inputVolumeNode, outputVolumeNode):
ijkToRAS = vtk.vtkMatrix4x4()
inputVolumeNode.GetIJKToRASMatrix(ijkToRAS)
outputVolumeNode.SetIJKToRASMatrix(ijkToRAS)
extract = vtk.vtkImageExtractComponents()
extract.SetInputConnection(inputVolumeNode.GetImageDataConnection())
extract.SetComponents(0, 1, 2)
luminance = vtk.vtkImageLuminance()
luminance.SetInputConnection(extract.GetOutputPort())
luminance.Update()
outputVolumeNode.SetImageDataConnection(luminance.GetOutputPort())
def image_from_file(fname):
try:
rd = vtk.vtkPNGReader()
rd.SetFileName(fname)
removeAlpha = vtk.vtkImageExtractComponents()
removeAlpha.SetComponents(0, 1, 2)
removeAlpha.SetInputConnection(rd.GetOutputPort())
removeAlpha.Update()
return removeAlpha.GetOutput()
except Exception, err:
print "Problem opening file '%s': %s" % (fname, err)
return None
def image_from_file(fname):
try:
rd = vtk.vtkPNGReader()
rd.SetFileName(fname)
removeAlpha = vtk.vtkImageExtractComponents()
removeAlpha.SetComponents(0, 1, 2)
removeAlpha.SetInputConnection(rd.GetOutputPort())
removeAlpha.Update()
return removeAlpha.GetOutput()
except Exception, err:
print "Problem opening file '%s': %s" % (fname, err)
return None
def updateRendering(self):
"""
Update the Rendering of this module
"""
data = self.getInput(1)
x, y, z = self.dataUnit.getDimensions()
data = optimize.optimize(image=data,
updateExtent=(0, x - 1, 0, y - 1, 0, z - 1))
if data.GetNumberOfScalarComponents() > 3:
extract = vtk.vtkImageExtractComponents()
extract.SetInput(data)
extract.SetComponents(1, 1, 1)
data = extract.GetOutput()
if data.GetNumberOfScalarComponents() > 1:
self.luminance.SetInput(data)
data = self.luminance.GetOutput()
z = self.parameters["Slice"]
ext = (0, x - 1, 0, y - 1, z, z)
voi = vtk.vtkExtractVOI()
voi.SetVOI(ext)
voi.SetInput(data)
slice = voi.GetOutput()
self.geometry.SetInput(slice)
self.warp.SetInput(self.geometry.GetOutput())
self.warp.SetScaleFactor(self.parameters["Scale"])
self.merge.SetGeometry(self.warp.GetOutput())
if slice.GetNumberOfScalarComponents() == 1:
maptocol = vtk.vtkImageMapToColors()
ctf = self.getInputDataUnit(1).getColorTransferFunction()
maptocol.SetInput(slice)
maptocol.SetLookupTable(ctf)
maptocol.Update()
scalars = maptocol.GetOutput()
else:
scalars = slice
self.merge.SetScalars(scalars)
data = self.merge.GetOutput()
if self.parameters["Normals"]:
self.normals.SetInput(data)
self.normals.SetFeatureAngle(self.parameters["FeatureAngle"])
print "Feature angle=", self.parameters["FeatureAngle"]
data = self.normals.GetOutput()
self.mapper.SetInput(data)
self.mapper.Update()
VisualizationModule.updateRendering(self)
self.parent.Render()
def runConversionMethodSingleComponent(self, inputVolumeNode,
outputVolumeNode,
componentToExtract):
ijkToRAS = vtk.vtkMatrix4x4()
inputVolumeNode.GetIJKToRASMatrix(ijkToRAS)
outputVolumeNode.SetIJKToRASMatrix(ijkToRAS)
extract = vtk.vtkImageExtractComponents()
extract.SetInputConnection(inputVolumeNode.GetImageDataConnection())
extract.SetComponents(componentToExtract)
extract.Update()
outputVolumeNode.SetImageDataConnection(extract.GetOutputPort())
def updateRendering(self): """ Update the Rendering of this module """ data = self.getInput(1) x,y,z = self.dataUnit.getDimensions() data = optimize.optimize(image = data, updateExtent = (0, x-1, 0, y-1, 0, z-1)) if data.GetNumberOfScalarComponents() > 3: extract = vtk.vtkImageExtractComponents() extract.SetInput(data) extract.SetComponents(1, 1, 1) data = extract.GetOutput() if data.GetNumberOfScalarComponents() > 1: self.luminance.SetInput(data) data = self.luminance.GetOutput() z = self.parameters["Slice"] ext = (0, x - 1, 0, y - 1, z, z) voi = vtk.vtkExtractVOI() voi.SetVOI(ext) voi.SetInput(data) slice = voi.GetOutput() self.geometry.SetInput(slice) self.warp.SetInput(self.geometry.GetOutput()) self.warp.SetScaleFactor(self.parameters["Scale"]) self.merge.SetGeometry(self.warp.GetOutput()) if slice.GetNumberOfScalarComponents() == 1: maptocol = vtk.vtkImageMapToColors() ctf = self.getInputDataUnit(1).getColorTransferFunction() maptocol.SetInput(slice) maptocol.SetLookupTable(ctf) maptocol.Update() scalars = maptocol.GetOutput() else: scalars = slice self.merge.SetScalars(scalars) data = self.merge.GetOutput() if self.parameters["Normals"]: self.normals.SetInput(data) self.normals.SetFeatureAngle(self.parameters["FeatureAngle"]) print "Feature angle=", self.parameters["FeatureAngle"] data = self.normals.GetOutput() self.mapper.SetInput(data) self.mapper.Update() VisualizationModule.updateRendering(self) self.parent.Render()
def run(self, inputFile, enableScreenshots=0):
"""
Run the actual algorithm
"""
#parse logfile
logging.info('Processing started')
imageLogFile = LogDataObject() #initialize log object
imageLogFile.ImportFromFile(inputFile) #import image parameters of log object
if not(imageLogFile.VerifyParameters()): #check that all parameters were set
logging.info('Failed: Log file parameters not set')
return False
if not(self.isValidImageFileType(imageLogFile.FileType)): #check for valid file type
logging.info('Failed: Invalid image type')
logging.info(imageLogFile.FileType)
return False
# read image
(inputDirectory,logPath) = os.path.split(inputFile)
imageFileTemplate = os.path.join(inputDirectory, imageLogFile.Prefix + imageLogFile.SequenceStart + "." + imageLogFile.FileType)
[success, outputVolumeNode] = slicer.util.loadVolume(imageFileTemplate, returnNode=True)
if not(success):
logging.info('Failed to load image')
return False
#calculate image spacing
spacing = [imageLogFile.Resolution, imageLogFile.Resolution, imageLogFile.Resolution]
# if vector image, convert to scalar using luminance (0.30*R + 0.59*G + 0.11*B + 0.0*A)
#check if loaded volume is vector type, if so convert to scalar
if outputVolumeNode.GetClassName() =='vtkMRMLVectorVolumeNode':
scalarVolumeNode = slicer.mrmlScene.AddNewNodeByClass('vtkMRMLScalarVolumeNode', imageLogFile.Prefix)
scalarVolumeNode.SetSpacing(spacing)
extractVTK = vtk.vtkImageExtractComponents()
extractVTK.SetInputConnection(outputVolumeNode.GetImageDataConnection())
extractVTK.SetComponents(0, 1, 2)
luminance = vtk.vtkImageLuminance()
luminance.SetInputConnection(extractVTK.GetOutputPort())
luminance.Update()
scalarVolumeNode.SetImageDataConnection(luminance.GetOutputPort()) # apply
slicer.mrmlScene.RemoveNode(outputVolumeNode)
slicer.util.resetSliceViews() #update the field of view
else:
outputVolumeNode.SetSpacing(spacing)
outputVolumeNode.SetName(imageLogFile.Prefix)
slicer.util.resetSliceViews() #update the field of view
# Capture screenshot
if enableScreenshots:
self.takeScreenshot('SkyscanReconImportTest-Start','MyScreenshot',-1)
logging.info('Processing completed')
return True
def addImageHessian(image, image_dimensionality=None, verbose=0):
mypy.my_print(verbose, "*** addImageHessian ***")
if (image_dimensionality is None):
image_dimensionality = myvtk.getImageDimensionality(image=image,
verbose=verbose -
1)
image_gradient = vtk.vtkImageGradient()
if (vtk.vtkVersion.GetVTKMajorVersion() >= 6):
image_gradient.SetInputData(image)
else:
image_gradient.SetInput(image)
image_gradient.SetDimensionality(image_dimensionality)
image_gradient.Update()
image_w_gradient = image_gradient.GetOutput()
image_append_components = vtk.vtkImageAppendComponents()
for k_dim in xrange(image_dimensionality):
image_extract_components = vtk.vtkImageExtractComponents()
if (vtk.vtkVersion.GetVTKMajorVersion() >= 6):
image_extract_components.SetInputData(image_w_gradient)
else:
image_extract_components.SetInput(image_w_gradient)
image_extract_components.SetComponents(k_dim)
image_extract_components.Update()
image_w_gradient_component = image_extract_components.GetOutput()
image_gradient = vtk.vtkImageGradient()
if (vtk.vtkVersion.GetVTKMajorVersion() >= 6):
image_gradient.SetInputData(image_w_gradient_component)
else:
image_gradient.SetInput(image_w_gradient_component)
image_gradient.SetDimensionality(image_dimensionality)
image_gradient.Update()
image_w_hessian_component = image_gradient.GetOutput()
if (vtk.vtkVersion.GetVTKMajorVersion() >= 6):
image_append_components.AddInputData(image_w_hessian_component)
else:
image_append_components.AddInput(image_w_hessian_component)
image_append_components.Update()
image_w_hessian = image_append_components.GetOutput()
name = image.GetPointData().GetScalars().GetName()
image.GetPointData().AddArray(
image_w_gradient.GetPointData().GetArray(name + "Gradient"))
image.GetPointData().AddArray(
image_w_hessian.GetPointData().GetArray(name + "GradientGradient"))
image.GetPointData().SetActiveScalars(name + "GradientGradient")
def __init__(self):
"""
Initialization
"""
lib.ProcessingFilter.ProcessingFilter.__init__(self, (1, 1))
self.vtkfilter = vtk.vtkImageExtractComponents()
self.vtkfilter.AddObserver("ProgressEvent", lib.messenger.send)
lib.messenger.connect(self.vtkfilter, 'ProgressEvent',
self.updateProgress)
self.descs = {
"Component1": "Component #1",
"Component2": "Component #2",
"Component3": "Component #3"
}
self.filterDesc = "Extracts the red and/or green and/or blue components of an RGB color image into separate greyscale channels\nInput: RGB image\nOutput: 3 grayscale images"
def bw(self):
"""Make it black and white"""
n = self._data.GetPointData().GetNumberOfComponents()
if n==4:
ecr = vtk.vtkImageExtractComponents()
ecr.SetInputData(self._data)
ecr.SetComponents(0,1,2)
ecr.Update()
img = ecr.GetOutput()
else:
img = self._data
ecr = vtk.vtkImageLuminance()
ecr.SetInputData(img)
ecr.Update()
return self._update(ecr.GetOutput())
def depthDataCallback(self, caller, eventId):
extractFilterDepth = vtk.vtkImageExtractComponents()
extractFilterDepth.SetInputData(depthMap.GetImageData())
extractFilterDepth.SetComponents(0)
extractFilterDepth.Update()
imageDepth = extractFilterDepth.GetOutput()
vtkDataDepth = imageDepth.GetPointData().GetScalars()
numpyDataDepth = numpy_support.vtk_to_numpy(vtkDataDepth)
numpyDataDepth = numpyDataDepth.reshape(dims[0], dims[1])
listOfPoints = generate_pointcloud(numpyDataDepth)
polyData = generatePolyData(listOfPoints)
pointCloudModel.SetAndObservePolyData(polyData)
{
"focalLength": self.ui.focalLength.value,
"principlePointX": self.ui.principlePointX.value,
"principlePointY": self.ui.principlePointY.value
}
def insert(self, document):
if not self.view:
return
if self.CaptureDepth:
image = self.view.CaptureDepthBuffer()
idata = numpy_support.vtk_to_numpy(image) * 256
rw = self.view.GetRenderWindow()
width,height = rw.GetSize()
imageslice = np.flipud(idata.reshape(height,width))
#import Image
#img = Image.fromarray(imageslice)
#img.show()
#try:
# input("Press enter to continue ")
#except NameError:
# pass
document.data = imageslice
self.CaptureDepth = False
else:
image = self.view.CaptureWindow(1)
if self.CaptureLuminance: #TODO: this is still preOpenGL2
rth = vtk.vtkImageRGBToHSI()
rth.SetInputData(image)
ec = vtk.vtkImageExtractComponents()
ec.SetInputConnection(rth.GetOutputPort())
ec.SetComponents(2,2,2)
ec.Update()
image = ec.GetOutput()
npview = dsa.WrapDataObject(image)
idata = npview.PointData[0]
ext = image.GetExtent()
width = ext[1] - ext[0] + 1
height = ext[3] - ext[2] + 1
imageslice = np.flipud(idata.reshape(height,width,3))
#import Image
#img = Image.fromarray(imageslice)
#img.show()
#try:
# input("Press enter to continue ")
#except NameError:
# pass
document.data = imageslice
super(ImageExplorer, self).insert(document)
def runConversionMethodAverage(self, inputVolumeNode, outputVolumeNode):
ijkToRAS = vtk.vtkMatrix4x4()
inputVolumeNode.GetIJKToRASMatrix(ijkToRAS)
outputVolumeNode.SetIJKToRASMatrix(ijkToRAS)
numberOfComponents = inputVolumeNode.GetImageData(
).GetNumberOfScalarComponents()
weightedSum = vtk.vtkImageWeightedSum()
weights = vtk.vtkDoubleArray()
weights.SetNumberOfValues(numberOfComponents)
# TODO: Average could be extended to let the user choose the weights of the components.
evenWeight = 1.0 / numberOfComponents
logging.debug("ImageWeightedSum: weight value for all components: %s" %
evenWeight)
for comp in range(numberOfComponents):
weights.SetValue(comp, evenWeight)
weightedSum.SetWeights(weights)
for comp in range(numberOfComponents):
extract = vtk.vtkImageExtractComponents()
extract.SetInputConnection(
inputVolumeNode.GetImageDataConnection())
extract.SetComponents(comp)
extract.Update()
# Cast component to Double
compToDouble = vtk.vtkImageCast()
compToDouble.SetInputConnection(0, extract.GetOutputPort())
compToDouble.SetOutputScalarTypeToDouble()
# Add to the weighted sum
weightedSum.AddInputConnection(compToDouble.GetOutputPort())
logging.debug("TotalInputConnections in weightedSum: %s" %
weightedSum.GetTotalNumberOfInputConnections())
weightedSum.SetNormalizeByWeight(
False) # It is already normalized in the evenWeight case.
weightedSum.Update()
# Cast back to the type of the InputVolume, for consistency with other ConversionMethods
castBack = vtk.vtkImageCast()
castBack.SetInputConnection(0, weightedSum.GetOutputPort())
castBack.SetOutputScalarType(
inputVolumeNode.GetImageData().GetScalarType())
outputVolumeNode.SetImageDataConnection(castBack.GetOutputPort())
def getScalarNodeFrom2DNode(self, vectorNode):
""" Get a 3D vtkMRMLScalarVolumeNode (1 slice) from a vtkMRMLVectorVolumeNode
:param vectorNode:
:return: output volume
"""
extract = vtk.vtkImageExtractComponents()
extract.SetComponents(0, 1, 2)
luminance = vtk.vtkImageLuminance()
extract.SetInputConnection(vectorNode.GetImageDataConnection())
luminance.SetInputConnection(extract.GetOutputPort())
luminance.Update()
ijkToRAS = vtk.vtkMatrix4x4()
vectorNode.GetIJKToRASMatrix(ijkToRAS)
outputVolume = slicer.mrmlScene.CreateNodeByClass(
"vtkMRMLScalarVolumeNode")
slicer.mrmlScene.AddNode(outputVolume)
outputVolume.SetName(vectorNode.GetName() + "_3D")
outputVolume.SetIJKToRASMatrix(ijkToRAS)
outputVolume.SetImageDataConnection(luminance.GetOutputPort())
return outputVolume
def run(self, inputVolume, outputVolume, cameraParams, pointCloudParams):
"""
Run the actual algorithm
"""
if not self.isValidInputOutputData(inputVolume, outputVolume):
slicer.util.errorDisplay(
'Input volume is the same as output volume. Choose a different output volume.'
)
return False
if not self.hasImageData(inputVolume):
return False
logging.info('Processing started')
inputImage = inputVolume.GetImageData()
imageDims = inputImage.GetDimensions()[0:2]
#Extract the vtkImageData from the vtkMRMLScalarVolumeNode
extractFilterDepth = vtk.vtkImageExtractComponents()
extractFilterDepth.SetInputData(inputImage)
extractFilterDepth.SetComponents(0)
extractFilterDepth.Update()
imageDepth = extractFilterDepth.GetOutput()
#Convert depth data to numpy array
vtkDataDepth = imageDepth.GetPointData().GetScalars()
numpyDataDepth = numpy_support.vtk_to_numpy(vtkDataDepth)
numpyDataDepth = numpyDataDepth.reshape(imageDims[1], imageDims[0])
listOfPoints = self.generate_pointcloud(numpyDataDepth, cameraParams,
pointCloudParams)
polyData = self.generatePolyData(listOfPoints)
outputVolume.SetAndObservePolyData(polyData)
logging.info('Processing completed')
return True
def onApply(self):
inputVolume = self.inputSelector.currentNode()
outputVolume = self.outputSelector.currentNode()
# check for input data
if not (inputVolume and outputVolume):
qt.QMessageBox.critical(
slicer.util.mainWindow(),
'Luminance', 'Input and output volumes are required for conversion')
return
# check that data has enough components
inputImage = inputVolume.GetImageData()
if not inputImage or inputImage.GetNumberOfScalarComponents() < 3:
qt.QMessageBox.critical(
slicer.util.mainWindow(),
'Vector to Scalar Volume', 'Input does not have enough components for conversion')
return
# run the filter
# - extract the RGB portions
extract = vtk.vtkImageExtractComponents()
extract.SetComponents(0,1,2)
luminance = vtk.vtkImageLuminance()
if vtk.VTK_MAJOR_VERSION <= 5:
extract.SetInput(inputVolume.GetImageData())
luminance.SetInput(extract.GetOutput())
luminance.GetOutput().Update()
else:
extract.SetInputConnection(inputVolume.GetImageDataConnection())
luminance.SetInputConnection(extract.GetOutputPort())
luminance.Update()
ijkToRAS = vtk.vtkMatrix4x4()
inputVolume.GetIJKToRASMatrix(ijkToRAS)
outputVolume.SetIJKToRASMatrix(ijkToRAS)
if vtk.VTK_MAJOR_VERSION <= 5:
outputVolume.SetAndObserveImageData(luminance.GetOutput())
else:
outputVolume.SetImageDataConnection(luminance.GetOutputPort())
# make the output volume appear in all the slice views
selectionNode = slicer.app.applicationLogic().GetSelectionNode()
selectionNode.SetReferenceActiveVolumeID(outputVolume.GetID())
slicer.app.applicationLogic().PropagateVolumeSelection(0)
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 = "Calculating inverse FFT"
inputImage = self.getInput(1)
self.filter = vtk.vtkImageRFFT()
extract = vtk.vtkImageExtractComponents()
extract.SetComponents(0)
self.filter.SetInput(inputImage)
extract.SetInputConnection(self.filter.GetOutputPort())
outputImage = extract.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 = "Calculating inverse FFT" inputImage = self.getInput(1) self.filter = vtk.vtkImageRFFT() extract = vtk.vtkImageExtractComponents() extract.SetComponents(0) self.filter.SetInput(inputImage) extract.SetInputConnection(self.filter.GetOutputPort()) outputImage = extract.GetOutput() if update: outputImage.Update() return outputImage
def imageDataTo3Component(image, ctf):
"""
Processes image data to get it to proper 3 component RGB data
"""
image.UpdateInformation()
ncomps = image.GetNumberOfScalarComponents()
if ncomps == 1:
maptocolor = vtk.vtkImageMapToColors()
maptocolor.SetInputConnection(image.GetProducerPort())
maptocolor.SetLookupTable(ctf)
maptocolor.SetOutputFormatToRGB()
imagedata = maptocolor.GetOutput()
elif ncomps > 3:
Logging.info("Data has %d components, extracting" % ncomps, kw="imageop")
extract = vtk.vtkImageExtractComponents()
extract.SetComponents(0, 1, 2)
extract.SetInputConnection(image.GetProducerPort())
imagedata = extract.GetOutput()
else:
imagedata = image
return imagedata
def processOutputData(self, data):
"""
Process the data before it's send to the preview
"""
data.UpdateInformation()
ncomps = data.GetNumberOfScalarComponents()
if ncomps > 3:
extract = vtk.vtkImageExtractComponents()
extract.SetComponents(0, 1, 2)
extract.SetInput(data)
data = extract.GetOutput()
if ncomps == 1:
Logging.info("Mapping trough ctf", kw="preview")
self.mapToColors = vtk.vtkImageMapToColors()
self.mapToColors.SetInput(data)
self.updateColor()
colorImage = self.mapToColors.GetOutput()
outdata = colorImage
return outdata
return data
def processOutputData(self, data):
"""
Process the data before it's send to the preview
"""
data.UpdateInformation()
ncomps = data.GetNumberOfScalarComponents()
if ncomps > 3:
extract = vtk.vtkImageExtractComponents()
extract.SetComponents(0, 1, 2)
extract.SetInput(data)
data = extract.GetOutput()
if ncomps == 1:
Logging.info("Mapping trough ctf", kw = "preview")
self.mapToColors = vtk.vtkImageMapToColors()
self.mapToColors.SetInput(data)
self.updateColor()
colorImage = self.mapToColors.GetOutput()
outdata = colorImage
return outdata
return data
def extractFrame(scalarVolumeNode, multiVolumeNode, frameId):
# Extract frame from multiVolumeNode and put it into scalarVolumeNode
# if no scalar volume given, create one
if scalarVolumeNode is None:
scalarVolumeNode = slicer.vtkMRMLScalarVolumeNode()
scalarVolumeNode.SetScene(slicer.mrmlScene)
slicer.mrmlScene.AddNode(scalarVolumeNode)
# Extract the image data
mvImage = multiVolumeNode.GetImageData()
extract = vtk.vtkImageExtractComponents()
if vtk.VTK_MAJOR_VERSION <= 5:
extract.SetInput(mvImage)
else:
extract.SetInputData(mvImage)
extract.SetComponents(frameId)
extract.Update()
ras2ijk = vtk.vtkMatrix4x4()
ijk2ras = vtk.vtkMatrix4x4()
multiVolumeNode.GetRASToIJKMatrix(ras2ijk)
multiVolumeNode.GetIJKToRASMatrix(ijk2ras)
scalarVolumeNode.SetRASToIJKMatrix(ras2ijk)
scalarVolumeNode.SetIJKToRASMatrix(ijk2ras)
scalarVolumeNode.SetAndObserveImageData(extract.GetOutput())
displayNode = scalarVolumeNode.GetDisplayNode()
if displayNode is None:
displayNode = slicer.mrmlScene.CreateNodeByClass('vtkMRMLScalarVolumeDisplayNode')
displayNode.SetReferenceCount(1)
displayNode.SetScene(slicer.mrmlScene)
slicer.mrmlScene.AddNode(displayNode)
displayNode.SetDefaultColorMap()
scalarVolumeNode.SetAndObserveDisplayNodeID(displayNode.GetID())
return scalarVolumeNode
def runConversionMethodAverage(self, inputVolumeNode, outputVolumeNode):
ijkToRAS = vtk.vtkMatrix4x4()
inputVolumeNode.GetIJKToRASMatrix(ijkToRAS)
outputVolumeNode.SetIJKToRASMatrix(ijkToRAS)
numberOfComponents = inputVolumeNode.GetImageData().GetNumberOfScalarComponents()
weightedSum = vtk.vtkImageWeightedSum()
weights = vtk.vtkDoubleArray()
weights.SetNumberOfValues(numberOfComponents)
# TODO: Average could be extended to let the user choose the weights of the components.
evenWeight = 1.0/numberOfComponents
logging.debug("ImageWeightedSum: weight value for all components: %s" % evenWeight)
for comp in range(numberOfComponents):
weights.SetValue(comp, evenWeight)
weightedSum.SetWeights(weights)
for comp in range(numberOfComponents):
extract = vtk.vtkImageExtractComponents()
extract.SetInputConnection(inputVolumeNode.GetImageDataConnection())
extract.SetComponents(comp)
extract.Update()
# Cast component to Double
compToDouble = vtk.vtkImageCast()
compToDouble.SetInputConnection(0, extract.GetOutputPort())
compToDouble.SetOutputScalarTypeToDouble()
# Add to the weighted sum
weightedSum.AddInputConnection(compToDouble.GetOutputPort())
logging.debug("TotalInputConnections in weightedSum: %s" % weightedSum.GetTotalNumberOfInputConnections())
weightedSum.SetNormalizeByWeight(False) # It is already normalized in the evenWeight case.
weightedSum.Update()
# Cast back to the type of the InputVolume, for consistency with other ConversionMethods
castBack = vtk.vtkImageCast()
castBack.SetInputConnection(0, weightedSum.GetOutputPort())
castBack.SetOutputScalarType(inputVolumeNode.GetImageData().GetScalarType())
outputVolumeNode.SetImageDataConnection(castBack.GetOutputPort())
def imageDataTo3Component(image, ctf):
"""
Processes image data to get it to proper 3 component RGB data
"""
image.UpdateInformation()
ncomps = image.GetNumberOfScalarComponents()
if ncomps == 1:
maptocolor = vtk.vtkImageMapToColors()
maptocolor.SetInputConnection(image.GetProducerPort())
maptocolor.SetLookupTable(ctf)
maptocolor.SetOutputFormatToRGB()
imagedata = maptocolor.GetOutput()
elif ncomps > 3:
Logging.info("Data has %d components, extracting" % ncomps,
kw="imageop")
extract = vtk.vtkImageExtractComponents()
extract.SetComponents(0, 1, 2)
extract.SetInputConnection(image.GetProducerPort())
imagedata = extract.GetOutput()
else:
imagedata = image
return imagedata
def getDataSet(self, i, raw=0):
"""
@return Timepoint i
@param i The timepoint to return
"""
data = self.getTimepoint(i)
if self.isRGB and self.numberOfComponents == 4:
extract = vtk.vtkImageExtractComponents()
extract.SetComponents(0, 1, 2)
extract.SetInput(data)
data = extract.GetOutput()
if self.flipVertically:
flip = vtk.vtkImageFlip()
flip.SetFilteredAxis(1)
flip.SetInput(data)
data = flip.GetOutput()
if self.flipHorizontally:
flip = vtk.vtkImageFlip()
flip.SetFilteredAxis(0)
flip.SetInput(data)
data = flip.GetOutput()
return data
def getDataSet(self, i, raw = 0): """ @return Timepoint i @param i The timepoint to return """ data = self.getTimepoint(i) if self.isRGB and self.numberOfComponents == 4: extract = vtk.vtkImageExtractComponents() extract.SetComponents(0, 1, 2) extract.SetInput(data) data = extract.GetOutput() if self.flipVertically: flip = vtk.vtkImageFlip() flip.SetFilteredAxis(1) flip.SetInput(data) data = flip.GetOutput() if self.flipHorizontally: flip = vtk.vtkImageFlip() flip.SetFilteredAxis(0) flip.SetInput(data) data = flip.GetOutput() return data
def OnCurveButton(self):
if (str(self.inputSmoothSelector.currentNode())
or str(self.imagenMultuply.currentNode())) == "None":
print('ERROR: Select Input Volume Node and Label Mask')
qt.QMessageBox.information(
slicer.util.mainWindow(), 'Slicer Python',
'ERROR: Select Input Volume Node and Label Mask')
return True
else:
mvNode = slicer.vtkMRMLMultiVolumeNode(
) #creación nodo multivolumen
slicer.mrmlScene.AddNode(mvNode) #añadir a la escena el nodo
escena = slicer.mrmlScene
volumen4D = self.inputSmoothSelector.currentNode()
imagenvtk4D = volumen4D.GetImageData()
numero_imagenes = volumen4D.GetNumberOfFrames(
) #numero de frames del MV
#print('imagenes: ' + str(numero_imagenes))
#filtro vtk para descomponer un volumen 4D
extract1 = vtk.vtkImageExtractComponents()
extract1.SetInputData(imagenvtk4D)
#matriz de transformacion
ras2ijk = vtk.vtkMatrix4x4()
ijk2ras = vtk.vtkMatrix4x4()
#le solicitamos al volumen original que nos devuelva sus matrices
volumen4D.GetRASToIJKMatrix(ras2ijk)
volumen4D.GetIJKToRASMatrix(ijk2ras)
#creo un volumen nuevo
#volumenFijo = self.inputVolumeSelector.currentNode();
#le asigno las transformaciones
#le asigno el volumen 3D fijo
extract1.SetComponents(0)
extract1.Update()
volumenFiltro = slicer.vtkMRMLScalarVolumeNode()
volumenFiltro.SetName('Filtro')
volumenFiltro.SetAndObserveImageData(extract1.GetOutput())
volumenFiltro.SetRASToIJKMatrix(ras2ijk)
volumenFiltro.SetIJKToRASMatrix(ijk2ras)
#anado el nuevo volumen a la escena
escena.AddNode(volumenFiltro)
volumenSalida = slicer.vtkMRMLScalarVolumeNode()
#creacion de volumen de salida
slicer.mrmlScene.AddNode(volumenSalida)
j = 1
bandera = 0
frameLabelsAttr = ''
volumeLabels = vtk.vtkDoubleArray()
volumeLabels.SetNumberOfTuples(numero_imagenes)
volumeLabels.SetNumberOfComponents(1)
volumeLabels.Allocate(numero_imagenes)
mvImage = vtk.vtkImageData()
mvImage.SetExtent(volumenFiltro.GetImageData().GetExtent()
) ##Se le asigna la dimension del miltuvolumen
mvImage.AllocateScalars(
volumenFiltro.GetImageData().GetScalarType(), numero_imagenes
) ##Se le asigna el tipo y numero de cortes al multivolumen
mvImageArray = vtk.util.numpy_support.vtk_to_numpy(
mvImage.GetPointData().GetScalars()
) ## Se crea la matriz de datos donde va a ir la imagen
mat = vtk.vtkMatrix4x4()
##Se hace la conversion y se obtiene la matriz de transformacion del nodo
volumenFiltro.GetRASToIJKMatrix(mat)
mvNode.SetRASToIJKMatrix(mat)
volumenFiltro.GetIJKToRASMatrix(mat)
mvNode.SetIJKToRASMatrix(mat)
##
vector_int = []
for i in range(numero_imagenes):
# extraigo la imagen movil
extract1.SetComponents(i) #Seleccionar un volumen lejano
extract1.Update()
#Creo un volumen movil, y realizamos el mismo procedimiento que con el fijo
volumenFiltro.SetAndObserveImageData(extract1.GetOutput())
volumenFiltro.SetName('Filtrado')
escena.AddNode(volumenFiltro)
#parametros para la operacion de registro que seran entregados al modulo cli "brainsfit" segun tipo de registro
parameters = {}
parameters['Conductance'] = 1
parameters['numberOfIterations'] = 5
parameters['timeStep'] = 0.0625
parameters['inputVolume'] = volumenFiltro.GetID()
parameters['outputVolume'] = volumenFiltro.GetID()
cliNode = slicer.cli.run(
slicer.modules.gradientanisotropicdiffusion,
None,
parameters,
wait_for_completion=True)
slicer.util.saveNode(volumenFiltro,
'volumenFilter' + str(i) + '.nrrd')
vol = slicer.vtkMRMLScalarVolumeNode()
escena = slicer.mrmlScene
vol.SetName('salida')
escena.AddNode(vol)
Label = self.imagenMultuply.currentNode()
Label = slicer.util.getNode('vtkMRMLLabelMapVolumeNode1')
#parametros para la operacion de registro
parameters = {}
parameters['inputVolume1'] = escena.GetNodeByID(
'vtkMRMLLabelMapVolumeNode1'
) #dos volumenes de la escena, uno de ellos debe ser la mascara creada en el EDITOR
parameters['inputVolume2'] = volumenFiltro
parameters['outputVolume'] = vol
cliNode = slicer.cli.run(slicer.modules.multiplyscalarvolumes,
None,
parameters,
wait_for_completion=True)
slicer.util.saveNode(vol, 'volumenMulty' + str(i) + '.nrrd')
print(vol)
a = slicer.util.arrayFromVolume(vol)
intensidad = np.mean(a[:])
vector_int.append(intensidad)
# Switch to a layout (24) that contains a Chart View to initiate the construction of the widget and Chart View Node
lns = slicer.mrmlScene.GetNodesByClass('vtkMRMLLayoutNode')
lns.InitTraversal()
ln = lns.GetNextItemAsObject()
ln.SetViewArrangement(24)
# Get the Chart View Node
cvns = slicer.mrmlScene.GetNodesByClass('vtkMRMLChartViewNode')
cvns.InitTraversal()
cvn = cvns.GetNextItemAsObject()
# Create an Array Node and add some data
dn = slicer.mrmlScene.AddNode(slicer.vtkMRMLDoubleArrayNode())
a = dn.GetArray()
a.SetNumberOfTuples(numero_imagenes)
x = range(0, 600)
i = 0
for i in range(numero_imagenes):
a.SetComponent(i, 0, i)
a.SetComponent(i, 1, vector_int[i])
a.SetComponent(i, 2, 0)
# Create a Chart Node.
cn = slicer.mrmlScene.AddNode(slicer.vtkMRMLChartNode())
# Add the Array Nodes to the Chart. The first argument is a string used for the legend and to refer to the Array when setting properties.
cn.AddArray('Prostate perfusion', dn.GetID())
# Set a few properties on the Chart. The first argument is a string identifying which Array to assign the property.
# 'default' is used to assign a property to the Chart itself (as opposed to an Array Node).
cn.SetProperty('default', 'title', 'Perfusion curves')
cn.SetProperty('default', 'xAxisLabel', 'Time (s)')
cn.SetProperty('default', 'yAxisLabel', 'Intensity')
# Tell the Chart View which Chart to display
cvn.SetChartNodeID(cn.GetID())
def __init__(self, obj=None, channels=(), flip=False):
vtk.vtkImageActor.__init__(self)
vedo.base.Base3DProp.__init__(self)
if utils.isSequence(obj) and len(obj): # passing array
obj = np.asarray(obj)
if len(obj.shape) == 3: # has shape (nx,ny, ncolor_alpha_chan)
iac = vtk.vtkImageAppendComponents()
nchan = obj.shape[
2] # get number of channels in inputimage (L/LA/RGB/RGBA)
for i in range(nchan):
if flip:
arr = np.flip(np.flip(obj[:, :, i], 0), 0).ravel()
else:
arr = np.flip(obj[:, :, i], 0).ravel()
varb = numpy_to_vtk(arr,
deep=True,
array_type=vtk.VTK_UNSIGNED_CHAR)
varb.SetName("RGBA")
imgb = vtk.vtkImageData()
imgb.SetDimensions(obj.shape[1], obj.shape[0], 1)
imgb.GetPointData().AddArray(varb)
imgb.GetPointData().SetActiveScalars("RGBA")
iac.AddInputData(imgb)
iac.Update()
img = iac.GetOutput()
elif len(obj.shape) == 2: # black and white
if flip:
arr = np.flip(obj[:, :], 0).ravel()
else:
arr = obj.ravel()
varb = numpy_to_vtk(arr,
deep=True,
array_type=vtk.VTK_UNSIGNED_CHAR)
varb.SetName("RGBA")
img = vtk.vtkImageData()
img.SetDimensions(obj.shape[1], obj.shape[0], 1)
img.GetPointData().AddArray(varb)
img.GetPointData().SetActiveScalars("RGBA")
elif isinstance(obj, vtk.vtkImageData):
img = obj
elif isinstance(obj, str):
if "https://" in obj:
obj = vedo.io.download(obj, verbose=False)
fname = obj.lower()
if fname.endswith(".png"):
picr = vtk.vtkPNGReader()
elif fname.endswith(".jpg") or fname.endswith(".jpeg"):
picr = vtk.vtkJPEGReader()
elif fname.endswith(".bmp"):
picr = vtk.vtkBMPReader()
elif fname.endswith(".tif") or fname.endswith(".tiff"):
picr = vtk.vtkTIFFReader()
picr.SetOrientationType(vedo.settings.tiffOrientationType)
else:
colors.printc("Cannot understand picture format", obj, c='r')
return
picr.SetFileName(obj)
self.filename = obj
picr.Update()
img = picr.GetOutput()
else:
img = vtk.vtkImageData()
# select channels
nchans = len(channels)
if nchans and img.GetPointData().GetScalars().GetNumberOfComponents(
) > nchans:
pec = vtk.vtkImageExtractComponents()
pec.SetInputData(img)
if nchans == 3:
pec.SetComponents(channels[0], channels[1], channels[2])
elif nchans == 2:
pec.SetComponents(channels[0], channels[1])
elif nchans == 1:
pec.SetComponents(channels[0])
pec.Update()
img = pec.GetOutput()
self._data = img
self.SetInputData(img)
sx, sy, _ = img.GetDimensions()
self.shape = np.array([sx, sy])
self._mapper = self.GetMapper()
# Create the RenderWindow, Renderer and both Actors # ren1 = vtk.vtkRenderer() ren1.SetBackground(1,1,1) renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Read the data. Note this creates a 3-component scalar. red = vtk.vtkPNGReader() red.SetFileName(VTK_DATA_ROOT + "/Data/RedCircle.png") red.Update() # Next filter can only handle RGB *(&&*@ extract = vtk.vtkImageExtractComponents() extract.SetInputConnection(red.GetOutputPort()) extract.SetComponents(0,1,2) # Quantize the image into an index quantize = vtk.vtkImageQuantizeRGBToIndex() quantize.SetInputConnection(extract.GetOutputPort()) quantize.SetNumberOfColors(3) # Create the pipeline discrete = vtk.vtkDiscreteFlyingEdges2D() discrete.SetInputConnection(quantize.GetOutputPort()) discrete.SetValue(0,0) # Create polgons polyLoops = vtk.vtkContourLoopExtraction()
def registrarButton(self):
Tipo_registro = self.typeComboBox.currentText
mvNode = slicer.vtkMRMLMultiVolumeNode()
slicer.mrmlScene.AddNode(mvNode)
escena = slicer.mrmlScene
volumen4D = self.inputSelector.currentNode()
imagenvtk4D = volumen4D.GetImageData()
numero_imagenes = volumen4D.GetNumberOfFrames()
print('imagenes: ' + str(numero_imagenes))
#filtro vtk para descomponer un volumen 4D
#matriz de transformacion
ras2ijk = vtk.vtkMatrix4x4()
ijk2ras = vtk.vtkMatrix4x4()
#le solicitamos al volumen original que nos devuelva sus matrices
volumen4D.GetRASToIJKMatrix(ras2ijk)
volumen4D.GetIJKToRASMatrix(ijk2ras)
extract1 = vtk.vtkImageExtractComponents()
extract1.SetInputData(imagenvtk4D)
## print(extract1)
#creo un volumen nuevo
volumenFijo = slicer.vtkMRMLScalarVolumeNode()
#le asigno las transformaciones
volumenFijo.SetRASToIJKMatrix(ras2ijk)
volumenFijo.SetIJKToRASMatrix(ijk2ras)
#le asigno el volumen 3D fijo
extract1.SetComponents(0)
extract1.Update()
volumenFijo.SetName('Fijo')
volumenFijo.SetAndObserveImageData(extract1.GetOutput())
#anado el nuevo volumen a la escena
escena.AddNode(volumenFijo)
vol_desp = []
## volumenSalida = self.volumeSelector.currentNode()
volumenSalida = slicer.vtkMRMLScalarVolumeNode()
slicer.mrmlScene.AddNode(volumenSalida)
j = 1
bandera = 0
Desp_LR1 = 0
Desp_PA1 = 0
Desp_IS1 = 0
frameLabelsAttr = ''
frames = []
volumeLabels = vtk.vtkDoubleArray()
volumeLabels.SetNumberOfTuples(numero_imagenes)
volumeLabels.SetNumberOfComponents(1)
volumeLabels.Allocate(numero_imagenes)
mvImage = vtk.vtkImageData()
mvImage.SetExtent(volumenFijo.GetImageData().GetExtent()
) ##Se le asigna la dimension del miltuvolumen
mvImage.AllocateScalars(
volumenFijo.GetImageData().GetScalarType(), numero_imagenes
) ##Se le asigna el tipo y numero de cortes al multivolumen
mvImageArray = vtk.util.numpy_support.vtk_to_numpy(
mvImage.GetPointData().GetScalars()
) ## Se crea la matriz de datos donde va a ir la imagen
mat = vtk.vtkMatrix4x4()
##Se hace la conversion y se obtiene la matriz de transformacion del nodo
volumenFijo.GetRASToIJKMatrix(mat)
mvNode.SetRASToIJKMatrix(mat)
volumenFijo.GetIJKToRASMatrix(mat)
mvNode.SetIJKToRASMatrix(mat)
##
for i in range(numero_imagenes):
# extraigo la imagen movil
extract1.SetComponents(i) #Seleccionar un volumen lejano
extract1.Update()
#Creo un volumen movil, y realizamos el mismo procedimiento que con el fijo
volumenMovil = slicer.vtkMRMLScalarVolumeNode()
volumenMovil.SetRASToIJKMatrix(ras2ijk)
volumenMovil.SetIJKToRASMatrix(ijk2ras)
volumenMovil.SetAndObserveImageData(extract1.GetOutput())
volumenMovil.SetName('movil')
escena.AddNode(volumenMovil)
## slicer.util.saveNode(volumenMovil,'volumenMovil'+str(i+1)+'.nrrd')
#creamos la transformada para alinear los volumenes
transformadaSalidaBSpline = slicer.vtkMRMLBSplineTransformNode()
transformadaSalidaBSpline.SetName(
'Transformada de registro BSpline' + str(i + 1))
slicer.mrmlScene.AddNode(transformadaSalidaBSpline)
transformadaSalidaLinear = slicer.vtkMRMLLinearTransformNode()
transformadaSalidaLinear.SetName(
'Transformada de registro Lineal' + str(i + 1))
slicer.mrmlScene.AddNode(transformadaSalidaLinear)
#parametros para la operacion de registro
parameters = {}
if Tipo_registro == 'Rigid-BSpline':
parameters['fixedVolume'] = volumenFijo.GetID()
parameters['movingVolume'] = volumenMovil.GetID()
parameters['transformType'] = 'Rigid'
parameters['outputTransform'] = transformadaSalidaLinear.GetID(
)
parameters['outputVolume'] = volumenSalida.GetID()
cliNode = slicer.cli.run(slicer.modules.brainsfit,
None,
parameters,
wait_for_completion=True)
if bandera == 0:
bandera = 1
volumenFijo = volumenSalida
parameters['fixedVolume'] = volumenFijo.GetID()
parameters['movingVolume'] = volumenSalida.GetID()
parameters['transformType'] = 'BSpline'
parameters[
'outputTransform'] = transformadaSalidaBSpline.GetID()
parameters['outputVolume'] = volumenSalida.GetID()
cliNode = slicer.cli.run(slicer.modules.brainsfit,
None,
parameters,
wait_for_completion=True)
slicer.util.saveNode(volumenSalida,
'volumenSalida' + str(i + 1) + '.nrrd')
frameImage = volumenSalida.GetImageData()
frameImageArray = vtk.util.numpy_support.vtk_to_numpy(
frameImage.GetPointData().GetScalars())
mvImageArray.T[i] = frameImageArray
elif Tipo_registro == 'Rigid-Affine':
parameters['fixedVolume'] = volumenFijo.GetID()
parameters['movingVolume'] = volumenMovil.GetID()
parameters['transformType'] = 'Rigid'
parameters['outputTransform'] = transformadaSalidaLinear.GetID(
)
parameters['outputVolume'] = volumenSalida.GetID()
cliNode = slicer.cli.run(slicer.modules.brainsfit,
None,
parameters,
wait_for_completion=True)
Matriz = transformadaSalidaLinear.GetMatrixTransformToParent()
Desp_LR1 = Matriz.GetElement(0, 3)
Desp_PA1 = Matriz.GetElement(1, 3)
Desp_IS1 = Matriz.GetElement(2, 3)
print(Desp_LR1)
if bandera == 0:
bandera = 1
volumenFijo = volumenSalida
parameters['fixedVolume'] = volumenFijo.GetID()
parameters['movingVolume'] = volumenSalida.GetID()
parameters['transformType'] = 'Affine'
parameters['outputTransform'] = transformadaSalidaLinear.GetID(
)
parameters['outputVolume'] = volumenSalida.GetID()
cliNode = slicer.cli.run(slicer.modules.brainsfit,
None,
parameters,
wait_for_completion=True)
slicer.util.saveNode(volumenSalida,
'volumenSalida' + str(i + 1) + '.nrrd')
frameImage = volumenSalida.GetImageData()
frameImageArray = vtk.util.numpy_support.vtk_to_numpy(
frameImage.GetPointData().GetScalars())
mvImageArray.T[i] = frameImageArray
elif (Tipo_registro == 'Rigid') or (Tipo_registro
== 'Bspline') or (Tipo_registro
== 'Affine'):
parameters['fixedVolume'] = volumenFijo.GetID()
parameters['movingVolume'] = volumenMovil.GetID()
parameters['transformType'] = Tipo_registro
## parameters['linearTransform'] = transformadaSalidaLinear.GetID()
## parameters['bsplineTransform'] = transformadaSalidaBSpline.GetID()
if Tipo_registro == 'Bspline':
parameters[
'outputTransform'] = transformadaSalidaBSpline.GetID()
else:
parameters[
'outputTransform'] = transformadaSalidaLinear.GetID()
parameters['outputVolume'] = volumenSalida.GetID()
cliNode = slicer.cli.run(slicer.modules.brainsfit,
None,
parameters,
wait_for_completion=True)
slicer.util.saveNode(volumenSalida,
'volumenSalida' + str(i + 1) + '.nrrd')
print('entre')
frameImage = volumenSalida.GetImageData()
frameImageArray = vtk.util.numpy_support.vtk_to_numpy(
frameImage.GetPointData().GetScalars())
mvImageArray.T[i] = frameImageArray
mvDisplayNode = slicer.mrmlScene.CreateNodeByClass(
'vtkMRMLMultiVolumeDisplayNode')
mvDisplayNode.SetScene(slicer.mrmlScene)
slicer.mrmlScene.AddNode(mvDisplayNode)
mvDisplayNode.SetReferenceCount(mvDisplayNode.GetReferenceCount() -
1)
mvDisplayNode.SetDefaultColorMap()
mvNode.SetAndObserveDisplayNodeID(mvDisplayNode.GetID())
mvNode.SetAndObserveImageData(mvImage)
mvNode.SetNumberOfFrames(numero_imagenes)
mvNode.SetLabelArray(volumeLabels)
mvNode.SetLabelName('na')
mvNode.SetAttribute('MultiVolume.FrameLabels', frameLabelsAttr)
mvNode.SetAttribute('MultiVolume.NumberOfFrames',
str(numero_imagenes))
mvNode.SetAttribute('MultiVolume.FrameIdentifyingDICOMTagName',
'NA')
mvNode.SetAttribute('MultiVolume.FrameIdentifyingDICOMTagUnits',
'na')
mvNode.SetName('MultiVolume Registrado')
Helper.SetBgFgVolumes(mvNode.GetID(), None)
Matriz = transformadaSalidaLinear.GetMatrixTransformToParent()
Desp_LR2 = Matriz.GetElement(0, 3)
Desp_PA2 = Matriz.GetElement(1, 3)
Desp_IS2 = Matriz.GetElement(2, 3)
print(Desp_LR2)
Desp_LR = Desp_LR2 + Desp_LR1
Desp_PA = Desp_PA2 + Desp_PA1
Desp_IS = Desp_IS2 + Desp_IS1
if ((abs(Desp_LR) > 1) or (abs(Desp_PA) > 1)
or (abs(Desp_IS) > 1)):
print(j)
vol_des = 'VOLUMEN' + str(
i + 1) + ' Desplazamiento --> LR: ' + str(
Desp_LR) + ' PA: ' + str(Desp_PA) + ' IS: ' + str(
Desp_IS)
vol_desp.append(vol_des)
print('Registro completo')
print(vol_desp)
#al terminar el ciclo for con todos los volumenes registrados se genera una
#ventana emergente con un mensaje("Registro completo!") y mostrando los
#volumenes que se desplazaron mas de 4mm
qt.QMessageBox.information(slicer.util.mainWindow(), 'Slicer Python',
'Registro completo' + str(vol_desp))
return True
def run(self, inputVolume):
"""
Run the actual algorithm
"""
#se obtiene la escena y se obtiene el volumen 4D a partir del Volumen 4D de
#entrada de la ventana desplegable
escena = slicer.mrmlScene
imagenvtk4D = inputVolume.GetImageData()
#Se obtiene el número de volúmenes que tiene el volumen 4D
numero_imagenes = inputVolume.GetNumberOfFrames()
print('imagenes: ' + str(numero_imagenes))
#filtro vtk para descomponer un volumen 4D
extract1 = vtk.vtkImageExtractComponents()
extract1.SetInputData(imagenvtk4D)
#matriz de transformación
ras2ijk = vtk.vtkMatrix4x4()
ijk2ras = vtk.vtkMatrix4x4()
#le solicitamos al volumen original que nos devuelva sus matrices
inputVolume.GetRASToIJKMatrix(ras2ijk)
inputVolume.GetIJKToRASMatrix(ijk2ras)
#creo un volumen nuevo
volumenFijo = slicer.vtkMRMLScalarVolumeNode()
volumenSalida = slicer.vtkMRMLScalarVolumeNode()
#le asigno las transformaciones
volumenFijo.SetRASToIJKMatrix(ras2ijk)
volumenFijo.SetIJKToRASMatrix(ijk2ras)
#le asigno el volumen 3D fijo
imagen_fija = extract1.SetComponents(0)
extract1.Update()
volumenFijo.SetName('fijo')
volumenFijo.SetAndObserveImageData(extract1.GetOutput())
#anado el nuevo volumen a la escena
escena.AddNode(volumenFijo)
#se crea un vector para guardar el número del volumen que tenga un
#desplazamiento de mas de 4mm en cualquier dirección
v = []
#se hace un ciclo for para registrar todos los demás volúmenes del volumen 4D
#con el primer volumen que se definió como fijo
for i in range(numero_imagenes - 1):
# extraigo la imagen móvil en la posición i+1 ya que el primero es el fijo
imagen_movil = extract1.SetComponents(
i + 1) #Seleccionar un volumen i+1
extract1.Update()
#Creo el volumen móvil, y realizo el mismo procedimiento que con el fijo
volumenMovil = slicer.vtkMRMLScalarVolumeNode()
volumenMovil.SetRASToIJKMatrix(ras2ijk)
volumenMovil.SetIJKToRASMatrix(ijk2ras)
volumenMovil.SetAndObserveImageData(extract1.GetOutput())
volumenMovil.SetName('movil ' + str(i + 1))
escena.AddNode(volumenMovil)
#creamos la transformada para alinear los volúmenes
transformadaSalida = slicer.vtkMRMLLinearTransformNode()
transformadaSalida.SetName('Transformadaderegistro' + str(i + 1))
slicer.mrmlScene.AddNode(transformadaSalida)
#parámetros para la operación de registro
parameters = {}
#parameters['InitialTransform'] = transI.GetID()
parameters['fixedVolume'] = volumenFijo.GetID()
parameters['movingVolume'] = volumenMovil.GetID()
parameters['transformType'] = 'Rigid'
parameters['outputTransform'] = transformadaSalida.GetID()
parameters['outputVolume'] = volumenSalida.GetID()
#Realizo el registro
cliNode = slicer.cli.run(slicer.modules.brainsfit,
None,
parameters,
wait_for_completion=True)
#obtengo la transformada lineal que se usó en el registro
transformada = escena.GetFirstNodeByName('Transformadaderegistro' +
str(i + 1))
#Obtengo la matriz de la transformada, esta matriz es de dimensiones 4x4
#en la cual estan todos los desplazamientos y rotaciones que se hicieron
#en la transformada, a partir de ella se obtienen los volumenes que se
#desplazaron mas de 4mm en cualquier direccion
Matriz = transformada.GetMatrixTransformToParent()
LR = Matriz.GetElement(
0, 3) #dirección izquierda o derecha en la fila 1, columna 4
PA = Matriz.GetElement(
1, 3) #dirección anterior o posterior en la fila 2, columna 4
IS = Matriz.GetElement(
2, 3) #dirección inferior o superior en la fila 3, columna 4
#Se mira si el volumen "i" en alguna dirección tuvo un desplazamiento
#mayor a 4mm, en caso de ser cierto se guarda en el vector "v"
if abs(LR) > 4:
v.append(i + 2)
elif abs(PA) > 4:
v.append(i + 2)
elif abs(IS) > 4:
v.append(i + 2)
print('Registro completo')
#al terminar el ciclo for con todos los volúmenes registrados se genera una
#ventana emergente con un mensaje("Registro completo!") y mostrando los
#volúmenes que se desplazaron mas de 4mm
qt.QMessageBox.information(
slicer.util.mainWindow(), 'Slicer Python',
'Registro completo!\nVolumenes con movimiento mayor a 4mm:\n' +
str(v))
return True
def remove_alpha(img):
"""Remove the alpha channel from ``vtk.vtkImageData``."""
ec = vtk.vtkImageExtractComponents()
ec.SetComponents(0, 1, 2)
ec.SetInputData(img)
return ec.GetOutput()
def main():
colors = vtk.vtkNamedColors()
fileName = get_program_parameters()
# Read the image.
readerFactory = vtk.vtkImageReader2Factory()
reader = readerFactory.CreateImageReader2(fileName)
reader.SetFileName(fileName)
reader.Update()
fft = vtk.vtkImageFFT()
fft.SetInputConnection(reader.GetOutputPort())
idealHighPass = vtk.vtkImageIdealHighPass()
idealHighPass.SetInputConnection(fft.GetOutputPort())
idealHighPass.SetXCutOff(0.1)
idealHighPass.SetYCutOff(0.1)
idealRfft = vtk.vtkImageRFFT()
idealRfft.SetInputConnection(idealHighPass.GetOutputPort())
idealReal = vtk.vtkImageExtractComponents()
idealReal.SetInputConnection(idealRfft.GetOutputPort())
idealReal.SetComponents(0)
butterworthHighPass = vtk.vtkImageButterworthHighPass()
butterworthHighPass.SetInputConnection(fft.GetOutputPort())
butterworthHighPass.SetXCutOff(0.1)
butterworthHighPass.SetYCutOff(0.1)
butterworthRfft = vtk.vtkImageRFFT()
butterworthRfft.SetInputConnection(butterworthHighPass.GetOutputPort())
butterworthReal = vtk.vtkImageExtractComponents()
butterworthReal.SetInputConnection(butterworthRfft.GetOutputPort())
butterworthReal.SetComponents(0)
# Create the actors.
idealColor = vtk.vtkImageMapToWindowLevelColors()
idealColor.SetWindow(500)
idealColor.SetLevel(0)
idealColor.SetInputConnection(idealReal.GetOutputPort())
idealActor = vtk.vtkImageActor()
idealActor.GetMapper().SetInputConnection(idealColor.GetOutputPort())
idealActor.GetProperty().SetInterpolationTypeToNearest()
butterworthColor = vtk.vtkImageMapToWindowLevelColors()
butterworthColor.SetWindow(500)
butterworthColor.SetLevel(0)
butterworthColor.SetInputConnection(butterworthReal.GetOutputPort())
butterworthActor = vtk.vtkImageActor()
butterworthActor.GetMapper().SetInputConnection(butterworthColor.GetOutputPort())
butterworthActor.GetProperty().SetInterpolationTypeToNearest()
# Setup the renderers.
idealRenderer = vtk.vtkRenderer()
idealRenderer.SetViewport(0.0, 0.0, 0.5, 1.0)
idealRenderer.AddActor(idealActor)
idealRenderer.ResetCamera()
idealRenderer.SetBackground(colors.GetColor3d("SlateGray"))
butterworthRenderer = vtk.vtkRenderer()
butterworthRenderer.SetViewport(0.5, 0.0, 1.0, 1.0)
butterworthRenderer.AddActor(butterworthActor)
butterworthRenderer.SetActiveCamera(idealRenderer.GetActiveCamera())
butterworthRenderer.SetBackground(colors.GetColor3d("LightSlateGray"))
renderWindow = vtk.vtkRenderWindow()
renderWindow.SetSize(600, 300)
renderWindow.SetWindowName('IdealHighPass')
renderWindow.AddRenderer(idealRenderer)
renderWindow.AddRenderer(butterworthRenderer)
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
style = vtk.vtkInteractorStyleImage()
renderWindowInteractor.SetInteractorStyle(style)
renderWindowInteractor.SetRenderWindow(renderWindow)
idealRenderer.GetActiveCamera().Dolly(1.4)
idealRenderer.ResetCameraClippingRange()
renderWindowInteractor.Initialize()
renderWindowInteractor.Start()
def process(
self
): #La funcion process es la encargada de realizar el registro.
escena = slicer.mrmlScene
#Se carga la escena
volumen4D = self.inputSelector.currentNode()
#Se carga el volumen seleccionado por el usuario
estructual = self.inputSelector_estructural.currentNode()
#se carga el volumen estructural seleccionado por el usuario
imagenvtk4D = volumen4D.GetImageData(
) #Se recupera la informacion del volumen
imagenvtkestructural = estructual.GetImageData()
# se recupera la informacion del volumen estructual
numero_imagenes = volumen4D.GetNumberOfFrames(
) #Numero de volumenes en el volumen 4D cargado
RegistrationType = self.inputSelector2.currentText #Se recupera el tipo de registro elegido
KernelSize = self.inputSelector3.currentText # se recupera el tamano del kernel
extract1 = vtk.vtkImageExtractComponents(
) #filtro vtk para descomponer un volumen 4D
extract1.SetInputData(
imagenvtk4D) #Se asigna el volumen 4D que se quiere descomponer
#matriz vacia para la recuperar en ella la transformacion de coordenadas
ras2ijk = vtk.vtkMatrix4x4()
ijk2ras = vtk.vtkMatrix4x4()
#le solicitamos al volumen original que nos devuelva sus matrices de transformaciones y se las asigne a las matrices vacias
volumen4D.GetRASToIJKMatrix(ras2ijk)
volumen4D.GetIJKToRASMatrix(ijk2ras)
#se crea un volumen vacio que sera el volumen fijo
volumenFijo = slicer.vtkMRMLScalarVolumeNode()
#se le asignan las transformaciones de coordenadas
volumenFijo.SetRASToIJKMatrix(ras2ijk)
volumenFijo.SetIJKToRASMatrix(ijk2ras)
#se le asigna el volumen 3D fijo
imagen_fija = extract1.SetComponents(0)
extract1.Update() #IMPORTANTE: necesario para guardar los cambios
volumenFijo.SetName('fijo') #se le asigna un nombre
volumenFijo.SetAndObserveImageData(
extract1.GetOutput()) #se le asigna un volumen visible
#se agrega el nuevo volumen a la escena
escena.AddNode(volumenFijo)
# el siguiente for Permite realizar la tranformacion de registro para cada uno de los volumenes diferentes al volumen fijo inicial
for i in range(
1,
numero_imagenes): #recorre todos los volumenes menos el fijo
# se extrae la imagen movil
imagen_movil = extract1.SetComponents(
i) #Selecciona un volumen cada vez
extract1.Update() #IMPORTANTE: sirve para actualizar los cambios
#Creo un volumen movil, y realizamos el mismo procedimiento que con el fijo
volumenMovil = slicer.vtkMRMLScalarVolumeNode()
volumenMovil.SetRASToIJKMatrix(ras2ijk)
volumenMovil.SetIJKToRASMatrix(ijk2ras)
volumenMovil.SetAndObserveImageData(extract1.GetOutput())
volumenMovil.SetName(
'movil' + str(i)
) #Se nombra como movil(i) si no se marca todos tendrian el mismo nombre en la escena
escena.AddNode(volumenMovil)
#creamos la transformada para alinear los volumenes
#en todos los casos se realiza una transformada rigida ya que esta brinda un punto de partida para las demas transformadas Bspline y Affine
transformadaSalida = slicer.vtkMRMLLinearTransformNode(
) #se crea la transformacion lineal
transformadaSalida.SetName(
'Transformada de registro' +
str(i)) #se nombra la transformada de registro(i)
slicer.mrmlScene.AddNode(
transformadaSalida) #se anade la transformada a la escena
#se asignan los parametros de la transformacion a una estructura parametros{}
parameters = {}
parameters['fixedVolume'] = volumenFijo.GetID() #volumen fijo
parameters['movingVolume'] = volumenMovil.GetID() #volumen movil
parameters[
'transformType'] = 'Rigid' #tipo de tranformacion: esta se hace en primer lugar para todas
parameters['outputTransform'] = transformadaSalida.GetID(
) #transformacion de salida
parameters['outputVolume'] = volumenMovil.GetID()
#volumen luego de la transformacion
cliNode = slicer.cli.run(
slicer.modules.brainsfit,
None,
parameters,
wait_for_completion=True
) #aplica la transformacion segun los parametros ingresados
if RegistrationType == 'Rigid': #Si el usuario elige el tipo de registro: rigido
# SUAVIZADO
parameters1 = {} #parametros del filtro
parameters1['inputVolume'] = volumenMovil.GetID()
parameters1['outputVolume'] = volumenMovil.GetID()
parameters1['sigma'] = self.inputSelector3.currentText
cliNode = slicer.cli.run(
slicer.modules.gaussianblurimagefilter,
None,
parameters1,
wait_for_completion=True
) #se corre la transformada elegida bspline o affine
slicer.util.saveNode(
volumenMovil, 'volumenmovil' + str(i) + '.nrrd'
) # se guarda cada volumen movil(i) transformado en mis documentos
escena.RemoveNode(
volumenMovil
) #Una vez realizada la transformacion se remueve el volumen de la escena
if not RegistrationType == 'Rigid': #si el usuario no eligio una transformada rigida,
escena.RemoveNode(
transformadaSalida) #se remueve la transformada rigida
if RegistrationType == "BSpline": #si el usuario eligio la transformada bspline
transformadaSalida = slicer.vtkMRMLBSplineTransformNode(
) #se crea una transformada no lineal bspline
elif RegistrationType == "Affine": #si el usuario eligio la transformada affine
transformadaSalida = slicer.vtkMRMLLinearTransformNode(
) # se crea una transformacion lineal
transformadaSalida.SetName(
'Transformada de registro' + str(i)
) #se nombra la transformada creada y se agrega a la escena
slicer.mrmlScene.AddNode(transformadaSalida)
parameters = {} #parametros de la transformada
parameters['fixedVolume'] = volumenFijo.GetID()
parameters['movingVolume'] = volumenMovil.GetID()
parameters[
'transformType'] = RegistrationType #esta variable se recupera segun la eleccion del usuario
parameters['outputTransform'] = transformadaSalida.GetID()
parameters['outputVolume'] = volumenMovil.GetID()
cliNode = slicer.cli.run(
slicer.modules.brainsfit,
None,
parameters,
wait_for_completion=True
) #se corre la transformada elegida bspline o affine
parameters1 = {} #parametros del filtro
parameters1['inputVolume'] = volumenMovil.GetID()
parameters1['outputVolume'] = volumenMovil.GetID()
parameters1['sigma'] = self.inputSelector3.currentText
cliNode = slicer.cli.run(
slicer.modules.gaussianblurimagefilter,
None,
parameters1,
wait_for_completion=True
) #se corre la transformada elegida bspline o affine
slicer.util.saveNode(
volumenMovil, 'volumenmovil' + str(i) +
'.nrrd') #se guarda el nodo y se remueve de la escena
escena.RemoveNode(volumenMovil)
estructual.GetRASToIJKMatrix(ras2ijk)
estructual.GetIJKToRASMatrix(ijk2ras)
#se crea un volumen vacio que sera el volumen fijo
vol_estructural_movil = slicer.vtkMRMLScalarVolumeNode()
#se le asignan las transformaciones de coordenadas
vol_estructural_movil.SetRASToIJKMatrix(ras2ijk)
vol_estructural_movil.SetIJKToRASMatrix(ijk2ras)
#se le asigna el volumen 3D fijo
#imagen_estruct_movil = extract2.SetComponents(0)
#extract2.Update() #IMPORTANTE: necesario para guardar los cambios
vol_estructural_movil.SetName('estructural') #se le asigna un nombre
vol_estructural_movil.SetAndObserveImageData(
imagenvtkestructural) #se le asigna un volumen visible
escena.AddNode(vol_estructural_movil)
transformadaSalida = slicer.vtkMRMLLinearTransformNode(
) #se crea la transformacion lineal
#transformadaSalida = slicer.vtkMRMLBSplineTransformNode()#se crea la transformacion lineal
transformadaSalida.SetName('Transformada de registro estructual'
) #se nombra la transformada de registro(i)
slicer.mrmlScene.AddNode(
transformadaSalida) #se anade la transformada a la escena
#se asignan los parametros de la transformacion a una estructura parametros{}
parameters = {}
parameters['fixedVolume'] = volumenFijo.GetID() #volumen fijo
parameters['movingVolume'] = vol_estructural_movil.GetID(
) #volumen movil
##parameters['movingVolume'] = escena.GetNodeByID('vtkMRMLScalarVolumeNode1')#volumen movil
parameters[
'transformType'] = 'Affine' #tipo de tranformacion: esta se hace en primer lugar para todas
parameters['outputTransform'] = transformadaSalida.GetID(
) #transformacion de salida
parameters['outputVolume'] = vol_estructural_movil.GetID()
#volumen luego de la transformacion
cliNode = slicer.cli.run(
slicer.modules.brainsfit,
None,
parameters,
wait_for_completion=True
) #aplica la transformacion segun los parametros ingresados
parameters1 = {} #parametros del filtro
parameters1['inputVolume'] = volumenFijo.GetID()
parameters1['outputVolume'] = volumenFijo.GetID()
parameters1['sigma'] = self.inputSelector3.currentText
cliNode = slicer.cli.run(slicer.modules.gaussianblurimagefilter,
None,
parameters1,
wait_for_completion=True)
#se agrega el nuevo volumen a la escena
slicer.util.saveNode(
volumenFijo, 'volumenfijo.nrrd'
) #se guarda el volumen fijo en mis documentos; .nrrd es la extension para nodos
slicer.util.saveNode(
vol_estructural_movil, 'volumenestructural.nrrd'
) #se guarda el volumen fijo en mis documentos; .nrrd es la extension para nodos
escena.RemoveNode(vol_estructural_movil)
escena.RemoveNode(
volumenFijo) #al finalizar el for se remueve el volumen fijo
slicer.util.openAddDataDialog(
) #se abre la ventana para cargar datos para que el usuario cargue los volumenes creados y guardados
mensaje = 'Registro y Suavizado Completados'
qt.QMessageBox.information(slicer.util.mainWindow(), 'Slicer Python',
mensaje) #se muestra en ventana
print(mensaje) # se muestra en el python interactor
def onApplyButton(self):
mvNode = self.outputSelector.currentNode()
inputVolume= self.inputSelector.currentNode()
"""
Run the actual algorithm
"""
#se obtiene la escena y se obtiene el volumen 4D a partir del Volumen 4D de
#entrada de la ventana desplegable
escena = slicer.mrmlScene
imagenvtk4D = inputVolume.GetImageData()
#Se obtiene el número de volúmenes que tiene el volumen 4D
numero_imagenes = inputVolume.GetNumberOfFrames()
print('imagenes: ' + str(numero_imagenes))
#filtro vtk para descomponer un volumen 4D
extract1 = vtk.vtkImageExtractComponents()
extract1.SetInputData(imagenvtk4D)
#matriz de transformación
ras2ijk = vtk.vtkMatrix4x4()
ijk2ras = vtk.vtkMatrix4x4()
#le solicitamos al volumen original que nos devuelva sus matrices
inputVolume.GetRASToIJKMatrix(ras2ijk)
inputVolume.GetIJKToRASMatrix(ijk2ras)
#creo un volumen nuevo
volumenFijo = slicer.vtkMRMLScalarVolumeNode()
volumenSalida = slicer.vtkMRMLMultiVolumeNode()
#le asigno las transformaciones
volumenFijo.SetRASToIJKMatrix(ras2ijk)
volumenFijo.SetIJKToRASMatrix(ijk2ras)
#le asigno el volumen 3D fijo
imagen_fija = extract1.SetComponents(0)
extract1.Update()
volumenFijo.SetName('fijo')
volumenFijo.SetAndObserveImageData(extract1.GetOutput())
#anado el nuevo volumen a la escena
escena.AddNode(volumenFijo)
#se crea un vector para guardar el número del volumen que tenga un
#desplazamiento de mas de 4mm en cualquier dirección
v=[]
#se hace un ciclo for para registrar todos los demás volúmenes del volumen 4D
#con el primer volumen que se definió como fijo
frameLabelsAttr=''
frames = []
volumeLabels = vtk.vtkDoubleArray()
volumeLabels.SetNumberOfTuples(numero_imagenes)
volumeLabels.SetNumberOfComponents(1)
volumeLabels.Allocate(numero_imagenes)
for i in range(numero_imagenes):
# extraigo la imagen móvil en la posición i+1 ya que el primero es el fijo
imagen_movil = extract1.SetComponents(i+1) #Seleccionar un volumen i+1
extract1.Update()
#Creo el volumen móvil, y realizo el mismo procedimiento que con el fijo
volumenMovil = slicer.vtkMRMLScalarVolumeNode();
volumenMovil.SetRASToIJKMatrix(ras2ijk)
volumenMovil.SetIJKToRASMatrix(ijk2ras)
volumenMovil.SetAndObserveImageData(extract1.GetOutput())
volumenMovil.SetName('movil '+str(i+1))
escena.AddNode(volumenMovil)
#creamos la transformada para alinear los volúmenes
transformadaSalida = slicer.vtkMRMLLinearTransformNode()
transformadaSalida.SetName('Transformadaderegistro'+str(i+1))
slicer.mrmlScene.AddNode(transformadaSalida)
#parámetros para la operación de registro
parameters = {}
#parameters['InitialTransform'] = transI.GetID()
parameters['fixedVolume'] = volumenFijo.GetID()
parameters['movingVolume'] = volumenMovil.GetID()
parameters['transformType'] = 'Rigid'
parameters['outputTransform'] = transformadaSalida.GetID()
frames.append(volumenMovil)
## parameters['outputVolume']=volumenSalida.GetID()
#Realizo el registro
cliNode = slicer.cli.run( slicer.modules.brainsfit,None,parameters,wait_for_completion=True)
#obtengo la transformada lineal que se usó en el registro
transformada=escena.GetFirstNodeByName('Transformadaderegistro'+str(i+1))
#Obtengo la matriz de la transformada, esta matriz es de dimensiones 4x4
#en la cual estan todos los desplazamientos y rotaciones que se hicieron
#en la transformada, a partir de ella se obtienen los volumenes que se
#desplazaron mas de 4mm en cualquier direccion
frameId = i;
volumeLabels.SetComponent(i, 0, frameId)
frameLabelsAttr += str(frameId)+','
Matriz=transformada.GetMatrixTransformToParent()
LR=Matriz.GetElement(0,3)#dirección izquierda o derecha en la fila 1, columna 4
PA=Matriz.GetElement(1,3)#dirección anterior o posterior en la fila 2, columna 4
IS=Matriz.GetElement(2,3)#dirección inferior o superior en la fila 3, columna 4
#Se mira si el volumen "i" en alguna dirección tuvo un desplazamiento
#mayor a 4mm, en caso de ser cierto se guarda en el vector "v"
if abs(LR)>4:
v.append(i+2)
elif abs(PA)>4:
v.append(i+2)
elif abs(IS)>4:
v.append(i+2)
print("MovilExtent: "+str(volumenMovil.GetImageData().GetExtent()))
## print("valor de f: "+ str(volumenMovil))
frameLabelsAttr = frameLabelsAttr[:-1]
mvImage = vtk.vtkImageData()
mvImage.SetExtent(volumenMovil.GetImageData().GetExtent())##Se le asigna la dimensión del miltuvolumen
mvImage.AllocateScalars(volumenMovil.GetImageData().GetScalarType(), numero_imagenes)##Se le asigna el tipo y número de cortes al multivolumen
mvImageArray = vtk.util.numpy_support.vtk_to_numpy(mvImage.GetPointData().GetScalars())## Se crea la matriz de datos donde va a ir la imagen
mat = vtk.vtkMatrix4x4()
##Se hace la conversión y se obtiene la matriz de transformación del nodo
volumenMovil.GetRASToIJKMatrix(mat)
mvNode.SetRASToIJKMatrix(mat)
volumenMovil.GetIJKToRASMatrix(mat)
mvNode.SetIJKToRASMatrix(mat)
print("frameId: "+str(frameId))
print("# imag: "+str(numero_imagenes))
## print("Long frame1: "+str(len(frame)))
print("Long frames: "+str(len(frames)))
##
for frameId in range(numero_imagenes):
# TODO: check consistent size and orientation!
frame = frames[frameId]
frameImage = frame.GetImageData()
frameImageArray = vtk.util.numpy_support.vtk_to_numpy(frameImage.GetPointData().GetScalars())
mvImageArray.T[frameId] = frameImageArray
##Se crea el nodo del multivolumen
mvDisplayNode = slicer.mrmlScene.CreateNodeByClass('vtkMRMLMultiVolumeDisplayNode')
mvDisplayNode.SetScene(slicer.mrmlScene)
slicer.mrmlScene.AddNode(mvDisplayNode)
mvDisplayNode.SetReferenceCount(mvDisplayNode.GetReferenceCount()-1)
mvDisplayNode.SetDefaultColorMap()
mvNode.SetAndObserveDisplayNodeID(mvDisplayNode.GetID())
mvNode.SetAndObserveImageData(mvImage)
mvNode.SetNumberOfFrames(numero_imagenes)
mvNode.SetLabelArray(volumeLabels)
mvNode.SetLabelName('na')
mvNode.SetAttribute('MultiVolume.FrameLabels',frameLabelsAttr)
mvNode.SetAttribute('MultiVolume.NumberOfFrames',str(numero_imagenes))
mvNode.SetAttribute('MultiVolume.FrameIdentifyingDICOMTagName','NA')
mvNode.SetAttribute('MultiVolume.FrameIdentifyingDICOMTagUnits','na')
mvNode.SetName('MultiVolume Registrado')
Helper.SetBgFgVolumes(mvNode.GetID(),None)
print('Registro completo')
#al terminar el ciclo for con todos los volúmenes registrados se genera una
#ventana emergente con un mensaje("Registro completo!") y mostrando los
#volúmenes que se desplazaron mas de 4mm
qt.QMessageBox.information(slicer.util.mainWindow(),'Slicer Python','Registro completo!\nVolumenes con movimiento mayor a 4mm:\n'+str(v))
return True
def registrarButton(self):
#La función registrarButton permitirá recuperar información del multivolumen,
#la creación de nodos tipo "ScalarVolumeNode" y "MultiVolumeNode" donde estarán asociados
#las matrices de transformación del multivolumen importado. El primer volumen será nombrado
#como 'Fijo' y los demás serán volumen tipo 'Móvil'. Se añaden los mismos a la escena creada previamente.
#Se creará un multivolumen que sera el reconstruido a partir del registro y se empezará a extraer componente a
#componente del multivolumen importado, esto se repite desde el frame 0 hasta el numero de frame totales.
#Se añaden a la escena atributos que brindan información sobre la transformada.
#Se podrá entonces implementar el modulo cli de registro "brainsfit", que tomará los parámetros de entrada y
#aplicará el correspondiente tipo de registro al multivolumen seleccionado.
#Finalmente, se recuperarán los datos de desplazamiento por medio de la matriz de transformación y el volumen de salida se usará
#para hacer la reconstrucción del multivolumen añadiendo un nodo de visualización. Se mostrarán los volumenes con desplazamiento mayor de 1 mm.
if str(self.inputSelector.currentNode()) == 'None':
print('ERROR:Select Input Volume Node')
qt.QMessageBox.information(slicer.util.mainWindow(),
'Slicer Python',
'ERROR:Select Input Volume Node')
return True
else:
Tipo_registro = self.typeComboBox.currentText #el tipo de registro seleccionado previamente en el layout de parameters
mvNode = slicer.vtkMRMLMultiVolumeNode(
) #creación nodo multivolumen
slicer.mrmlScene.AddNode(mvNode) #añadir a la escena el nodo
escena = slicer.mrmlScene
volumen4D = self.inputSelector.currentNode()
imagenvtk4D = volumen4D.GetImageData()
numero_imagenes = volumen4D.GetNumberOfFrames(
) #numero de frames del MV
print('imagenes: ' + str(numero_imagenes))
#filtro vtk para descomponer un volumen 4D
extract1 = vtk.vtkImageExtractComponents()
extract1.SetInputData(imagenvtk4D)
#matriz de transformacion
ras2ijk = vtk.vtkMatrix4x4()
ijk2ras = vtk.vtkMatrix4x4()
#le solicitamos al volumen original que nos devuelva sus matrices
volumen4D.GetRASToIJKMatrix(ras2ijk)
volumen4D.GetIJKToRASMatrix(ijk2ras)
#creo un volumen nuevo
#volumenFijo = self.inputVolumeSelector.currentNode();
#le asigno las transformaciones
#le asigno el volumen 3D fijo
extract1.SetComponents(0)
extract1.Update()
volumenFijo = slicer.vtkMRMLScalarVolumeNode()
volumenFijo.SetName('Fijo')
volumenFijo.SetAndObserveImageData(extract1.GetOutput())
volumenFijo.SetRASToIJKMatrix(ras2ijk)
volumenFijo.SetIJKToRASMatrix(ijk2ras)
#anado el nuevo volumen a la escena
escena.AddNode(volumenFijo)
vol_desp = []
volumenSalida = slicer.vtkMRMLScalarVolumeNode()
#creacion de volumen de salida
slicer.mrmlScene.AddNode(volumenSalida)
j = 1
bandera = 0
frameLabelsAttr = ''
volumeLabels = vtk.vtkDoubleArray()
volumeLabels.SetNumberOfTuples(numero_imagenes)
volumeLabels.SetNumberOfComponents(1)
volumeLabels.Allocate(numero_imagenes)
mvImage = vtk.vtkImageData()
mvImage.SetExtent(volumenFijo.GetImageData().GetExtent()
) ##Se le asigna la dimension del miltuvolumen
mvImage.AllocateScalars(
volumenFijo.GetImageData().GetScalarType(), numero_imagenes
) ##Se le asigna el tipo y numero de cortes al multivolumen
mvImageArray = vtk.util.numpy_support.vtk_to_numpy(
mvImage.GetPointData().GetScalars()
) ## Se crea la matriz de datos donde va a ir la imagen
mat = vtk.vtkMatrix4x4()
##Se hace la conversion y se obtiene la matriz de transformacion del nodo
volumenFijo.GetRASToIJKMatrix(mat)
mvNode.SetRASToIJKMatrix(mat)
volumenFijo.GetIJKToRASMatrix(mat)
mvNode.SetIJKToRASMatrix(mat)
##
for i in range(numero_imagenes):
# extraigo la imagen movil
extract1.SetComponents(i) #Seleccionar un volumen lejano
extract1.Update()
#Creo un volumen movil, y realizamos el mismo procedimiento que con el fijo
volumenMovil = slicer.vtkMRMLScalarVolumeNode()
volumenMovil.SetRASToIJKMatrix(ras2ijk)
volumenMovil.SetIJKToRASMatrix(ijk2ras)
volumenMovil.SetAndObserveImageData(extract1.GetOutput())
volumenMovil.SetName('movil')
escena.AddNode(volumenMovil)
#creamos la transformada para alinear los volumenes
transformadaSalidaBSpline = slicer.vtkMRMLBSplineTransformNode(
)
transformadaSalidaBSpline.SetName(
'Transformada de registro BSpline' + str(i + 1))
slicer.mrmlScene.AddNode(transformadaSalidaBSpline)
transformadaSalidaLinear = slicer.vtkMRMLLinearTransformNode()
transformadaSalidaLinear.SetName(
'Transformada de registro Lineal' + str(i + 1))
slicer.mrmlScene.AddNode(transformadaSalidaLinear)
#parametros para la operacion de registro que seran entregados al modulo cli "brainsfit" segun tipo de registro
parameters = {}
if Tipo_registro == 'Rigid-BSpline':
parameters['fixedVolume'] = volumenFijo.GetID()
parameters['movingVolume'] = volumenMovil.GetID()
parameters['transformType'] = 'Rigid'
parameters[
'outputTransform'] = transformadaSalidaLinear.GetID()
parameters['outputVolume'] = volumenSalida.GetID()
cliNode = slicer.cli.run(slicer.modules.brainsfit,
None,
parameters,
wait_for_completion=True)
if bandera == 0:
bandera = 1
volumenFijo = volumenSalida
parameters['fixedVolume'] = volumenFijo.GetID()
parameters['movingVolume'] = volumenSalida.GetID()
parameters['transformType'] = 'BSpline'
parameters[
'outputTransform'] = transformadaSalidaBSpline.GetID()
parameters['outputVolume'] = volumenSalida.GetID()
cliNode = slicer.cli.run(slicer.modules.brainsfit,
None,
parameters,
wait_for_completion=True)
frameImage = volumenSalida.GetImageData()
frameImageArray = vtk.util.numpy_support.vtk_to_numpy(
frameImage.GetPointData().GetScalars())
mvImageArray.T[i] = frameImageArray
elif Tipo_registro == 'Rigid-Affine':
parameters['fixedVolume'] = volumenFijo.GetID()
parameters['movingVolume'] = volumenMovil.GetID()
parameters['transformType'] = 'Rigid'
parameters[
'outputTransform'] = transformadaSalidaLinear.GetID()
parameters['outputVolume'] = volumenSalida.GetID()
cliNode = slicer.cli.run(slicer.modules.brainsfit,
None,
parameters,
wait_for_completion=True)
Matriz = transformadaSalidaLinear.GetMatrixTransformToParent(
)
if bandera == 0:
bandera = 1
volumenFijo = volumenSalida
parameters['fixedVolume'] = volumenFijo.GetID()
parameters['movingVolume'] = volumenSalida.GetID()
parameters['transformType'] = 'Affine'
parameters[
'outputTransform'] = transformadaSalidaLinear.GetID()
parameters['outputVolume'] = volumenSalida.GetID()
cliNode = slicer.cli.run(slicer.modules.brainsfit,
None,
parameters,
wait_for_completion=True)
frameImage = volumenSalida.GetImageData()
frameImageArray = vtk.util.numpy_support.vtk_to_numpy(
frameImage.GetPointData().GetScalars())
mvImageArray.T[i] = frameImageArray
elif (Tipo_registro
== 'Rigid') or (Tipo_registro
== 'Bspline') or (Tipo_registro
== 'Affine'):
parameters['fixedVolume'] = volumenFijo.GetID()
parameters['movingVolume'] = volumenMovil.GetID()
parameters['transformType'] = Tipo_registro
if Tipo_registro == 'Bspline':
parameters[
'outputTransform'] = transformadaSalidaBSpline.GetID(
)
else:
parameters[
'outputTransform'] = transformadaSalidaLinear.GetID(
)
parameters['outputVolume'] = volumenSalida.GetID()
cliNode = slicer.cli.run(slicer.modules.brainsfit,
None,
parameters,
wait_for_completion=True)
Parameters = {}
Parameters['Conductance'] = 1
Parameters['numberOfIterations'] = 5
Parameters['timeStep'] = 0.0625
Parameters['inputVolume'] = volumenSalida.GetID()
Parameters['outputVolume'] = volumenSalida.GetID()
cliNode = slicer.cli.run(
slicer.modules.gradientanisotropicdiffusion,
None,
Parameters,
wait_for_completion=True)
frameImage = volumenSalida.GetImageData()
frameImageArray = vtk.util.numpy_support.vtk_to_numpy(
frameImage.GetPointData().GetScalars())
mvImageArray.T[i] = frameImageArray
if (i == 9):
self.VolumenReferencia = volumenSalida
mvDisplayNode = slicer.mrmlScene.CreateNodeByClass(
'vtkMRMLMultiVolumeDisplayNode')
mvDisplayNode.SetScene(slicer.mrmlScene)
slicer.mrmlScene.AddNode(mvDisplayNode)
mvDisplayNode.SetReferenceCount(
mvDisplayNode.GetReferenceCount() - 1)
mvDisplayNode.SetDefaultColorMap()
mvNode.SetAndObserveDisplayNodeID(mvDisplayNode.GetID())
mvNode.SetAndObserveImageData(mvImage)
mvNode.SetNumberOfFrames(numero_imagenes)
mvNode.SetLabelArray(volumeLabels)
mvNode.SetLabelName('na')
mvNode.SetAttribute('MultiVolume.FrameLabels', frameLabelsAttr)
mvNode.SetAttribute('MultiVolume.NumberOfFrames',
str(numero_imagenes))
mvNode.SetAttribute('MultiVolume.FrameIdentifyingDICOMTagName',
'NA')
mvNode.SetAttribute(
'MultiVolume.FrameIdentifyingDICOMTagUnits', 'na')
mvNode.SetName('MultiVolume Registrado')
Helper.SetBgFgVolumes(mvNode.GetID(), None)
Matriz = transformadaSalidaLinear.GetMatrixTransformToParent()
#imprime en la consola los volumenes que tienen desplazamientos mayores 1 mm
print('Registro completo')
#al terminar el ciclo for con todos los volumenes registrados se genera una
#ventana emergente con un mensaje("Registro completo!") y mostrando los
#volumenes que se desplazaron mas de 4mm
qt.QMessageBox.information(slicer.util.mainWindow(),
'Slicer Python', 'Registro completo')
return True
def main():
fileName = get_program_parameters()
colors = vtk.vtkNamedColors()
# Read the CT data of the human head.
reader = vtk.vtkMetaImageReader()
reader.SetFileName(fileName)
reader.Update()
cast = vtk.vtkImageCast()
cast.SetInputConnection(reader.GetOutputPort())
cast.SetOutputScalarTypeToFloat()
# Magnify the image.
magnify = vtk.vtkImageMagnify()
magnify.SetInputConnection(cast.GetOutputPort())
magnify.SetMagnificationFactors(2, 2, 1)
magnify.InterpolateOn()
# Smooth the data.
# Remove high frequency artifacts due to linear interpolation.
smooth = vtk.vtkImageGaussianSmooth()
smooth.SetInputConnection(magnify.GetOutputPort())
smooth.SetDimensionality(2)
smooth.SetStandardDeviations(1.5, 1.5, 0.0)
smooth.SetRadiusFactors(2.01, 2.01, 0.0)
# Compute the 2D gradient.
gradient = vtk.vtkImageGradient()
gradient.SetInputConnection(smooth.GetOutputPort())
gradient.SetDimensionality(2)
# Convert the data to polar coordinates.
# The image magnitude is mapped into saturation value,
# whilst the gradient direction is mapped into hue value.
polar = vtk.vtkImageEuclideanToPolar()
polar.SetInputConnection(gradient.GetOutputPort())
polar.SetThetaMaximum(255.0)
# Add a third component to the data.
# This is needed since the gradient filter only generates two components,
# and we need three components to represent color.
pad = vtk.vtkImageConstantPad()
pad.SetInputConnection(polar.GetOutputPort())
pad.SetOutputNumberOfScalarComponents(3)
pad.SetConstant(200.0)
# At this point we have Hue, Value, Saturation.
# Permute components so saturation will be constant.
# Re-arrange components into HSV order.
permute = vtk.vtkImageExtractComponents()
permute.SetInputConnection(pad.GetOutputPort())
permute.SetComponents(0, 2, 1)
# Convert back into RGB values.
rgb = vtk.vtkImageHSVToRGB()
rgb.SetInputConnection(permute.GetOutputPort())
rgb.SetMaximum(255.0)
# Set up a viewer for the image.
# Note that vtkImageViewer and vtkImageViewer2 are convenience wrappers around
# vtkActor2D, vtkImageMapper, vtkRenderer, and vtkRenderWindow.
# So all that needs to be supplied is the interactor.
viewer = vtk.vtkImageViewer()
viewer.SetInputConnection(rgb.GetOutputPort())
viewer.SetZSlice(22)
viewer.SetColorWindow(255.0)
viewer.SetColorLevel(127.0)
viewer.GetRenderWindow().SetSize(512, 512)
viewer.GetRenderer().SetBackground(colors.GetColor3d("Silver"))
# Create the RenderWindowInteractor.
iren = vtk.vtkRenderWindowInteractor()
viewer.SetupInteractor(iren)
viewer.Render()
iren.Initialize()
iren.Start()
# Create the RenderWindow, Renderer and both Actors # ren1 = vtk.vtkRenderer() ren1.SetBackground(1, 1, 1) renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Read the data. Note this creates a 3-component scalar. red = vtk.vtkPNGReader() red.SetFileName(VTK_DATA_ROOT + "/Data/RedCircle.png") red.Update() # Next filter can only handle RGB *(&&*@ extract = vtk.vtkImageExtractComponents() extract.SetInputConnection(red.GetOutputPort()) extract.SetComponents(0, 1, 2) # Quantize the image into an index quantize = vtk.vtkImageQuantizeRGBToIndex() quantize.SetInputConnection(extract.GetOutputPort()) quantize.SetNumberOfColors(3) # Create the pipeline discrete = vtk.vtkDiscreteFlyingEdges2D() discrete.SetInputConnection(quantize.GetOutputPort()) discrete.SetValue(0, 0) # Create polgons polyLoops = vtk.vtkContourLoopExtraction()
