def bgMultiVolumeNode(self, bgMultiVolumeNode):
logging.debug(
'MultiVolumeIntensityChartView: bgMultiVolumeNode changed')
self.__bgMultiVolumeNode = bgMultiVolumeNode
if not self.__bgMultiVolumeNode:
self.__chartView.minimumSize = QSize(0, 0)
return
else:
self.__chartView.minimumSize = QSize(200, 200)
nFrames = self.__bgMultiVolumeNode.GetNumberOfFrames()
self.refreshArray(self.__bgxArray, nFrames, '')
self.refreshArray(self.__bgyArray, nFrames, '1st multivolume')
self.__chartTable = self.createNewVTKTable(self.__bgxArray,
self.__bgyArray)
self.__chartTable.SetNumberOfRows(nFrames)
# get the range of intensities for the
mvi = self.__bgMultiVolumeNode.GetImageData()
self.__mvRange = [0, 0]
for f in range(nFrames):
extract = vtk.vtkImageExtractComponents()
self.setExtractInput(extract, mvi)
extract.SetComponents(f)
extract.Update()
frame = extract.GetOutput()
frameRange = frame.GetScalarRange()
self.__mvRange[0] = min(self.__mvRange[0], frameRange[0])
self.__mvRange[1] = max(self.__mvRange[1], frameRange[1])
self.__mvLabels = self.getMultiVolumeLabels(self.__bgMultiVolumeNode)
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)
extract.SetInput(inputVolume.GetImageData())
luminance = vtk.vtkImageLuminance()
luminance.SetInput(extract.GetOutput())
luminance.GetOutput().Update()
ijkToRAS = vtk.vtkMatrix4x4()
inputVolume.GetIJKToRASMatrix(ijkToRAS)
outputVolume.SetIJKToRASMatrix(ijkToRAS)
outputVolume.SetAndObserveImageData(luminance.GetOutput())
# 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 bgMultiVolumeNode(self, bgMultiVolumeNode):
logging.debug('MultiVolumeIntensityChartView: bgMultiVolumeNode changed')
self.__bgMultiVolumeNode = bgMultiVolumeNode
if not self.__bgMultiVolumeNode:
self.__chartView.minimumSize = QSize(0,0)
return
else:
self.__chartView.minimumSize = QSize(200,200)
nFrames = self.__bgMultiVolumeNode.GetNumberOfFrames()
self.refreshArray(self.__bgxArray, nFrames, '')
self.refreshArray(self.__bgyArray, nFrames, '1st multivolume')
self.__chartTable = self.createNewVTKTable(self.__bgxArray, self.__bgyArray)
self.__chartTable.SetNumberOfRows(nFrames)
# get the range of intensities for the
mvi = self.__bgMultiVolumeNode.GetImageData()
self.__mvRange = [0,0]
for f in range(nFrames):
extract = vtk.vtkImageExtractComponents()
self.setExtractInput(extract, mvi)
extract.SetComponents(f)
extract.Update()
frame = extract.GetOutput()
frameRange = frame.GetScalarRange()
self.__mvRange[0] = min(self.__mvRange[0], frameRange[0])
self.__mvRange[1] = max(self.__mvRange[1], frameRange[1])
self.__mvLabels = self.getMultiVolumeLabels(self.__bgMultiVolumeNode)
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)
extract.SetInput(inputVolume.GetImageData())
luminance = vtk.vtkImageLuminance()
luminance.SetInput(extract.GetOutput())
luminance.GetOutput().Update()
ijkToRAS = vtk.vtkMatrix4x4()
inputVolume.GetIJKToRASMatrix(ijkToRAS)
outputVolume.SetIJKToRASMatrix(ijkToRAS)
outputVolume.SetAndObserveImageData(luminance.GetOutput())
# 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 onApply(self):
fixedImage = self.fixedSelector.currentNode()
movingImage = self.movingSelector.currentNode()
#outputImage = self.outputSelector.currentNode()
fixedExtract = vtk.vtkImageExtractComponents()
fixedExtract.SetComponents(0,1,2)
fixedLuminance = vtk.vtkImageLuminance()
fixedExtract.SetInputConnection(fixedImage.GetImageDataConnection())
fixedLuminance.SetInputConnection(fixedExtract.GetOutputPort())
fixedLuminance.Update()
fixedIJKToRAS = vtk.vtkMatrix4x4()
fixedImage.GetIJKToRASMatrix(fixedIJKToRAS)
fixedScalarVolume = slicer.vtkMRMLScalarVolumeNode()
fixedScalarVolume.SetName('fixedScalarImage')
fixedScalarVolume.SetIJKToRASMatrix(fixedIJKToRAS)
fixedScalarVolume.SetImageDataConnection(fixedLuminance.GetOutputPort())
slicer.mrmlScene.AddNode(fixedScalarVolume)
movingExtract = vtk.vtkImageExtractComponents()
movingExtract.SetComponents(0,1,2)
movingLuminance = vtk.vtkImageLuminance()
movingExtract.SetInputConnection(movingImage.GetImageDataConnection())
movingLuminance.SetInputConnection(movingExtract.GetOutputPort())
movingLuminance.Update()
movingIJKToRAS = vtk.vtkMatrix4x4()
movingImage.GetIJKToRASMatrix(movingIJKToRAS)
movingScalarVolume = slicer.vtkMRMLScalarVolumeNode()
movingScalarVolume.SetName('movingScalarImage')
movingScalarVolume.SetIJKToRASMatrix(movingIJKToRAS)
movingScalarVolume.SetImageDataConnection(movingLuminance.GetOutputPort())
slicer.mrmlScene.AddNode(movingScalarVolume)
anglesNumber = self.numberOfAnglesBox.value
print anglesNumber
imageRegistration = slicer.modules.imageregistrationcli
parameters = {
"fixedImage": fixedScalarVolume,
"movingImage": movingScalarVolume,
"anglesNumber": anglesNumber,
}
slicer.cli.run( imageRegistration,None,parameters,wait_for_completion=True )
def onHelloWorldButtonClicked(self):
print "Hello World !"
#frame volume sera el scalar volume de referencia#
self.__mvNode = self.mvSelector.currentNode()
#NODO REFERENCIA
frameVolume = slicer.vtkMRMLScalarVolumeNode()
frameVolume.SetScene(slicer.mrmlScene)
slicer.mrmlScene.AddNode(frameVolume)
nComponents = self.__mvNode.GetNumberOfFrames()
f=int(self.__veInitial.value)
frameId = min(f,nComponents-1)
ras2ijk = vtk.vtkMatrix4x4()
ijk2ras = vtk.vtkMatrix4x4()
self.__mvNode.GetRASToIJKMatrix(ras2ijk)
self.__mvNode.GetIJKToRASMatrix(ijk2ras)
frameImage = frameVolume.GetImageData()
if frameImage == None:
frameVolume.SetRASToIJKMatrix(ras2ijk)
frameVolume.SetIJKToRASMatrix(ijk2ras)
mvImage = self.__mvNode.GetImageData()
for i in range(nComponents-1):
extract = vtk.vtkImageExtractComponents()
extract.SetInput(mvImage)
extract.SetComponents(i)
extract.Update()
if i == 0:
frameVolume.SetAndObserveImageData(extract.GetOutput())
elif i < frameId+1 :
s=vtk.vtkImageMathematics()
s.SetOperationToAdd()
s.SetInput1(frameVolume.GetImageData())
s.SetInput2(extract.GetOutput())
s.Update()
frameVolume.SetAndObserveImageData(s.GetOutput())
frameName = 'Holaaa'
frameVolume.SetName(frameName)
selectionNode = slicer.app.applicationLogic().GetSelectionNode()
selectionNode.SetReferenceActiveVolumeID(frameVolume.GetID())
slicer.app.applicationLogic().PropagateVolumeSelection(0)
def onSliderChanged(self, newValue):
value = self.__mdSlider.value
if self.__mvNode != None:
mvDisplayNode = self.__mvNode.GetDisplayNode()
mvDisplayNode.SetFrameComponent(newValue)
else:
return
if self.extractFrame == True:
frameVolume = self.__vfSelector.currentNode()
if frameVolume == None:
mvNodeFrameCopy = slicer.vtkMRMLScalarVolumeNode()
mvNodeFrameCopy.SetName(self.__mvNode.GetName() + ' frame')
mvNodeFrameCopy.SetScene(slicer.mrmlScene)
slicer.mrmlScene.AddNode(mvNodeFrameCopy)
self.__vfSelector.setCurrentNode(mvNodeFrameCopy)
frameVolume = self.__vfSelector.currentNode()
mvImage = self.__mvNode.GetImageData()
frameId = newValue
extract = vtk.vtkImageExtractComponents()
extract.SetInput(mvImage)
extract.SetComponents(frameId)
extract.Update()
ras2ijk = vtk.vtkMatrix4x4()
ijk2ras = vtk.vtkMatrix4x4()
self.__mvNode.GetRASToIJKMatrix(ras2ijk)
self.__mvNode.GetIJKToRASMatrix(ijk2ras)
frameImage = frameVolume.GetImageData()
if frameImage == None:
frameVolume.SetRASToIJKMatrix(ras2ijk)
frameVolume.SetIJKToRASMatrix(ijk2ras)
frameVolume.SetAndObserveImageData(extract.GetOutput())
displayNode = frameVolume.GetDisplayNode()
if displayNode == None:
displayNode = slicer.mrmlScene.CreateNodeByClass(
'vtkMRMLScalarVolumeDisplayNode')
displayNode.SetReferenceCount(1)
displayNode.SetScene(slicer.mrmlScene)
slicer.mrmlScene.AddNode(displayNode)
displayNode.SetDefaultColorMap()
frameVolume.SetAndObserveDisplayNodeID(displayNode.GetID())
frameName = '%s frame %d' % (self.__mvNode.GetName(), frameId)
frameVolume.SetName(frameName)
def onSliderChanged(self, newValue):
value = self.__mdSlider.value
if self.__mvNode != None:
mvDisplayNode = self.__mvNode.GetDisplayNode()
mvDisplayNode.SetFrameComponent(newValue)
else:
return
if self.extractFrame == True:
frameVolume = self.__vfSelector.currentNode()
if frameVolume == None:
mvNodeFrameCopy = slicer.vtkMRMLScalarVolumeNode()
mvNodeFrameCopy.SetName(self.__mvNode.GetName()+' frame')
mvNodeFrameCopy.SetScene(slicer.mrmlScene)
slicer.mrmlScene.AddNode(mvNodeFrameCopy)
self.__vfSelector.setCurrentNode(mvNodeFrameCopy)
frameVolume = self.__vfSelector.currentNode()
mvImage = self.__mvNode.GetImageData()
frameId = newValue
extract = vtk.vtkImageExtractComponents()
extract.SetInput(mvImage)
extract.SetComponents(frameId)
extract.Update()
ras2ijk = vtk.vtkMatrix4x4()
ijk2ras = vtk.vtkMatrix4x4()
self.__mvNode.GetRASToIJKMatrix(ras2ijk)
self.__mvNode.GetIJKToRASMatrix(ijk2ras)
frameImage = frameVolume.GetImageData()
if frameImage == None:
frameVolume.SetRASToIJKMatrix(ras2ijk)
frameVolume.SetIJKToRASMatrix(ijk2ras)
frameVolume.SetAndObserveImageData(extract.GetOutput())
displayNode = frameVolume.GetDisplayNode()
if displayNode == None:
displayNode = slicer.mrmlScene.CreateNodeByClass('vtkMRMLScalarVolumeDisplayNode')
displayNode.SetReferenceCount(1)
displayNode.SetScene(slicer.mrmlScene)
slicer.mrmlScene.AddNode(displayNode)
displayNode.SetDefaultColorMap()
frameVolume.SetAndObserveDisplayNodeID(displayNode.GetID())
frameName = '%s frame %d' % (self.__mvNode.GetName(), frameId)
frameVolume.SetName(frameName)
def onSliderChanged(self, newValue):
value = self.__mdSlider.value
if self.__dwvNode != None:
dwvDisplayNode = self.__dwvNode.GetDisplayNode()
dwvDisplayNode.SetDiffusionComponent(newValue)
if self.extractFrame == True:
frameVolume = self.__vfSelector.currentNode()
if frameVolume == None or self.__dwvNode == None:
return
dwvImage = self.__dwvNode.GetImageData()
frameId = newValue
extract = vtk.vtkImageExtractComponents()
cast = vtk.vtkImageCast()
extract.SetInput(dwvImage)
extract.SetComponents(frameId)
cast.SetInput(extract.GetOutput())
cast.SetOutputScalarTypeToShort()
cast.Update()
frame = cast.GetOutput()
ras2ijk = vtk.vtkMatrix4x4()
ijk2ras = vtk.vtkMatrix4x4()
self.__dwvNode.GetRASToIJKMatrix(ras2ijk)
self.__dwvNode.GetIJKToRASMatrix(ijk2ras)
frameImage = frameVolume.GetImageData()
if frameImage == None:
frameVolume.SetAndObserveImageData(frame)
frameVolume.SetRASToIJKMatrix(ras2ijk)
frameVolume.SetIJKToRASMatrix(ijk2ras)
frameImage = frame
frameImage.DeepCopy(frame)
displayNode = frameVolume.GetDisplayNode()
if displayNode == None:
displayNode = slicer.mrmlScene.CreateNodeByClass('vtkMRMLScalarVolumeDisplayNode')
displayNode.SetReferenceCount(1)
displayNode.SetScene(slicer.mrmlScene)
slicer.mrmlScene.AddNode(displayNode)
displayNode.SetDefaultColorMap()
frameVolume.SetAndObserveDisplayNodeID(displayNode.GetID())
frameName = '%s frame %d' % (self.__dwvNode.GetName(), frameId)
frameVolume.SetName(frameName)
def onHelloWorldButtonClicked(self):
print "Hello World !"
#frame volume sera el scalar volume de referencia#
self.__mvNode = self.mvSelector.currentNode()
#NODO REFERENCIA
frameVolume = slicer.vtkMRMLScalarVolumeNode()
frameVolume.SetScene(slicer.mrmlScene)
slicer.mrmlScene.AddNode(frameVolume)
nComponents = self.__mvNode.GetNumberOfFrames()
f = int(self.__veInitial.value)
frameId = min(f, nComponents - 1)
ras2ijk = vtk.vtkMatrix4x4()
ijk2ras = vtk.vtkMatrix4x4()
self.__mvNode.GetRASToIJKMatrix(ras2ijk)
self.__mvNode.GetIJKToRASMatrix(ijk2ras)
frameImage = frameVolume.GetImageData()
if frameImage == None:
frameVolume.SetRASToIJKMatrix(ras2ijk)
frameVolume.SetIJKToRASMatrix(ijk2ras)
mvImage = self.__mvNode.GetImageData()
for i in range(nComponents - 1):
extract = vtk.vtkImageExtractComponents()
extract.SetInput(mvImage)
extract.SetComponents(i)
extract.Update()
if i == 0:
frameVolume.SetAndObserveImageData(extract.GetOutput())
elif i < frameId + 1:
s = vtk.vtkImageMathematics()
s.SetOperationToAdd()
s.SetInput1(frameVolume.GetImageData())
s.SetInput2(extract.GetOutput())
s.Update()
frameVolume.SetAndObserveImageData(s.GetOutput())
frameName = 'Holaaa'
frameVolume.SetName(frameName)
selectionNode = slicer.app.applicationLogic().GetSelectionNode()
selectionNode.SetReferenceActiveVolumeID(frameVolume.GetID())
slicer.app.applicationLogic().PropagateVolumeSelection(0)
def setInputMultiVolumeNode(self, multiVolumeNode):
self.multiVolumeNode = multiVolumeNode
self.nodePre = slicer.vtkMRMLScalarVolumeNode()
extract = vtk.vtkImageExtractComponents()
if vtk.VTK_MAJOR_VERSION <= 5:
extract.SetInput(self.multiVolumeNode.GetImageData())
else:
extract.SetInputData(self.multiVolumeNode.GetImageData)
extract.SetComponents(0)
extract.Update()
ras2ijk = vtk.vtkMatrix4x4()
ijk2ras = vtk.vtkMatrix4x4()
self.multiVolumeNode.GetRASToIJKMatrix(ras2ijk)
self.multiVolumeNode.GetIJKToRASMatrix(ijk2ras)
self.nodePre.SetRASToIJKMatrix(ras2ijk)
self.nodePre.SetIJKToRASMatrix(ijk2ras)
self.nodePre.SetAndObserveImageData(extract.GetOutput())
self.nodeArrayMultiVolume = self.createMultiVolumeNumpyArray(self.multiVolumeNode)
self.nodeArrayPre = self.nodeArrayMultiVolume[:,:,:,0]
self.nodeArrayFirst = self.nodeArrayMultiVolume[:,:,:,1]
self.nodeArrayFinal = self.nodeArrayMultiVolume[:,:,:,-1]
def setInputMultiVolumeNode(self, multiVolumeNode):
self.multiVolumeNode = multiVolumeNode
self.nodePre = slicer.vtkMRMLScalarVolumeNode()
extract = vtk.vtkImageExtractComponents()
if vtk.VTK_MAJOR_VERSION <= 5:
extract.SetInput(self.multiVolumeNode.GetImageData())
else:
extract.SetInputData(self.multiVolumeNode.GetImageData)
extract.SetComponents(0)
extract.Update()
ras2ijk = vtk.vtkMatrix4x4()
ijk2ras = vtk.vtkMatrix4x4()
self.multiVolumeNode.GetRASToIJKMatrix(ras2ijk)
self.multiVolumeNode.GetIJKToRASMatrix(ijk2ras)
self.nodePre.SetRASToIJKMatrix(ras2ijk)
self.nodePre.SetIJKToRASMatrix(ijk2ras)
self.nodePre.SetAndObserveImageData(extract.GetOutput())
self.nodeArrayMultiVolume = self.createMultiVolumeNumpyArray(
self.multiVolumeNode)
self.nodeArrayPre = self.nodeArrayMultiVolume[:, :, :, 0]
self.nodeArrayFirst = self.nodeArrayMultiVolume[:, :, :, 1]
self.nodeArrayFinal = self.nodeArrayMultiVolume[:, :, :, -1]
def onApplyButton(self):
# logic = multi2SingleVolumeLogic()
# print("Run the algorithm")
# logic.run(self.inputSelector.currentNode(), self.outputSelector.currentNode(), enableScreenshotsFlag,screenshotScaleFactor)
inputVolume = self.inputSelector.currentNode()
outputVolume = self.outputSelector.currentNode()
mvNode = slicer.util.getNode(inputVolume.GetID())
mvData = mvNode.GetImageData()
#get the studyID from the multivolume.
instUids=mvNode.GetAttribute('DICOM.instanceUIDs').split()
filename=slicer.dicomDatabase.fileForInstance(instUids[0])
studyID = str(slicer.dicomDatabase.fileValue(filename,'0020,0010'))
extract = vtk.vtkImageExtractComponents()
extract.SetInputData(mvData)
extract.SetComponents(0)
extract.Update()
scalarVolumeNode = slicer.vtkMRMLScalarVolumeNode()
scalarVolumeNode.SetScene(slicer.mrmlScene)
slicer.mrmlScene.AddNode(scalarVolumeNode)
ras2ijk = vtk.vtkMatrix4x4()
ijk2ras = vtk.vtkMatrix4x4()
mvNode.GetRASToIJKMatrix(ras2ijk)
mvNode.GetIJKToRASMatrix(ijk2ras)
scalarVolumeNode.SetRASToIJKMatrix(ras2ijk)
scalarVolumeNode.SetIJKToRASMatrix(ijk2ras)
scalarVolumeNode.SetAndObserveImageData(extract.GetOutput())
displayNode = scalarVolumeNode.GetDisplayNode()
scalarVolumeNode.SetName(studyID + '_singleVolume')
def filtro(self):
escenafiltro = slicer.mrmlScene
#Se recupera la escena cargada
volumen4Dfiltro = self.inputSelector3.currentNode()
imagenvtk4Dfiltro = volumen4Dfiltro.GetImageData()
numero_imagenes = volumen4Dfiltro.GetNumberOfFrames()
for i in range(0, numero_imagenes, 1):
#extraer la imagen movil
extract2 = vtk.vtkImageExtractComponents()
extract2.SetInputData(imagenvtk4Dfiltro)
extract2.SetComponents(i)
extract2.Update()
filtroGaussiano = vtk.vtkImageGaussianSmooth()
filtroGaussiano.SetStandardDeviation(1, 1, 1)
filtroGaussiano.SetInputData(extract2.GetOutput())
filtroGaussiano.Update()
ras2ijk = vtk.vtkMatrix4x4()
ijk2ras = vtk.vtkMatrix4x4()
volumen4Dfiltro.GetRASToIJKMatrix(ras2ijk)
volumen4Dfiltro.GetIJKToRASMatrix(ijk2ras)
volSalida = slicer.vtkMRMLScalarVolumeNode()
volSalida.SetAndObserveImageData(filtroGaussiano.GetOutput())
volSalida.SetRASToIJKMatrix(ras2ijk)
volSalida.SetIJKToRASMatrix(ijk2ras)
slicer.mrmlScene.AddNode(volSalida)
slicer.util.saveNode(
volSalida, 'filtrado' + str(i + 1) + '.nrrd'
) #se guarda el volumen registrado en la carpeta de documentos
print("ya filtre" + str(i))
def grafTiempo(self):
# 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)
vectorintensidad = []
# 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(27)
#Volumen
escena = slicer.mrmlScene
#Se recupera la escena cargada
volumen4D = self.inputSelector5.currentNode()
imagenvtk4D = volumen4D.GetImageData()
numero_imagenes = volumen4D.GetNumberOfFrames()
for i in range(0, numero_imagenes, 1):
extract2 = vtk.vtkImageExtractComponents()
extract2.SetInputData(imagenvtk4D)
imagen_movil = extract2.SetComponents(i)
extract2.Update()
#Matriz de transformacion
ras2ijk = vtk.vtkMatrix4x4()
ijk2ras = vtk.vtkMatrix4x4()
#Se solicita al volumen original que devuelva las matrices
volumen4D.GetRASToIJKMatrix(ras2ijk)
volumen4D.GetIJKToRASMatrix(ijk2ras)
#Se crea un volumen movil, y se realiza el mismo procedimiento que con el fijo
volumenMovil = slicer.vtkMRMLScalarVolumeNode()
volumenMovil.SetRASToIJKMatrix(ras2ijk)
volumenMovil.SetIJKToRASMatrix(ijk2ras)
volumenMovil.SetAndObserveImageData(extract2.GetOutput())
escena.AddNode(volumenMovil)
z = slicer.util.arrayFromVolume(volumenMovil)
m = np.mean(z[:])
vectorintensidad.append((m / 15000) - 1)
for i in range(0, numero_imagenes):
a.SetComponent(i, 0, i * 11.11)
a.SetComponent(i, 1, vectorintensidad[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.
# 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', 'intesidad vs tiempo')
cn.SetProperty('default', 'xAxisLabel', 'Tiempo(s)')
cn.SetProperty('default', 'yAxisLabel', 'Intensidad')
# Tell the Chart View which Chart to display
cvn.SetChartNodeID(cn.GetID())
def onInputChanged(self):
self.__mvNode = self.__mvSelector.currentNode()
if self.__mvNode != None:
Helper.SetBgFgVolumes(self.__mvNode.GetID(), None)
nFrames = self.__mvNode.GetNumberOfFrames()
self.__mdSlider.minimum = 0
self.__mdSlider.maximum = nFrames - 1
self.__chartTable.SetNumberOfRows(nFrames)
# if self.__cvn != None:
# self.__cvn.SetChartNodeID(self.__cn.GetID())
self.ctrlFrame.enabled = True
self.plotFrame.enabled = True
self.ctrlFrame.collapsed = 0
self.plotFrame.collapsed = 0
self.__vfSelector.setCurrentNode(None)
self.__xArray.SetNumberOfTuples(nFrames)
self.__xArray.SetNumberOfComponents(1)
self.__xArray.Allocate(nFrames)
self.__xArray.SetName('frame')
self.__yArray.SetNumberOfTuples(nFrames)
self.__yArray.SetNumberOfComponents(1)
self.__yArray.Allocate(nFrames)
self.__yArray.SetName('signal intensity')
self.__chartTable = vtk.vtkTable()
self.__chartTable.AddColumn(self.__xArray)
self.__chartTable.AddColumn(self.__yArray)
self.__chartTable.SetNumberOfRows(nFrames)
# get the range of intensities for the
mvi = self.__mvNode.GetImageData()
self.__mvRange = [0, 0]
for f in range(nFrames):
extract = vtk.vtkImageExtractComponents()
extract.SetInput(mvi)
extract.SetComponents(f)
extract.Update()
frame = extract.GetOutput()
frameRange = frame.GetScalarRange()
self.__mvRange[0] = min(self.__mvRange[0], frameRange[0])
self.__mvRange[1] = max(self.__mvRange[1], frameRange[1])
self.__mvLabels = string.split(
self.__mvNode.GetAttribute('MultiVolume.FrameLabels'), ',')
if len(self.__mvLabels) != nFrames:
return
for l in range(nFrames):
self.__mvLabels[l] = float(self.__mvLabels[l])
self.baselineFrames.maximum = nFrames
else:
self.ctrlFrame.enabled = False
self.plotFrame.enabled = False
self.ctrlFrame.collapsed = 1
self.plotFrame.collapsed = 1
self.__mvLabels = []
def DoIt(inputDir, rgbDir, outputDir):
#
# Read the input DICOM series as a volume
#
dcmList = []
for dcm in os.listdir(inputDir):
if len(dcm)-dcm.rfind('.dcm') == 4:
dcmList.append(inputDir+'/'+dcm)
scalarVolumePlugin = slicer.modules.dicomPlugins['DICOMScalarVolumePlugin']()
print 'Will examine: ',dcmList
indexer = ctk.ctkDICOMIndexer()
indexer.addDirectory(slicer.dicomDatabase, inputDir)
indexer.waitForImportFinished()
loadables = scalarVolumePlugin.examine([dcmList])
if len(loadables) == 0:
print 'Could not parse the DICOM Study!'
exit()
inputVolume = scalarVolumePlugin.load(loadables[0])
sNode = slicer.vtkMRMLVolumeArchetypeStorageNode()
'''
sNode.ResetFileNameList()
for f in loadables[0].files:
sNode.AddFileName(f)
sNode.SetFileName(loadables[0].files[0])
sNode.SetSingleFile(0)
inputVolume = slicer.vtkMRMLScalarVolumeNode()
sNode.ReadData(inputVolume)
'''
sNode.SetWriteFileFormat('nrrd')
sNode.SetFileName(os.path.join(outputDir,'input_volume.nrrd'))
sNode.WriteData(inputVolume)
#
# Order the input RGBs and rename in a temp directory
#
rgbList = []
for rgb in os.listdir(rgbDir):
if len(rgb)-rgb.rfind('.bmp') == 4:
rgbList.append(rgb)
tmpDir = slicer.app.settings().value('Modules/TemporaryDirectory')
tmpDir = tmpDir+'/PNGStackLabelConverter'
if not os.path.exists(tmpDir):
os.mkdir(tmpDir)
oldFiles = os.listdir(tmpDir)
# just in case there is anything in that directory
for f in oldFiles:
os.unlink(tmpDir+'/'+f)
rgbOrdered = [None] * len(loadables[0].files)
rgbCnt = 0
rgbExt = rgbList[0][rgbList[0].rfind('.')+1:len(rgbList[0])]
print 'Extension for RGBs: ',rgbExt
dcmFileList = loadables[0].files
rgbRenamedList = []
print 'Number of dcm files: ',len(dcmFileList), ' and rgb files: ',len(rgbOrdered)
dcmIdx = 0
for dcm in dcmFileList:
rgbIdx = 0
for rgb in rgbList:
dcmPrefix = dcm[dcm.rfind('/')+1:dcm.rfind('.')]
if rgb.find(dcmPrefix) != -1:
name = string.zfill(str(dcmIdx),5)
rgbCnt = rgbCnt+1
src = rgbDir+'/'+rgb
dest = tmpDir+'/'+name+'.'+rgbExt
rgbRenamedList.append(dest)
shutil.copy(src,dest)
break
rgbIdx = rgbIdx+1
# remove the matched DICOM file from the list
if rgbIdx == len(rgbList):
print('ERROR: failed to find matching label file for DICOM file '+dcm)
return
del rgbList[rgbIdx]
dcmIdx = dcmIdx+1
if len(rgbRenamedList) == 0:
print 'Could not parse the DICOM Study!'
return
sNode = slicer.vtkMRMLVolumeArchetypeStorageNode()
sNode.ResetFileNameList()
for f in rgbRenamedList:
sNode.AddFileName(f)
sNode.SetFileName(rgbRenamedList[0])
sNode.SetSingleFile(0)
inputRGBVolume = slicer.vtkMRMLVectorVolumeNode()
sNode.ReadData(inputRGBVolume)
# run the filter
# - extract the RGB portions
extract = vtk.vtkImageExtractComponents()
extract.SetComponents(0,1,2)
if vtk.vtkVersion().GetVTKMajorVersion() < 6:
extract.SetInput(inputRGBVolume.GetImageData())
else:
extract.SetInputData(inputRGBVolume.GetImageData())
luminance = vtk.vtkImageLuminance()
if vtk.vtkVersion().GetVTKMajorVersion() < 6:
luminance.SetInput(extract.GetOutput())
else:
luminance.SetInputData(extract.GetOutput())
cast = vtk.vtkImageCast()
if vtk.vtkVersion().GetVTKMajorVersion() < 6:
cast.SetInput(luminance.GetOutput())
else:
cast.SetInputData(luminance.GetOutput())
cast.SetOutputScalarTypeToShort()
cast.GetOutput().Update()
ijkToRAS = vtk.vtkMatrix4x4()
inputVolume.GetIJKToRASMatrix(ijkToRAS)
outputLabel = slicer.vtkMRMLLabelMapVolumeNode()
outputLabel.SetIJKToRASMatrix(ijkToRAS)
outputLabel.SetAndObserveImageData(cast.GetOutput())
reportingLogic = slicer.modules.reporting.logic()
displayNode = slicer.vtkMRMLLabelMapVolumeDisplayNode()
displayNode.SetAndObserveColorNodeID(reportingLogic.GetDefaultColorNode().GetID())
slicer.mrmlScene.AddNode(displayNode)
outputLabel.SetAndObserveDisplayNodeID(displayNode.GetID())
sNode.SetWriteFileFormat('nrrd')
sNode.SetFileName(os.path.join(outputDir,'label_output.nrrd'))
sNode.WriteData(outputLabel)
# save as DICOM SEG
labelCollection = vtk.vtkCollection()
labelCollection.AddItem(outputLabel)
slicer.mrmlScene.AddNode(inputVolume)
outputLabel.SetAttribute('AssociatedNodeID',inputVolume.GetID())
slicer.mrmlScene.AddNode(outputLabel)
# initialize the DICOM DB for Reporting logic
settings = qt.QSettings()
dbFileName = settings.value('DatabaseDirectory','')
if dbFileName =='':
print('ERROR: database must be initialized')
else:
dbFileName = dbFileName +'/ctkDICOM.sql'
reportingLogic.InitializeDICOMDatabase(dbFileName)
reportingLogic.DicomSegWrite(labelCollection, outputDir)
def DoIt(inputDir, rgbDir, outputDir):
#
# Read the input DICOM series as a volume
#
dcmList = []
for dcm in os.listdir(inputDir):
if len(dcm) - dcm.rfind('.dcm') == 4:
dcmList.append(inputDir + '/' + dcm)
scalarVolumePlugin = slicer.modules.dicomPlugins[
'DICOMScalarVolumePlugin']()
print 'Will examine: ', dcmList
indexer = ctk.ctkDICOMIndexer()
indexer.addDirectory(slicer.dicomDatabase, inputDir)
indexer.waitForImportFinished()
loadables = scalarVolumePlugin.examine([dcmList])
if len(loadables) == 0:
print 'Could not parse the DICOM Study!'
exit()
inputVolume = scalarVolumePlugin.load(loadables[0])
sNode = slicer.vtkMRMLVolumeArchetypeStorageNode()
'''
sNode.ResetFileNameList()
for f in loadables[0].files:
sNode.AddFileName(f)
sNode.SetFileName(loadables[0].files[0])
sNode.SetSingleFile(0)
inputVolume = slicer.vtkMRMLScalarVolumeNode()
sNode.ReadData(inputVolume)
'''
sNode.SetWriteFileFormat('nrrd')
sNode.SetFileName(os.path.join(outputDir, 'input_volume.nrrd'))
sNode.WriteData(inputVolume)
#
# Order the input RGBs and rename in a temp directory
#
rgbList = []
for rgb in os.listdir(rgbDir):
if len(rgb) - rgb.rfind('.bmp') == 4:
rgbList.append(rgb)
tmpDir = slicer.app.settings().value('Modules/TemporaryDirectory')
tmpDir = tmpDir + '/PNGStackLabelConverter'
if not os.path.exists(tmpDir):
os.mkdir(tmpDir)
oldFiles = os.listdir(tmpDir)
# just in case there is anything in that directory
for f in oldFiles:
os.unlink(tmpDir + '/' + f)
rgbOrdered = [None] * len(loadables[0].files)
rgbCnt = 0
rgbExt = rgbList[0][rgbList[0].rfind('.') + 1:len(rgbList[0])]
print 'Extension for RGBs: ', rgbExt
dcmFileList = loadables[0].files
rgbRenamedList = []
print 'Number of dcm files: ', len(dcmFileList), ' and rgb files: ', len(
rgbOrdered)
dcmIdx = 0
for dcm in dcmFileList:
rgbIdx = 0
for rgb in rgbList:
dcmPrefix = dcm[dcm.rfind('/') + 1:dcm.rfind('.')]
if rgb.find(dcmPrefix) != -1:
name = string.zfill(str(dcmIdx), 5)
rgbCnt = rgbCnt + 1
src = rgbDir + '/' + rgb
dest = tmpDir + '/' + name + '.' + rgbExt
rgbRenamedList.append(dest)
shutil.copy(src, dest)
break
rgbIdx = rgbIdx + 1
# remove the matched DICOM file from the list
if rgbIdx == len(rgbList):
print('ERROR: failed to find matching label file for DICOM file ' +
dcm)
return
del rgbList[rgbIdx]
dcmIdx = dcmIdx + 1
if len(rgbRenamedList) == 0:
print 'Could not parse the DICOM Study!'
return
sNode = slicer.vtkMRMLVolumeArchetypeStorageNode()
sNode.ResetFileNameList()
for f in rgbRenamedList:
sNode.AddFileName(f)
sNode.SetFileName(rgbRenamedList[0])
sNode.SetSingleFile(0)
inputRGBVolume = slicer.vtkMRMLVectorVolumeNode()
sNode.ReadData(inputRGBVolume)
# run the filter
# - extract the RGB portions
extract = vtk.vtkImageExtractComponents()
extract.SetComponents(0, 1, 2)
if vtk.vtkVersion().GetVTKMajorVersion() < 6:
extract.SetInput(inputRGBVolume.GetImageData())
else:
extract.SetInputData(inputRGBVolume.GetImageData())
luminance = vtk.vtkImageLuminance()
if vtk.vtkVersion().GetVTKMajorVersion() < 6:
luminance.SetInput(extract.GetOutput())
else:
luminance.SetInputData(extract.GetOutput())
cast = vtk.vtkImageCast()
if vtk.vtkVersion().GetVTKMajorVersion() < 6:
cast.SetInput(luminance.GetOutput())
else:
cast.SetInputData(luminance.GetOutput())
cast.SetOutputScalarTypeToShort()
cast.GetOutput().Update()
ijkToRAS = vtk.vtkMatrix4x4()
inputVolume.GetIJKToRASMatrix(ijkToRAS)
outputLabel = slicer.vtkMRMLLabelMapVolumeNode()
outputLabel.SetIJKToRASMatrix(ijkToRAS)
outputLabel.SetAndObserveImageData(cast.GetOutput())
reportingLogic = slicer.modules.reporting.logic()
displayNode = slicer.vtkMRMLLabelMapVolumeDisplayNode()
displayNode.SetAndObserveColorNodeID(
reportingLogic.GetDefaultColorNode().GetID())
slicer.mrmlScene.AddNode(displayNode)
outputLabel.SetAndObserveDisplayNodeID(displayNode.GetID())
sNode.SetWriteFileFormat('nrrd')
sNode.SetFileName(os.path.join(outputDir, 'label_output.nrrd'))
sNode.WriteData(outputLabel)
# save as DICOM SEG
labelCollection = vtk.vtkCollection()
labelCollection.AddItem(outputLabel)
slicer.mrmlScene.AddNode(inputVolume)
outputLabel.SetAttribute('AssociatedNodeID', inputVolume.GetID())
slicer.mrmlScene.AddNode(outputLabel)
# initialize the DICOM DB for Reporting logic
settings = qt.QSettings()
dbFileName = settings.value('DatabaseDirectory', '')
if dbFileName == '':
print('ERROR: database must be initialized')
else:
dbFileName = dbFileName + '/ctkDICOM.sql'
reportingLogic.InitializeDICOMDatabase(dbFileName)
reportingLogic.DicomSegWrite(labelCollection, outputDir)
def rigido(self):
escena = slicer.mrmlScene
#Se recupera la escena cargada
volumen4D = self.inputSelector.currentNode()
imagenvtk4D = volumen4D.GetImageData()
extract1 = vtk.vtkImageExtractComponents()
extract1.SetInputData(imagenvtk4D)
imagen_fija = extract1.SetComponents(0)
extract1.Update()
#Matriz de transformacion
ras2ijk = vtk.vtkMatrix4x4()
ijk2ras = vtk.vtkMatrix4x4()
#Se solicita al volumen original que devuelva las matrices
volumen4D.GetRASToIJKMatrix(ras2ijk)
volumen4D.GetIJKToRASMatrix(ijk2ras)
#Se crea un volumen nuevo
volumenFijo = slicer.vtkMRMLScalarVolumeNode()
#Se asignan las transformaciones
volumenFijo.SetRASToIJKMatrix(ras2ijk)
volumenFijo.SetIJKToRASMatrix(ijk2ras)
#Se asigna el volumen 3D
volumenFijo.SetAndObserveImageData(extract1.GetOutput())
escena.AddNode(volumenFijo)
numero_imagenes = volumen4D.GetNumberOfFrames()
valor1 = []
# vector donde se guarda los valores de LR despues aplicar la transformada rigida
valor2 = []
# vector donde se guarda los valores de PA despues aplicar la transformada rigida
valor3 = []
# vector donde se guarda los valores de IS despues aplicar la transformada rigida
vecvolmay = []
# vector que muestra el frame, los volumenes que tienen un movimiento mayor a 4 mm
valor1.append(0)
valor2.append(0)
valor3.append(0)
#En esta parte se evaluan todos los volumenes moviles
for i in range(0, numero_imagenes, 1):
#extraer la imagen movil
extract2 = vtk.vtkImageExtractComponents()
extract2.SetInputData(imagenvtk4D)
imagen_movil = extract2.SetComponents(i)
extract2.Update()
#Se crea un volumen movil, y se realiza el mismo procedimiento que con el fijo
volumenMovil = slicer.vtkMRMLScalarVolumeNode()
volumenSalida = slicer.vtkMRMLScalarVolumeNode()
escena.AddNode(volumenSalida)
volumenMovil.SetRASToIJKMatrix(ras2ijk)
volumenMovil.SetIJKToRASMatrix(ijk2ras)
volumenMovil.SetAndObserveImageData(extract2.GetOutput())
escena.AddNode(volumenMovil)
#Se crea la transformada para alinear los volumenes
transformadaSalida = slicer.vtkMRMLLinearTransformNode()
transformadaSalida.SetName(
'Transformada de registro rigido' +
str(i)) #se le da un nombre especifico a la transformada
slicer.mrmlScene.AddNode(transformadaSalida)
parameters = {}
parameters['fixedVolume'] = volumenFijo.GetID()
parameters['movingVolume'] = volumenMovil.GetID()
parameters[
'transformType'] = 'Rigid' #Se coloca segun lo que se quiera hacer si rigido, afin o bspline
parameters['outputTransform'] = transformadaSalida.GetID()
parameters['outputVolume'] = volumenSalida.GetID()
cliNode = slicer.cli.run(slicer.modules.brainsfit,
None,
parameters,
wait_for_completion=True)
slicer.util.saveNode(
volumenSalida, 'volumenrigido' + str(i + 1) + '.nrrd'
) #se guarda el volumen registrado en la carpeta de documentos
# Este for se hace con el fin de ver los volumenes que tienen un desplazamiento mayor a 4 mm con respecto al fijo
for i in range(0, numero_imagenes):
nodo = escena.GetNodesByName('Transformada de registro rigido' +
str(i))
nodo = nodo.GetItemAsObject(0)
matriztransformada = nodo.GetMatrixTransformToParent(
) # Se obtiene la matriz de transformacion
# se obtiene para cada frame la ubicacion en las 3 direcciones
valor1inicial = matriztransformada.GetElement(
0, 3
) #se agrega el valor en la posicion 0 3 de la transformada valor que corresponde a LR
valor2inicial = matriztransformada.GetElement(
1, 3
) #se agrega el valor en la posicion 0 3 de la transformada valor que corresponde a PA
valor3inicial = matriztransformada.GetElement(
2, 3
) #se agrega el valor en la posicion 0 3 de la transformada valor que corresponde a IS
valor1.append(valor1inicial)
valor2.append(valor2inicial)
valor3.append(valor3inicial)
# Si la posicion en cualquier direccion de un volumen es mayor a 4mm respecto al del primer frame se obtiene un vector con su posicion
if ((abs(valor1[i]) > 4) or (abs(valor2[i]) > 4)
or (abs(valor3[i]) > 4)):
vecvolmay.append(i)
print("Los volumenes con los que se mueve mas de 4mm son")
print("Volumen")
print(vecvolmay)
if (len(vecvolmay) == 0): # Si no hay alguni no se muestra nada
print("Ningun volumen se movio mas de 4mm")
def onInputChanged(self):
self.__mvNode = self.__mvSelector.currentNode()
if self.__mvNode != None:
Helper.SetBgFgVolumes(self.__mvNode.GetID(), None)
nFrames = self.__mvNode.GetNumberOfFrames()
self.__mdSlider.minimum = 0
self.__mdSlider.maximum = nFrames-1
self.__chartTable.SetNumberOfRows(nFrames)
# if self.__cvn != None:
# self.__cvn.SetChartNodeID(self.__cn.GetID())
self.ctrlFrame.enabled = True
self.plotFrame.enabled = True
self.ctrlFrame.collapsed = 0
self.plotFrame.collapsed = 0
self.__vfSelector.setCurrentNode(None)
self.__xArray.SetNumberOfTuples(nFrames)
self.__xArray.SetNumberOfComponents(1)
self.__xArray.Allocate(nFrames)
self.__xArray.SetName('frame')
self.__yArray.SetNumberOfTuples(nFrames)
self.__yArray.SetNumberOfComponents(1)
self.__yArray.Allocate(nFrames)
self.__yArray.SetName('signal intensity')
self.__chartTable = vtk.vtkTable()
self.__chartTable.AddColumn(self.__xArray)
self.__chartTable.AddColumn(self.__yArray)
self.__chartTable.SetNumberOfRows(nFrames)
# get the range of intensities for the
mvi = self.__mvNode.GetImageData()
self.__mvRange = [0,0]
for f in range(nFrames):
extract = vtk.vtkImageExtractComponents()
extract.SetInput(mvi)
extract.SetComponents(f)
extract.Update()
frame = extract.GetOutput()
frameRange = frame.GetScalarRange()
self.__mvRange[0] = min(self.__mvRange[0], frameRange[0])
self.__mvRange[1] = max(self.__mvRange[1], frameRange[1])
self.__mvLabels = string.split(self.__mvNode.GetAttribute('MultiVolume.FrameLabels'),',')
if len(self.__mvLabels) != nFrames:
return
for l in range(nFrames):
self.__mvLabels[l] = float(self.__mvLabels[l])
self.baselineFrames.maximum = nFrames
else:
self.ctrlFrame.enabled = False
self.plotFrame.enabled = False
self.ctrlFrame.collapsed = 1
self.plotFrame.collapsed = 1
self.__mvLabels = []
def region(self):
escena = slicer.mrmlScene
#Se recupera la escena cargada
volumen4D = self.inputSelector4.currentNode()
imagenvtk4D = volumen4D.GetImageData()
extract1 = vtk.vtkImageExtractComponents()
extract1.SetInputData(imagenvtk4D)
imagen_fija = extract1.SetComponents(0)
extract1.Update()
#Matriz de transformacion
ras2ijk = vtk.vtkMatrix4x4()
ijk2ras = vtk.vtkMatrix4x4()
#Se solicita al volumen original que devuelva las matrices
volumen4D.GetRASToIJKMatrix(ras2ijk)
volumen4D.GetIJKToRASMatrix(ijk2ras)
#Se crea un volumen nuevo
volumenFijo = slicer.vtkMRMLScalarVolumeNode()
#Se asignan las transformaciones
volumenFijo.SetRASToIJKMatrix(ras2ijk)
volumenFijo.SetIJKToRASMatrix(ijk2ras)
#Se asigna el volumen 3D
volumenFijo.SetAndObserveImageData(extract1.GetOutput())
escena.AddNode(volumenFijo)
escena = slicer.mrmlScene
#Se recupera la escena cargada
volumen4D = self.inputSelector2.currentNode()
imagenvtk4D = volumen4D.GetImageData()
numero_imagenes = volumen4D.GetNumberOfFrames()
for i in range(0, numero_imagenes, 1):
extract2 = vtk.vtkImageExtractComponents()
extract2.SetInputData(imagenvtk4D)
imagen_movil = extract2.SetComponents(i)
extract2.Update()
#Matriz de transformacion
ras2ijk = vtk.vtkMatrix4x4()
ijk2ras = vtk.vtkMatrix4x4()
#Se solicita al volumen original que devuelva las matrices
volumen4D.GetRASToIJKMatrix(ras2ijk)
volumen4D.GetIJKToRASMatrix(ijk2ras)
#Se crea un volumen movil, y se realiza el mismo procedimiento que con el fijo
volumenMovil = slicer.vtkMRMLScalarVolumeNode()
vol = slicer.vtkMRMLScalarVolumeNode()
vol.SetName('salida')
escena.AddNode(vol)
volumenMovil.SetRASToIJKMatrix(ras2ijk)
volumenMovil.SetIJKToRASMatrix(ijk2ras)
volumenMovil.SetAndObserveImageData(extract2.GetOutput())
escena.AddNode(volumenMovil)
#parametros para la operacion de registro
parameters = {}
parameters['inputVolume1'] = volumenFijo.GetID(
) #dos volumenes de la escena, uno de ellos debe ser la mascara creada en el EDITOR
parameters['inputVolume2'] = volumenMovil.GetID()
parameters['outputVolume'] = vol
cliNode = slicer.cli.run(slicer.modules.multiplyscalarvolumes,
None,
parameters,
wait_for_completion=True)
slicer.util.saveNode(
vol, 'roi' + str(i + 1) + '.nrrd'
) #se guarda el volumen registrado en la carpeta de documentos
def ExportFunction(self):
escena = slicer.mrmlScene
outputVolume = self.outputSelector.currentNode()
outputDir = self.__fDialogOutput.directory
Nombre = outputVolume.GetName()
metadato1 = self.Diccionario.get(Nombre)
volumen4D = outputVolume.GetImageData()
numero_imagenes = outputVolume.GetNumberOfFrames()
extract1 = vtk.vtkImageExtractComponents()
extract1.SetInputData(volumen4D)
ras2ijk = vtk.vtkMatrix4x4()
ijk2ras = vtk.vtkMatrix4x4()
outputVolume.GetRASToIJKMatrix(ras2ijk)
outputVolume.GetIJKToRASMatrix(ijk2ras)
print(outputDir)
for i in range(numero_imagenes):
extract1.SetComponents(i) #Seleccionar un volumen lejano
extract1.Update()
ScalarVolume = slicer.vtkMRMLScalarVolumeNode()
ScalarVolume.SetRASToIJKMatrix(ras2ijk)
ScalarVolume.SetIJKToRASMatrix(ijk2ras)
ScalarVolume.SetAndObserveImageData(extract1.GetOutput())
ScalarVolume.SetName(str(Nombre) + str(i + 1))
escena.AddNode(ScalarVolume)
Parameters = {}
Parameters['patientID'] = metadato1.PatientID
## Parameters ['patientComments']=
Parameters['patientName'] = 'Validacion_PIS'
Parameters['studyID'] = metadato1.StudyID
Parameters['studyDate'] = metadato1.StudyDate
Parameters['studyComments'] = metadato1.StudyComments
Parameters['studyDescription'] = metadato1.StudyDescription
Parameters['modality'] = metadato1.Modality
Parameters['manufacturer'] = metadato1.Manufacturer
## Parameters ['model']=
Parameters['seriesNumber'] = metadato1.SeriesNumber
Parameters['seriesDescription'] = metadato1.SeriesDescription
## Parameters ['rescaleIntercept']=metadato.Rescaleintercept
## Parameter (3/1): rescaleSlope (Rescale slope)
Parameters['inputVolume'] = ScalarVolume
Parameters['dicomDirectory'] = outputDir
Parameters['dicomPrefix'] = 'IMG'
Parameters['dicomNumberFormat'] = '%04d' + str(i + 1)
cliNode = slicer.cli.run(slicer.modules.createdicomseries,
None,
Parameters,
wait_for_completion=True)
n = 0
## Parameters ['patientName']= 'Katy'
a = 0
a = 2
qt.QMessageBox.information(slicer.util.mainWindow(), 'Slicer Python',
'Multivolume Exportado')
def registrarButton(self):
mvNode = self.outputRegSelector.currentNode()
inputVolume = self.inputRegSelector.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
hm = vtk.vtkMatrix4x4()
transformadaSalida.GetMatrixTransformToWorld(hm)
volumenMovil.ApplyTransformMatrix(hm)
volumenMovil.SetAndObserveTransformNodeID(None)
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')
return True
