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)
示例#2
0
  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)
示例#3
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)
示例#4
0
    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)
示例#7
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)
示例#10
0
    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)
示例#11
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())
示例#16
0
    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
示例#22
0
    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')
示例#23
0
    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