def GetRawDICOMData(filenames,fileID):
  print filenames,fileID
  vtkRealDcmReader = vtk.vtkDICOMImageReader()
  vtkRealDcmReader.SetFileName("%s/%s"%(rootdir,filenames[0]) )
  vtkRealDcmReader.Update()
  vtkRealData = vtk.vtkImageCast()
  vtkRealData.SetOutputScalarTypeToFloat()
  vtkRealData.SetInput( vtkRealDcmReader.GetOutput() )
  vtkRealData.Update( )
  real_image = vtkRealData.GetOutput().GetPointData() 
  real_array = vtkNumPy.vtk_to_numpy(real_image.GetArray(0)) 

  vtkImagDcmReader = vtk.vtkDICOMImageReader()
  vtkImagDcmReader.SetFileName("%s/%s"%(rootdir,filenames[1]) )
  vtkImagDcmReader.Update()
  vtkImagData = vtk.vtkImageCast()
  vtkImagData.SetOutputScalarTypeToFloat()
  vtkImagData.SetInput( vtkImagDcmReader.GetOutput() )
  vtkImagData.Update( )
  imag_image = vtkImagData.GetOutput().GetPointData() 
  imag_array = vtkNumPy.vtk_to_numpy(imag_image.GetArray(0)) 

  vtkAppend = vtk.vtkImageAppendComponents()
  vtkAppend.SetInput( 0,vtkRealDcmReader.GetOutput() )
  vtkAppend.SetInput( 1,vtkImagDcmReader.GetOutput() )
  vtkAppend.Update( )

  vtkDcmWriter = vtk.vtkDataSetWriter()
  vtkDcmWriter.SetFileName("rawdata.%04d.vtk" % fileID )
  vtkDcmWriter.SetInput(vtkAppend.GetOutput())
  vtkDcmWriter.Update()

  return (real_array,imag_array)
Beispiel #2
0
    def test_vtk_pyexception_deadlock(self):
        """Test if VTK has been patched to release the GIL during all
        VTK method calls.
        """

        import vtk
        # this gives floats by default
        s = vtk.vtkImageGridSource()
        c1 = vtk.vtkImageCast()
        c1.SetOutputScalarTypeToShort()
        c1.SetInput(s.GetOutput())
        c2 = vtk.vtkImageCast()
        c2.SetOutputScalarTypeToFloat()
        c2.SetInput(s.GetOutput())

        m = vtk.vtkImageMathematics()

        # make sure we are multi-threaded
        if m.GetNumberOfThreads() < 2:
            m.SetNumberOfThreads(2)
        m.SetInput1(c1.GetOutput())
        m.SetInput2(c2.GetOutput())

        # without the patch, this call will deadlock forever
        try:
            # with the patch this should generate a RuntimeError
            m.Update()
        except RuntimeError:
            pass
        else:
            self.fail(
            'Multi-threaded error vtkImageMathematics did not raise '
            'exception.')
Beispiel #3
0
	def execute(self, inputs, update = 0, last = 0):
		"""
		Execute the filter with given inputs and return the output
		"""			   
		if not lib.ProcessingFilter.ProcessingFilter.execute(self, inputs):
			return None
		
		image = self.getInput(1)
		origType = image.GetScalarType()
		cast1 = vtk.vtkImageCast()
		cast1.SetInput(image)
		cast1.SetOutputScalarTypeToShort()
		# vtkImageCityBlockDistance requires short input
		self.vtkfilter.SetInput(cast1.GetOutput())
		
		data = self.vtkfilter.GetOutput()
		if self.parameters["CastToOriginal"]:
			cast = vtk.vtkImageCast()
			cast.SetInput(self.vtkfilter.GetOutput())
			cast.SetOutputScalarType(origType)
			cast.SetClampOverflow(1)
			data = cast.GetOutput()
		
		if update:
			self.vtkfilter.Update()
		
		return data  
Beispiel #4
0
    def onApply(self):
        # This can be a long operation - indicate it to the user
        qt.QApplication.setOverrideCursor(qt.Qt.WaitCursor)

        self.scriptedEffect.saveStateForUndo()

        # Get parameters
        fullyConnected = self.scriptedEffect.integerParameter("FullyConnected")
        minimumSize = self.scriptedEffect.integerParameter("MinimumSize")

        # Get modifier labelmap
        selectedSegmentLabelmap = self.scriptedEffect.selectedSegmentLabelmap()

        castIn = vtk.vtkImageCast()
        castIn.SetInputData(selectedSegmentLabelmap)
        castIn.SetOutputScalarTypeToUnsignedLong()

        # Identify the islands in the inverted volume and
        # find the pixel that corresponds to the background
        islandMath = vtkITK.vtkITKIslandMath()
        islandMath.SetInputConnection(castIn.GetOutputPort())
        islandMath.SetFullyConnected(fullyConnected)
        islandMath.SetMinimumSize(minimumSize)

        # Note that island operation happens in unsigned long space
        # but the segment editor works in unsigned char
        castOut = vtk.vtkImageCast()
        castOut.SetInputConnection(islandMath.GetOutputPort())
        castOut.SetOutputScalarTypeToUnsignedChar()
        castOut.Update()

        islandCount = islandMath.GetNumberOfIslands()
        islandOrigCount = islandMath.GetOriginalNumberOfIslands()
        ignoredIslands = islandOrigCount - islandCount
        logging.info("%d islands created (%d ignored)" %
                     (islandCount, ignoredIslands))

        # Create oriented image data from output
        import vtkSegmentationCorePython as vtkSegmentationCore
        multiLabelImage = vtkSegmentationCore.vtkOrientedImageData()
        multiLabelImage.DeepCopy(castOut.GetOutput())
        selectedSegmentLabelmapImageToWorldMatrix = vtk.vtkMatrix4x4()
        selectedSegmentLabelmap.GetImageToWorldMatrix(
            selectedSegmentLabelmapImageToWorldMatrix)
        multiLabelImage.SetGeometryFromImageToWorldMatrix(
            selectedSegmentLabelmapImageToWorldMatrix)

        # Import multi-label labelmap to segmentation
        segmentationNode = self.scriptedEffect.parameterSetNode(
        ).GetSegmentationNode()
        selectedSegmentID = self.scriptedEffect.parameterSetNode(
        ).GetSelectedSegmentID()
        selectedSegmentName = segmentationNode.GetSegmentation().GetSegment(
            selectedSegmentID).GetName()
        slicer.vtkSlicerSegmentationsModuleLogic.ImportLabelmapToSegmentationNode( \
          multiLabelImage, segmentationNode, selectedSegmentName )

        segmentationNode.GetSegmentation().RemoveSegment(selectedSegmentID)

        qt.QApplication.restoreOverrideCursor()
    def onApply(self):
        # TODO:
        # self.logic.undoRedo = self.undoRedo

        # Get parameters
        fullyConnected = self.scriptedEffect.integerParameter("FullyConnected")
        minimumSize = self.scriptedEffect.integerParameter("MinimumSize")

        # Get modifier labelmap
        selectedSegmentLabelmap = self.scriptedEffect.selectedSegmentLabelmap()

        castIn = vtk.vtkImageCast()
        castIn.SetInputData(selectedSegmentLabelmap)
        castIn.SetOutputScalarTypeToUnsignedLong()

        # Identify the islands in the inverted volume and
        # find the pixel that corresponds to the background
        islandMath = vtkITK.vtkITKIslandMath()
        islandMath.SetInputConnection(castIn.GetOutputPort())
        islandMath.SetFullyConnected(fullyConnected)
        islandMath.SetMinimumSize(minimumSize)

        # Note that island operation happens in unsigned long space
        # but the segment editor works in unsigned char
        castOut = vtk.vtkImageCast()
        castOut.SetInputConnection(islandMath.GetOutputPort())
        castOut.SetOutputScalarTypeToUnsignedChar()
        castOut.Update()

        islandCount = islandMath.GetNumberOfIslands()
        islandOrigCount = islandMath.GetOriginalNumberOfIslands()
        ignoredIslands = islandOrigCount - islandCount
        logging.info("%d islands created (%d ignored)" % (islandCount, ignoredIslands))

        # Create oriented image data from output
        import vtkSegmentationCorePython as vtkSegmentationCore

        multiLabelImage = vtkSegmentationCore.vtkOrientedImageData()
        multiLabelImage.DeepCopy(castOut.GetOutput())
        selectedSegmentLabelmapImageToWorldMatrix = vtk.vtkMatrix4x4()
        selectedSegmentLabelmap.GetImageToWorldMatrix(selectedSegmentLabelmapImageToWorldMatrix)
        multiLabelImage.SetGeometryFromImageToWorldMatrix(selectedSegmentLabelmapImageToWorldMatrix)

        # Import multi-label labelmap to segmentation
        segmentationNode = self.scriptedEffect.parameterSetNode().GetSegmentationNode()
        selectedSegmentID = self.scriptedEffect.parameterSetNode().GetSelectedSegmentID()
        selectedSegmentName = segmentationNode.GetSegmentation().GetSegment(selectedSegmentID).GetName()
        slicer.vtkSlicerSegmentationsModuleLogic.ImportLabelmapToSegmentationNode(
            multiLabelImage, segmentationNode, selectedSegmentName
        )

        # Set labelmap visibility to outline for the new segments
        displayNode = segmentationNode.GetDisplayNode()
        # for index in xrange(1,islandCount+1):
        #  segmentID = selectedSegmentName + "_" + str(index)
        #  displayNode.SetSegmentVisibility2DFill(segmentID, False)
        #  displayNode.SetSegmentVisibility2DOutline(segmentID, True)

        displayNode.SetSegmentVisibility(selectedSegmentID, False)
Beispiel #6
0
  def onApply(self):
    #TODO:
    #self.logic.undoRedo = self.undoRedo

    # Get parameters
    fullyConnected = self.scriptedEffect.integerParameter("FullyConnected")
    minimumSize = self.scriptedEffect.integerParameter("MinimumSize")

    # Get modifier labelmap
    selectedSegmentLabelmap = self.scriptedEffect.selectedSegmentLabelmap()

    castIn = vtk.vtkImageCast()
    castIn.SetInputData(selectedSegmentLabelmap)
    castIn.SetOutputScalarTypeToUnsignedLong()

    # Identify the islands in the inverted volume and
    # find the pixel that corresponds to the background
    islandMath = vtkITK.vtkITKIslandMath()
    islandMath.SetInputConnection(castIn.GetOutputPort())
    islandMath.SetFullyConnected(fullyConnected)
    islandMath.SetMinimumSize(minimumSize)

    # Note that island operation happens in unsigned long space
    # but the segment editor works in unsigned char
    castOut = vtk.vtkImageCast()
    castOut.SetInputConnection(islandMath.GetOutputPort())
    castOut.SetOutputScalarTypeToUnsignedChar()
    castOut.Update()

    islandCount = islandMath.GetNumberOfIslands()
    islandOrigCount = islandMath.GetOriginalNumberOfIslands()
    ignoredIslands = islandOrigCount - islandCount
    logging.info( "%d islands created (%d ignored)" % (islandCount, ignoredIslands) )

    # Create oriented image data from output
    import vtkSegmentationCorePython as vtkSegmentationCore
    multiLabelImage = vtkSegmentationCore.vtkOrientedImageData()
    multiLabelImage.DeepCopy(castOut.GetOutput())
    selectedSegmentLabelmapImageToWorldMatrix = vtk.vtkMatrix4x4()
    selectedSegmentLabelmap.GetImageToWorldMatrix(selectedSegmentLabelmapImageToWorldMatrix)
    multiLabelImage.SetGeometryFromImageToWorldMatrix(selectedSegmentLabelmapImageToWorldMatrix)

    # Import multi-label labelmap to segmentation
    segmentationNode = self.scriptedEffect.parameterSetNode().GetSegmentationNode()
    selectedSegmentID = self.scriptedEffect.parameterSetNode().GetSelectedSegmentID()
    selectedSegmentName = segmentationNode.GetSegmentation().GetSegment(selectedSegmentID).GetName()
    slicer.vtkSlicerSegmentationsModuleLogic.ImportLabelmapToSegmentationNode( \
      multiLabelImage, segmentationNode, selectedSegmentName )

    # Set labelmap visibility to outline for the new segments
    displayNode = segmentationNode.GetDisplayNode()
    #for index in xrange(1,islandCount+1):
    #  segmentID = selectedSegmentName + "_" + str(index)
    #  displayNode.SetSegmentVisibility2DFill(segmentID, False)
    #  displayNode.SetSegmentVisibility2DOutline(segmentID, True)

    displayNode.SetSegmentVisibility(selectedSegmentID, False)
  def onApply(self):
    # This can be a long operation - indicate it to the user
    qt.QApplication.setOverrideCursor(qt.Qt.WaitCursor)

    self.scriptedEffect.saveStateForUndo()

    # Get parameters
    fullyConnected = self.scriptedEffect.integerParameter("FullyConnected")
    minimumSize = self.scriptedEffect.integerParameter("MinimumSize")

    # Get modifier labelmap
    selectedSegmentLabelmap = self.scriptedEffect.selectedSegmentLabelmap()

    castIn = vtk.vtkImageCast()
    castIn.SetInputData(selectedSegmentLabelmap)
    castIn.SetOutputScalarTypeToUnsignedLong()

    # Identify the islands in the inverted volume and
    # find the pixel that corresponds to the background
    islandMath = vtkITK.vtkITKIslandMath()
    islandMath.SetInputConnection(castIn.GetOutputPort())
    islandMath.SetFullyConnected(fullyConnected)
    islandMath.SetMinimumSize(minimumSize)

    # Note that island operation happens in unsigned long space
    # but the segment editor works in unsigned char
    castOut = vtk.vtkImageCast()
    castOut.SetInputConnection(islandMath.GetOutputPort())
    castOut.SetOutputScalarTypeToUnsignedChar()
    castOut.Update()

    islandCount = islandMath.GetNumberOfIslands()
    islandOrigCount = islandMath.GetOriginalNumberOfIslands()
    ignoredIslands = islandOrigCount - islandCount
    logging.info( "%d islands created (%d ignored)" % (islandCount, ignoredIslands) )

    # Create oriented image data from output
    import vtkSegmentationCorePython as vtkSegmentationCore
    multiLabelImage = vtkSegmentationCore.vtkOrientedImageData()
    multiLabelImage.DeepCopy(castOut.GetOutput())
    selectedSegmentLabelmapImageToWorldMatrix = vtk.vtkMatrix4x4()
    selectedSegmentLabelmap.GetImageToWorldMatrix(selectedSegmentLabelmapImageToWorldMatrix)
    multiLabelImage.SetGeometryFromImageToWorldMatrix(selectedSegmentLabelmapImageToWorldMatrix)

    # Import multi-label labelmap to segmentation
    segmentationNode = self.scriptedEffect.parameterSetNode().GetSegmentationNode()
    selectedSegmentID = self.scriptedEffect.parameterSetNode().GetSelectedSegmentID()
    selectedSegmentName = segmentationNode.GetSegmentation().GetSegment(selectedSegmentID).GetName()
    slicer.vtkSlicerSegmentationsModuleLogic.ImportLabelmapToSegmentationNode( \
      multiLabelImage, segmentationNode, selectedSegmentName )

    segmentationNode.GetSegmentation().RemoveSegment(selectedSegmentID)

    qt.QApplication.restoreOverrideCursor()
Beispiel #8
0
    def removeIslands(self):
        #
        # change the label values based on the parameter node
        #
        if not self.sliceLogic:
            self.sliceLogic = self.editUtil.getSliceLogic()
        parameterNode = self.editUtil.getParameterNode()
        minimumSize = int(
            parameterNode.GetParameter("IslandEffect,minimumSize"))
        fullyConnected = bool(
            parameterNode.GetParameter("IslandEffect,fullyConnected"))
        label = self.editUtil.getLabel()

        # note that island operation happens in unsigned long space
        # but the slicer editor works in Short
        castIn = vtk.vtkImageCast()
        if vtk.VTK_MAJOR_VERSION <= 5:
            castIn.SetInput(self.getScopedLabelInput())
        else:
            castIn.SetInputData(self.getScopedLabelInput())
        castIn.SetOutputScalarTypeToUnsignedLong()

        # now identify the islands in the inverted volume
        # and find the pixel that corresponds to the background
        islandMath = vtkITK.vtkITKIslandMath()
        if vtk.VTK_MAJOR_VERSION <= 5:
            islandMath.SetInput(castIn.GetOutput())
        else:
            islandMath.SetInputConnection(castIn.GetOutputPort())
        islandMath.SetFullyConnected(fullyConnected)
        islandMath.SetMinimumSize(minimumSize)
        # TODO: $this setProgressFilter $islandMath "Calculating Islands..."

        # note that island operation happens in unsigned long space
        # but the slicer editor works in Short
        castOut = vtk.vtkImageCast()
        if vtk.VTK_MAJOR_VERSION <= 5:
            castOut.SetInput(islandMath.GetOutput())
        else:
            castOut.SetInputConnection(islandMath.GetOutputPort())
        castOut.SetOutputScalarTypeToShort()
        castOut.SetOutput(self.getScopedLabelOutput())

        # TODO $this setProgressFilter $postThresh "Applying to Label Map..."
        castOut.Update()
        islandCount = islandMath.GetNumberOfIslands()
        islandOrigCount = islandMath.GetOriginalNumberOfIslands()
        ignoredIslands = islandOrigCount - islandCount
        print("%d islands created (%d ignored)" %
              (islandCount, ignoredIslands))

        self.applyScopedLabel()
        castOut.SetOutput(None)
def GetRawDICOMData(filenames,fileID):
  print filenames,fileID
  vtkRealDcmReader = vtk.vtkDICOMImageReader()
  vtkRealDcmReader.SetFileName("%s/%s"%(rootdir,filenames[0]) )
  vtkRealDcmReader.Update()
  vtkRealData = vtk.vtkImageCast()
  vtkRealData.SetOutputScalarTypeToFloat()
  vtkRealData.SetInput( vtkRealDcmReader.GetOutput() )
  vtkRealData.Update( )
  real_image = vtkRealData.GetOutput().GetPointData() 
  real_array = vtkNumPy.vtk_to_numpy(real_image.GetArray(0)) 

  vtkImagDcmReader = vtk.vtkDICOMImageReader()
  vtkImagDcmReader.SetFileName("%s/%s"%(rootdir,filenames[1]) )
  vtkImagDcmReader.Update()
  vtkImagData = vtk.vtkImageCast()
  vtkImagData.SetOutputScalarTypeToFloat()
  vtkImagData.SetInput( vtkImagDcmReader.GetOutput() )
  vtkImagData.Update( )
  imag_image = vtkImagData.GetOutput().GetPointData() 
  imag_array = vtkNumPy.vtk_to_numpy(imag_image.GetArray(0)) 

  vtkAppend = vtk.vtkImageAppendComponents()
  vtkAppend.SetInput( 0,vtkRealDcmReader.GetOutput() )
  vtkAppend.SetInput( 1,vtkImagDcmReader.GetOutput() )
  vtkAppend.Update( )

  # write raw data
  vtkRawData = vtkAppend.GetOutput()
  vtkRawData.SetSpacing( spacing )
  vtkDcmWriter = vtk.vtkDataSetWriter()
  vtkDcmWriter.SetFileTypeToBinary()
  vtkDcmWriter.SetFileName("s%d/rawdata.%04d.vtk" % (dirID,fileID) )
  vtkDcmWriter.SetInput( vtkRawData )
  vtkDcmWriter.Update()

  # write raw phase data
  vtkPhase = vtk.vtkImageMathematics()
  vtkPhase.SetInput1( vtkRealData.GetOutput() )
  vtkPhase.SetInput2( vtkImagData.GetOutput() )
  vtkPhase.SetOperationToATAN2( )
  vtkPhase.Update( )
  vtkPhaseData = vtkPhase.GetOutput()
  vtkPhaseData.SetSpacing( spacing )
  vtkDcmWriter = vtk.vtkDataSetWriter()
  vtkDcmWriter.SetFileTypeToBinary()
  vtkDcmWriter.SetFileName("s%d/phase.%04d.vtk" % (dirID,fileID) )
  vtkDcmWriter.SetInput( vtkPhaseData)
  vtkDcmWriter.Update()

  return (real_array,imag_array)
  def removeIslands(self):
    #
    # change the label values based on the parameter node
    #
    if not self.sliceLogic:
      self.sliceLogic = self.editUtil.getSliceLogic()
    parameterNode = self.editUtil.getParameterNode()
    minimumSize = int(parameterNode.GetParameter("IslandEffect,minimumSize"))
    fullyConnected = bool(parameterNode.GetParameter("IslandEffect,fullyConnected"))
    label = self.editUtil.getLabel()

    # note that island operation happens in unsigned long space
    # but the slicer editor works in Short
    castIn = vtk.vtkImageCast()
    if vtk.VTK_MAJOR_VERSION <= 5:
      castIn.SetInput( self.getScopedLabelInput() )
    else:
      castIn.SetInputData( self.getScopedLabelInput() )
    castIn.SetOutputScalarTypeToUnsignedLong()

    # now identify the islands in the inverted volume
    # and find the pixel that corresponds to the background
    islandMath = vtkITK.vtkITKIslandMath()
    if vtk.VTK_MAJOR_VERSION <= 5:
      islandMath.SetInput( castIn.GetOutput() )
    else:
      islandMath.SetInputConnection( castIn.GetOutputPort() )
    islandMath.SetFullyConnected( fullyConnected )
    islandMath.SetMinimumSize( minimumSize )
    # TODO: $this setProgressFilter $islandMath "Calculating Islands..."

    # note that island operation happens in unsigned long space
    # but the slicer editor works in Short
    castOut = vtk.vtkImageCast()
    if vtk.VTK_MAJOR_VERSION <= 5:
      castOut.SetInput( islandMath.GetOutput() )
    else:
      castOut.SetInputConnection( islandMath.GetOutputPort() )
    castOut.SetOutputScalarTypeToShort()
    castOut.SetOutput( self.getScopedLabelOutput() )

    # TODO $this setProgressFilter $postThresh "Applying to Label Map..."
    castOut.Update()
    islandCount = islandMath.GetNumberOfIslands()
    islandOrigCount = islandMath.GetOriginalNumberOfIslands()
    ignoredIslands = islandOrigCount - islandCount
    print( "%d islands created (%d ignored)" % (islandCount, ignoredIslands) )

    self.applyScopedLabel()
    castOut.SetOutput( None )
Beispiel #11
0
    def BuildVTKGradientBasedFeatureImage(self):

        cast = vtk.vtkImageCast()
        cast.SetInputData(self.Image)
        cast.SetOutputScalarTypeToFloat()
        cast.Update()

        gradientMagnitude = vtk.vtkImageGradientMagnitude()
        gradientMagnitude.SetInputConnection(cast.GetOutputPort())
        gradientMagnitude.SetDimensionality(self.Dimensionality)
        gradientMagnitude.Update()

        imageAdd = vtk.vtkImageMathematics()
        imageAdd.SetInputConnection(gradientMagnitude.GetOutputPort())
        imageAdd.SetOperationToAddConstant()
        imageAdd.SetConstantC(1.0)
        imageAdd.Update()

        imageInvert = vtk.vtkImageMathematics()
        imageInvert.SetInputConnection(imageAdd.GetOutputPort())
        imageInvert.SetOperationToInvert()
        imageInvert.SetConstantC(1E20)
        imageInvert.DivideByZeroToCOn()
        imageInvert.Update()

        self.FeatureImage = vtk.vtkImageData()
        self.FeatureImage.DeepCopy(imageInvert.GetOutput())
Beispiel #12
0
    def run(self):
        global vtk_error

        #----- verify extension ------------------
        extension = VerifyDataType(self.filepath)

        file_name = self.filepath.split(os.path.sep)[-1]

        n_array = ReadBitmap(self.filepath)
      
        if not(isinstance(n_array, numpy.ndarray)):
            return False
            
        image = converters.to_vtk(n_array, spacing=(1,1,1),\
                slice_number=1, orientation="AXIAL")


        dim = image.GetDimensions()
        x = dim[0]
        y = dim[1]

        img = vtk.vtkImageResample()
        img.SetInputData(image)
        img.SetAxisMagnificationFactor ( 0, 0.25 )
        img.SetAxisMagnificationFactor ( 1, 0.25 )
        img.SetAxisMagnificationFactor ( 2, 1 )    
        img.Update()

        tp = img.GetOutput().GetScalarTypeAsString()

        image_copy = vtk.vtkImageData()
        image_copy.DeepCopy(img.GetOutput())
        
        thumbnail_path = tempfile.mktemp()

        write_png = vtk.vtkPNGWriter()
        write_png.SetInputConnection(img.GetOutputPort())
        write_png.AddObserver("WarningEvent", VtkErrorPNGWriter)
        write_png.SetFileName(thumbnail_path)
        write_png.Write()

        if vtk_error:
            img = vtk.vtkImageCast()
            img.SetInputData(image_copy)
            img.SetOutputScalarTypeToUnsignedShort()
            #img.SetClampOverflow(1)
            img.Update()

            write_png = vtk.vtkPNGWriter()
            write_png.SetInputConnection(img.GetOutputPort())
            write_png.SetFileName(thumbnail_path)
            write_png.Write()
    
            vtk_error = False

        id = wx.NewId()

        bmp_item = [self.filepath, thumbnail_path, extension, x, y,\
                                str(x) + ' x ' + str(y), file_name, id]
        self.bmp_file.Add(bmp_item)
    def __init__(self, data_reader):
        #if vtk_structured_points_data!=None:
        #   ukosniki=vtk_structured_points_data.count("/")
        #  etykieta=vtk_structured_points_data.split("/",ukosniki)
        # self.WhoAmI=self.WhoAmI+" "+ etykieta[ukosniki]

        #def make_name(self,name):
        #   if name!=None:
        #      ukosniki=name.count("/")
        #     etykieta=name.split("/",ukosniki)
        #    self.WhoAmI=self.WhoAmI+" "+ etykieta[ukosniki]

        self.make_color_function(data_reader.get_data_set().GetScalarRange())
        # The property describes how the data will look
        self.volumeProperty = vtk.vtkVolumeProperty()
        self.volumeProperty.SetColor(self.colorTransferFunction)
        self.volumeProperty.SetScalarOpacity(self.opacityTransferFunction)
        self.volumeProperty.SetGradientOpacity(self.gradientTransferFunction)
        # The mapper / ray cast function know how to render the data
        self.compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()

        self.cast = vtk.vtkImageCast()
        self.cast.SetInput(data_reader.get_data_set())
        self.cast.SetOutputScalarTypeToUnsignedShort()

        self.cast.ClampOverflowOff()
        self.mapper = vtk.vtkVolumeRayCastMapper()
        self.mapper.SetVolumeRayCastFunction(self.compositeFunction)
        self.mapper.SetInputConnection(self.cast.GetOutputPort())

        self.actor = vtk.vtkVolume()
        self.actor.SetMapper(self.mapper)
        self.actor.SetProperty(self.volumeProperty)
def getIndexedImageData(inputVtkImageData, indexVal):
    """
    @type  inputVtkImageData: C{vtkImageData}
    @param inputVtkImageData: Image data to be processed
    
    @type  indexVal: C{unsigned int}
    @param indexVal: Index value that will be assigned to all non-zero values.
    
    Function replaces all non-zero valued pixels of provided
    C{inputVtkImageData} with C{indexVal} and returns the result.
    
    @rtype: C{vtkImageData}
    @return: UnsignedInt vtkImageData with two values 0 and provided
             C{indexVal}.
    """
    # Convert normalized input image to unsigned int scalars
    cast = vtk.vtkImageCast()
    cast.SetInput(getImageMask(inputVtkImageData))
    cast.SetOutputScalarTypeToUnsignedInt()
    
    # Then multiply the normalized image data by priovided constant
    multip = vtk.vtkImageMathematics()
    multip.SetOperationToMultiplyByK()
    multip.SetConstantK(indexVal)
    multip.SetInput(cast.GetOutput())
    return multip.GetOutput()
def write_image(_data, path_to_image):
    # == make sure data type is unsigned char
    cast = vtk.vtkImageCast()
    if vtk.VTK_MAJOR_VERSION <= 5:
        cast.SetInput(_data)
    else:
        cast.SetInputData(_data)
    cast.SetOutputScalarTypeToUnsignedChar()
    cast.Update()
    _data = cast.GetOutput()
    # == write
    file_ext = fu.get_file_extension(path_to_image)
    if (file_ext == "vti"):
        print("Writing as  '.vti' file.")
        image_writer = vtk.vtkXMLImageDataWriter()
    elif (file_ext == "nii"):
        print("Writing as  '.nii' file.")
        image_writer = vtk.vtkNIFTIImageWriter()
        print(
            "VTK seems to change image orientation of NIFTI. Make sure to check image orientation relative to original image"
        )
    elif (file_ext == "mhd" or file_ext == "mha"):
        print("Writing as .mhd/.raw or .mha image.")
        image_writer = vtk.vtkMetaImageWriter()
        image_writer.SetCompression(False)
    else:
        print("No valid image file extension specified!")
    if vtk.VTK_MAJOR_VERSION <= 5:
        image_writer.SetInput(_data)
    else:
        image_writer.SetInputData(_data)
    image_writer.SetFileName(path_to_image)
    # image_writer.Update()
    image_writer.Write()
    print("Image has been saved as %s " % (path_to_image))
Beispiel #16
0
 def castVolumeNodeToShort(self, volumeNode):
   imageData = volumeNode.GetImageData()  
   cast=vtk.vtkImageCast()
   cast.SetInputData(imageData)
   cast.SetOutputScalarTypeToShort()
   cast.SetOutput(imageData)
   cast.Update()  
Beispiel #17
0
    def read_metaimage(self, fname_meta, cast_type=5):

        reader = vtk.vtkMetaImageReader()
        reader.SetFileName(fname_meta)

        # VTK image cast
        img_cast = vtk.vtkImageCast()
        if cast_type == 0:
            # return a vtkImageData with wrong dims and bounds value
            self.reader = reader.GetOutput()
            # return reader.GetOutput()

        elif cast_type in [i for i in range(2, 12)]:
            img_cast.SetInputConnection(reader.GetOutputPort())
            img_cast.SetOutputScalarType(cast_type)
            img_cast.Update()
            self.reader = img_cast.GetOutput()
            # return img_cast.GetOutput()  # a vtkImageData

        else:
            sys.stderr.write(
                ('Wrong Cast Type! It should be 2, 3, ..., 11\n')
                ('No Image Cast Applied')
            )
            self.reader = img_cast.GetOutput()
            # return reader.GetOutput()

        self.flag_read = True

        return self.reader
Beispiel #18
0
    def Execute(self):

        if self.Image == None:
            self.PrintError('Error: No input image.')

        if self.OutputType == 'uchar' and self.ShiftScale:
            shiftScale = vtk.vtkImageShiftScale()
            shiftScale.SetInputData(self.Image)
            if self.WindowLevel[0] == 0.0:
                scalarRange = self.Image.GetScalarRange()
                scale = 255.0
                if (scalarRange[1]-scalarRange[0]) > 0.0:
                    scale = 255.0/(scalarRange[1]-scalarRange[0])
                shiftScale.SetShift(-scalarRange[0])
                shiftScale.SetScale(scale)
            else:
                shiftScale.SetShift(-(self.WindowLevel[1]-self.WindowLevel[0]/2.0))
                shiftScale.SetScale(255.0/self.WindowLevel[0])
            shiftScale.SetOutputScalarTypeToUnsignedChar()
            shiftScale.ClampOverflowOn()
            shiftScale.Update()
            self.Image = shiftScale.GetOutput()
        else:
            cast = vtk.vtkImageCast()
            cast.SetInputData(self.Image)
            if self.OutputType == 'float':
                cast.SetOutputScalarTypeToFloat()
            elif self.OutputType == 'double':
                cast.SetOutputScalarTypeToDouble()
            elif self.OutputType == 'uchar':
                cast.SetOutputScalarTypeToUnsignedChar()
            elif self.OutputType == 'short':
                cast.SetOutputScalarTypeToShort()
            cast.Update()
            self.Image = cast.GetOutput()
	def execute(self, inputs, update = 0, last = 0):
		"""
		Execute the filter with given inputs and return the output
		"""
		lib.ProcessingFilter.ProcessingFilter.execute(self, inputs)
		image = self.getInput(1)
		image2 = self.getInput(2)
		self.vtkfilter.SetClampOverflow(self.parameters["ClampOverflow"])
	
		if self.numberOfInputs[0] > 1:
			if image.GetScalarType != image2.GetScalarType():
				cast = vtk.vtkImageCast()
				cast.SetOutputScalarType(image.GetScalarType())
				cast.SetInput(image2)
				cast.Update()
				image2 = cast.GetOutput()
			self.vtkfilter.SetInput1(image)
			self.vtkfilter.SetInput2(image2)
		else:
			self.vtkfilter.SetInput1(image)
			self.vtkfilter.SetInput2(image)
			self.vtkfilter.SetInput(image)    
		f = "self.vtkfilter.SetOperationTo%s()" % self.operation
		eval(f)
		
		if update:
			self.vtkfilter.Update()
		return self.vtkfilter.GetOutput() 
Beispiel #20
0
def main(argv):
    #Just get something working for testing...
    try:
        opts, args = getopt.getopt(argv, "hi:", ["ifile="])
    except getopt.GetoptError as err:
        print 'tviewer.py -i <inputfile.vtk>'
        print(str(err))
    for opt, arg in opts:
        if opt == '-h':
            print 'tviewer.py -i <inputfile.vtk>'
            sys.exit()
        elif opt in ("-i", "--ifile"):
            inputfile = arg
    print("Going to load and generate png from ", inputfile)
    #Read data
    reader = vtk.vtkXMLImageDataReader()
    reader.SetFileName(inputfile)
    reader.Update()

    image = reader.GetOutput()
    #image.SetSpacing(1,1,1)
    #image.GetPointData().SetScalars(image.GetPointData().GetVectors())
    #Compute Q Criterion for texture mapping

    #Now put this in a png file
    castFilter = vtk.vtkImageCast()
    castFilter.SetInputData(image)
    castFilter.Update()

    w = vtk.vtkPNGWriter()
    w.SetInputData(castFilter.GetOutput())
    w.SetFileName("xyslice.png")
    w.Write()
Beispiel #21
0
    def __init__(self):
        """
		Initialization
		"""
        lib.ProcessingFilter.ProcessingFilter.__init__(self, (1, 1))
        self.vtkfilter = vtk.vtkImageCast()
        self.vtkfilter.AddObserver("ProgressEvent", lib.messenger.send)
        lib.messenger.connect(self.vtkfilter, 'ProgressEvent',
                              self.updateProgress)
        self.eventDesc = "Casting the image to datatype"
        self.descs = {
            "ClampOverflow": "Prevent over/underflow",
            "Float": "Float",
            "Double": "Double",
            "Int": "Int",
            "UnsignedInt": "Unsigned int",
            "Long": "Long",
            "UnsignedLong": "Unsigned long",
            "Short": "Short",
            "UnsignedShort": "Unsigned short",
            "UnsignedChar": "Unsigned char",
            "Char": "Char",
            "RescaleCTF": "Rescale current CTF to range of a new datatype"
        }
        self.filterDesc = "Converts input data type to another data type\nInput: Grayscale/Binary/Label image\nOutput: Grayscale/Binary/Label image"
    def update_mask(self, src):

        # Filter
        cast_filter = vtk.vtkImageCast()
        cast_filter.SetOutputScalarTypeToUnsignedInt()
        cast_filter.SetInputData(src)
        cast_filter.Update()

        # Create mesh using marching cube
        march = vtk.vtkDiscreteMarchingCubes()
        march.ComputeNormalsOn()
        march.ComputeGradientsOn()
        for i, organ in enumerate(Settings.organs):
            march.SetValue(i, Settings.labels[organ]['value'])
        march.SetInputData(cast_filter.GetOutput())
        march.Update()

        # Filtrate the masks
        smooth = vtk.vtkWindowedSincPolyDataFilter()
        smooth.SetInputConnection(march.GetOutputPort())
        smooth.SetNumberOfIterations(15)
        smooth.BoundarySmoothingOff()
        smooth.FeatureEdgeSmoothingOff()
        smooth.SetFeatureAngle(120.0)
        smooth.SetPassBand(.001)
        smooth.NonManifoldSmoothingOn()
        smooth.NormalizeCoordinatesOn()
        smooth.Update()

        self.surface_mapper.SetInputConnection(smooth.GetOutputPort())
Beispiel #23
0
    def convertITKtoVTK(self, image, cast=None, force=0):
        """
		Convert the ITK image data to VTK image
		"""
        # For non-ITK images, do nothing
        if image.__class__ == vtk.vtkImageData:
            return image

        try:
            import itk
        except ImportError:
            print "Could not import ITK, terminating."
            sys.exit()

        self.itkToVtk = itk.ImageToVTKImageFilter[image].New()
        # If the next filter is also an ITK filter, then won't
        # convert
        if not force and self.nextFilter and self.nextFilter.getITK():
            return image

        self.itkToVtk.SetInput(image)
        self.itkToVtk.Update()

        if cast:
            icast = vtk.vtkImageCast()
            if cast == "UC3":
                icast.SetOutputScalarTypeToUnsignedChar()
            elif cast == "US3":
                icast.SetOutputScalarTypeToUnsignedShort()
            icast.SetInput(self.itkToVtk.GetOutput())
            icast.Update()
            return icast.GetOutput()

        return self.itkToVtk.GetOutput()
Beispiel #24
0
def castImagesToLargestDataType(images):
    """
	This function casts a list of images using the vtkImageCast so that they all have the 
	same type that is large enough to hold all of the images
	@param images A list of vtkImageData objects
	"""
    returnValues = []
    largestType = -1
    largestMax = 0
    types = []
    differ = 0
    for index, i in enumerate(images):
        types.append(i.GetScalarType())
        if types[index] != types[index - 1]:
            differ = 1
        if i.GetScalarTypeMax() > largestMax:
            largestType = i.GetScalarType()
            largestMax = i.GetScalarTypeMax()

    if not differ: return images

    for i, image in enumerate(images):
        cast = vtk.vtkImageCast()
        cast.SetOutputScalarType(largestType)
        cast.SetInput(image)
        image = cast.GetOutput()
        returnValues.append(image)

    return returnValues
Beispiel #25
0
    def Execute(self):

        if self.Image == None:
            self.PrintError('Error: No input image.')

        if self.OutputType == 'uchar' and self.ShiftScale:
            shiftScale = vtk.vtkImageShiftScale()
            shiftScale.SetInputData(self.Image)
            if self.WindowLevel[0] == 0.0:
                scalarRange = self.Image.GetScalarRange()
                scale = 255.0
                if (scalarRange[1]-scalarRange[0]) > 0.0:
                    scale = 255.0/(scalarRange[1]-scalarRange[0])
                shiftScale.SetShift(-scalarRange[0])
                shiftScale.SetScale(scale)
            else:
                shiftScale.SetShift(-(self.WindowLevel[1]-self.WindowLevel[0]/2.0))
                shiftScale.SetScale(255.0/self.WindowLevel[0])
            shiftScale.SetOutputScalarTypeToUnsignedChar()
            shiftScale.ClampOverflowOn()
            shiftScale.Update()
            self.Image = shiftScale.GetOutput()
        else:
            cast = vtk.vtkImageCast()
            cast.SetInputData(self.Image)
            if self.OutputType == 'float':
                cast.SetOutputScalarTypeToFloat()
            elif self.OutputType == 'double':
                cast.SetOutputScalarTypeToDouble()
            elif self.OutputType == 'uchar':
                cast.SetOutputScalarTypeToUnsignedChar()
            elif self.OutputType == 'short':
                cast.SetOutputScalarTypeToShort()
            cast.Update()
            self.Image = cast.GetOutput()
Beispiel #26
0
    def BuildUpwindGradientBasedFeatureImage(self):
 
        cast = vtk.vtkImageCast()
        cast.SetInputData(self.Image)
        cast.SetOutputScalarTypeToFloat()
        cast.Update()
       
        gradientMagnitude = vtkvmtk.vtkvmtkUpwindGradientMagnitudeImageFilter()
        gradientMagnitude.SetInputConnection(cast.GetOutputPort())
        gradientMagnitude.SetUpwindFactor(self.UpwindFactor)
        gradientMagnitude.Update()

        featureImage = None
        if self.SigmoidRemapping==1:
            scalarRange = gradientMagnitude.GetOutput().GetPointData().GetScalars().GetRange()
            inputMinimum = scalarRange[0]
            inputMaximum = scalarRange[1]
            alpha = - (inputMaximum - inputMinimum) / 6.0
            beta = (inputMaximum + inputMinimum) / 2.0
            sigmoid = vtkvmtk.vtkvmtkSigmoidImageFilter()
            sigmoid.SetInputConnection(gradientMagnitude.GetOutputPort())
            sigmoid.SetAlpha(alpha)
            sigmoid.SetBeta(beta)
            sigmoid.SetOutputMinimum(0.0)
            sigmoid.SetOutputMaximum(1.0)
            sigmoid.Update()
            featureImage = sigmoid.GetOutput()
        else:
            boundedReciprocal = vtkvmtk.vtkvmtkBoundedReciprocalImageFilter()
            boundedReciprocal.SetInputConnection(gradientMagnitude.GetOutputPort())
            boundedReciprocal.Update()
            featureImage = boundedReciprocal.GetOutput()
 
        self.FeatureImage = vtk.vtkImageData()
        self.FeatureImage.DeepCopy(featureImage)
Beispiel #27
0
    def Execute(self):

        if self.Image == None:
            self.PrintError('Error: No input image.')

        morphologyFilter = vtkvmtk.vtkvmtkGrayscaleMorphologyImageFilter()
        if self.Operation == 'close':
            morphologyFilter.SetOperationToClose()
        elif self.Operation == 'open':
            morphologyFilter.SetOperationToOpen()
        elif self.Operation == 'dilate':
            morphologyFilter.SetOperationToDilate()
        elif self.Operation == 'erode':
            morphologyFilter.SetOperationToErode()

        cast = vtk.vtkImageCast()
        cast.SetInputData(self.Image)
        cast.SetOutputScalarTypeToFloat()
        cast.Update()

        morphologyFilter.SetInputConnection(cast.GetOutputPort())
        morphologyFilter.SetBallRadius(self.BallRadius)
        morphologyFilter.Update()

        self.Image = morphologyFilter.GetOutput()
Beispiel #28
0
    def BuildVTKGradientBasedFeatureImage(self):

        cast = vtk.vtkImageCast()
        cast.SetInputData(self.Image)
        cast.SetOutputScalarTypeToFloat()
        cast.Update()

        gradientMagnitude = vtk.vtkImageGradientMagnitude()
        gradientMagnitude.SetInputConnection(cast.GetOutputPort())
        gradientMagnitude.SetDimensionality(self.Dimensionality)
        gradientMagnitude.Update()

        imageAdd = vtk.vtkImageMathematics()
        imageAdd.SetInputConnection(gradientMagnitude.GetOutputPort())
        imageAdd.SetOperationToAddConstant()
        imageAdd.SetConstantC(1.0)
        imageAdd.Update()

        imageInvert = vtk.vtkImageMathematics()
        imageInvert.SetInputConnection(imageAdd.GetOutputPort())
        imageInvert.SetOperationToInvert()
        imageInvert.SetConstantC(1E20)
        imageInvert.DivideByZeroToCOn()
        imageInvert.Update()

        self.FeatureImage = vtk.vtkImageData()
        self.FeatureImage.DeepCopy(imageInvert.GetOutput())
def castImagesToLargestDataType(images):
    """
	This function casts a list of images using the vtkImageCast so that they all have the 
	same type that is large enough to hold all of the images
	@param images A list of vtkImageData objects
	"""
    returnValues = []
    largestType = -1
    largestMax = 0
    types = []
    differ = 0
    for index, i in enumerate(images):
        types.append(i.GetScalarType())
        if types[index] != types[index - 1]:
            differ = 1
        if i.GetScalarTypeMax() > largestMax:
            largestType = i.GetScalarType()
            largestMax = i.GetScalarTypeMax()

    if not differ:
        return images

    for i, image in enumerate(images):
        cast = vtk.vtkImageCast()
        cast.SetOutputScalarType(largestType)
        cast.SetInput(image)
        image = cast.GetOutput()
        returnValues.append(image)

    return returnValues
  def onApply(self):

    inputVolume = self.inputSelector.currentNode()
    outputVolume = self.outputSelector.currentNode()

    if not (inputVolume):
      qt.QMessageBox.critical(
          slicer.util.mainWindow(),
          'Averaging', 'Input volumes are required')
      return

    outVolumeNode = self.outputSelector.currentNode()
    volumesLogic = slicer.modules.volumes.logic()
    # newNode = volumesLogic.CloneVolume(slicer.mrmlScene, sourceVolumeNode, 'average volume')

    # create output volume by cloning the selected reference volume
    # volumesLogic = slicer.modules.volumes.logic()
    newNode = volumesLogic.CloneVolume(self.inputSelector.currentNode(), "average volume")

    # vtk function to average the images
    imgsum = vtk.vtkImageWeightedSum()
    imgsum.NormalizeByWeightOn()

    # add all of the input image data
    for (i,n) in enumerate(self.inputSelector.checkedNodes()):
       print("adding input image: {0}".format(n.GetName()))
       cast = vtk.vtkImageCast()
       cast.SetOutputScalarTypeToFloat()
       cast.AddInputConnection(n.GetImageDataConnection())
       imgsum.AddInputConnection(cast.GetOutputPort())
       imgsum.SetWeight(i, 1.)

    # run the filter and set the result to the output image
    imgsum.Update() 
    newNode.SetAndObserveImageData(imgsum.GetOutput())
	def execute(self, inputs = (1,1), update = 0, last = 0):
		"""
		Execute filter in input image and return output image
		"""
		if not lib.ProcessingFilter.ProcessingFilter.execute(self,inputs):
			return None

		self.eventDesc = "Calculating FFT"
		inputImage = self.getInput(1)

		# Convert image to float
		origType = inputImage.GetScalarType()
		castFloat = vtk.vtkImageCast()
		castFloat.SetOutputScalarTypeToFloat()
		self.filter = vtk.vtkImageFFT()
		#magnitude = vtk.vtkImageMagnitude()
		#fourierCenter = vtk.vtkImageFourierCenter()
		#logarithmic = vtk.vtkImageLogarithmicScale()
		#logarithmic.SetConstant(15)

		castFloat.SetInput(inputImage)
		self.filter.SetInputConnection(castFloat.GetOutputPort())
		#magnitude.SetInputConnection(self.filter.GetOutputPort())
		#fourierCenter.SetInputConnection(magnitude.GetOutputPort())
		#logarithmic.SetInputConnection(fourierCenter.GetOutputPort())
		#outputImage = logarithmic.GetOutput()
		outputImage = self.filter.GetOutput()
		
		if update:
			outputImage.Update()

		return outputImage
    def Execute(self):
          
        if self.Image == None:
            self.PrintError('Error: no Image.')

        cast = vtk.vtkImageCast()
        cast.SetInput(self.Image)
        cast.SetOutputScalarTypeToFloat()
        cast.Update()
        self.Image = cast.GetOutput()

        if not self.vmtkRenderer:
            self.vmtkRenderer = vmtkscripts.vmtkRenderer()
            self.vmtkRenderer.Initialize()
            self.OwnRenderer = 1
 
        if not self.ImageSeeder: 
            self.ImageSeeder = vmtkscripts.vmtkImageSeeder()
            self.ImageSeeder.vmtkRenderer = self.vmtkRenderer
            self.ImageSeeder.Image = self.Image
            self.ImageSeeder.Display = 0
            self.ImageSeeder.Execute()
            self.ImageSeeder.Display = 1
            self.ImageSeeder.BuildView()
  
        if not self.SurfaceViewer:
            self.SurfaceViewer = vmtkscripts.vmtkSurfaceViewer()
            self.SurfaceViewer.vmtkRenderer = self.vmtkRenderer
  
        initializationMethods = {
                                '0': self.CollidingFrontsInitialize,
                                '1': self.FastMarchingInitialize,
                                '2': self.ThresholdInitialize,
                                '3': self.IsosurfaceInitialize,
                                '4': self.SeedInitialize
                                }
  
        endInitialization = False
        while not endInitialization:
            queryString = 'Please choose initialization type: (0: colliding fronts; 1: fast marching; 2: threshold; 3: isosurface, 4: seed): '
            initializationType = self.InputText(queryString,self.InitializationTypeValidator)
            initializationMethods[initializationType]()
            self.DisplayLevelSetSurface(self.InitialLevelSets)
            queryString = 'Accept initialization? (y/n): '
            inputString = self.InputText(queryString,self.YesNoValidator)
            if inputString == 'y':
                self.MergeLevelSets()
                self.DisplayLevelSetSurface(self.MergedInitialLevelSets)
            queryString = 'Initialize another branch? (y/n): '
            inputString = self.InputText(queryString,self.YesNoValidator)
            if inputString == 'y':
                endInitialization = False
            elif inputString == 'n':
                endInitialization = True

        self.InitialLevelSets = self.MergedInitialLevelSets
        self.MergedInitialLevelSets = None

        if self.OwnRenderer:
            self.vmtkRenderer.Deallocate()
Beispiel #33
0
    def execute(self, inputs, update=0, last=0):
        """
		Execute the filter with given inputs and return the output
		"""
        if not lib.ProcessingFilter.ProcessingFilter.execute(self, inputs):
            return None

        if self.parameters["UseImageROI"]:
            maskImage = self.getInput(2)
            # If scalar type is not unsigned char, then cast the data
            cast = vtk.vtkImageCast()
            cast.SetInput(maskImage)
            cast.SetOutputScalarType(3)
            cast.SetClampOverflow(1)
            maskImage = cast.GetOutput()
        else:
            maxx, maxy, maxz = self.dataUnit.getDimensions()
            roi = self.parameters["ROI"][1]
            n, maskImage = lib.ImageOperations.getMaskFromROIs([roi], maxx,
                                                               maxy, maxz)

        scripting.wantWholeDataset = 1
        imagedata = self.getInput(1)
        imagedata.SetUpdateExtent(imagedata.GetWholeExtent())
        imagedata.Update()

        maskFilter = vtk.vtkImageMask()
        maskFilter.SetImageInput(imagedata)
        maskFilter.SetMaskInput(maskImage)
        maskFilter.SetMaskedOutputValue(self.parameters["OutputValue"])

        return maskFilter.GetOutput()
Beispiel #34
0
    def execute(self, inputs, update=0, last=0):
        """
		Execute the filter with given inputs and return the output
		"""
        lib.ProcessingFilter.ProcessingFilter.execute(self, inputs)
        image = self.getInput(1)
        image2 = self.getInput(2)
        self.vtkfilter.SetClampOverflow(self.parameters["ClampOverflow"])

        if self.numberOfInputs[0] > 1:
            if image.GetScalarType != image2.GetScalarType():
                cast = vtk.vtkImageCast()
                cast.SetOutputScalarType(image.GetScalarType())
                cast.SetInput(image2)
                cast.Update()
                image2 = cast.GetOutput()
            self.vtkfilter.SetInput1(image)
            self.vtkfilter.SetInput2(image2)
        else:
            self.vtkfilter.SetInput1(image)
            self.vtkfilter.SetInput2(image)
            self.vtkfilter.SetInput(image)
        f = "self.vtkfilter.SetOperationTo%s()" % self.operation
        eval(f)

        if update:
            self.vtkfilter.Update()
        return self.vtkfilter.GetOutput()
Beispiel #35
0
    def __init__(self, module_manager):
        ModuleBase.__init__(self, module_manager)

        self._input = None

        self._image_cast = vtk.vtkImageCast()
        self._vtk2itk = None
        # this stores the short_string of the current converter, e.g.
        # F3 or US3, etc.
        self._vtk2itk_short_string = None

        self._config.autotype = False
        # this will store the current type as full text, e.g. "unsigned char"
        self._config.type = 'float'

        config_list = [
            ('AutoType:', 'autotype', 'base:bool', 'checkbox',
             'If activated, output data type is set to '
             'input type.'),
            ('Data type:', 'type', 'base:str', 'choice',
             'Data will be cast to this type if AutoType is not used.', [
                 'float', 'signed short', 'unsigned short', 'unsigned char',
                 'unsigned long'
             ])
        ]

        ScriptedConfigModuleMixin.__init__(self, config_list,
                                           {'Module (self)': self})

        self.sync_module_logic_with_config()
Beispiel #36
0
 def __init__(self, module_manager):
     SimpleVTKClassModuleBase.__init__(
         self, module_manager,
         vtk.vtkImageCast(), 'Processing.',
         ('vtkImageData',), ('vtkImageData',),
         replaceDoc=True,
         inputFunctions=None, outputFunctions=None)
Beispiel #37
0
    def Execute(self):

        if self.Image == None:
            self.PrintError('Error: No input image.')

        if self.Grayscale:
            morphologyFilter = vtkvmtk.vtkvmtkGrayscaleMorphologyImageFilter()
            if self.Operation == 'close':
                morphologyFilter.SetOperationToClose()
            elif self.Operation == 'open':
                morphologyFilter.SetOperationToOpen()
            elif self.Operation == 'dilate':
                morphologyFilter.SetOperationToDilate()
            elif self.Operation == 'erode':
                morphologyFilter.SetOperationToErode()

            cast = vtk.vtkImageCast()
            cast.SetInput(self.Image)
            cast.SetOutputScalarTypeToFloat()
            cast.Update()

            morphologyFilter.SetInput(cast.GetOutput())

        morphologyFilter.SetBallRadius(self.BallRadius)
        morphologyFilter.Update()

        self.Image = morphologyFilter.GetOutput()
	def convertITKtoVTK(self, image, cast = None, force = 0):
		"""
		Convert the ITK image data to VTK image
		"""
		# For non-ITK images, do nothing
		if image.__class__ == vtk.vtkImageData:
			return image

		try:
			import itk
		except ImportError:
			print "Could not import ITK, terminating."
			sys.exit()
			
		self.itkToVtk = itk.ImageToVTKImageFilter[image].New()
		# If the next filter is also an ITK filter, then won't
		# convert
		if not force and self.nextFilter and self.nextFilter.getITK():
			return image

		self.itkToVtk.SetInput(image)
		self.itkToVtk.Update()

		if cast:
			icast = vtk.vtkImageCast()
			if cast == "UC3":
				icast.SetOutputScalarTypeToUnsignedChar()
			elif cast == "US3":
				icast.SetOutputScalarTypeToUnsignedShort()
			icast.SetInput(self.itkToVtk.GetOutput())
			icast.Update()
			return icast.GetOutput()

		return self.itkToVtk.GetOutput()
Beispiel #39
0
    def __init__(self, module_manager):
        # initialise our base class
        ModuleBase.__init__(self, module_manager)

        self._image_logic = vtk.vtkImageLogic()

        module_utils.setup_vtk_object_progress(self, self._image_logic,
                                               'Performing image logic')

        self._image_cast = vtk.vtkImageCast()
        module_utils.setup_vtk_object_progress(
            self, self._image_cast, 'Casting scalar type before image logic')

        self._config.operation = 0
        self._config.output_true_value = 1.0

        # 'choice' widget with 'base:int' type will automatically get cast
        # to index of selection that user makes.
        config_list = [
            ('Operation:', 'operation', 'base:int',
             'choice', 'The operation that should be performed.',
             tuple(self._operations)),
            ('Output true value:', 'output_true_value', 'base:float', 'text',
             'Output voxels that are TRUE will get this value.')
        ]

        ScriptedConfigModuleMixin.__init__(self, config_list, {
            'Module (self)': self,
            'vtkImageLogic': self._image_logic
        })

        self.sync_module_logic_with_config()
Beispiel #40
0
    def __init__(self, fileName=None, channel=0, ImageType=None):
        from vtk import vtkLSMReader, vtkImageCast
        import itk
        itk.pipeline.__init__(self)
        # if ImageType is None, give it a default value
        # this is useful to avoid loading Base while loading this module
        if ImageType == None:
            ImageType = itk.Image.UC3
        # remove useless SetInput() method created by the constructor of the pipeline class


#     del self.SetInput
# set up the pipeline
        self.connect(vtkLSMReader())
        self.connect(vtkImageCast())
        PType = itk.template(ImageType)[1][0]
        if PType == itk.UC:
            self[-1].SetOutputScalarTypeToUnsignedChar()
        elif PType == itk.US:
            self[-1].SetOutputScalarTypeToUnsignedShort()
        self.connect(itk.VTKImageToImageFilter[ImageType].New())
        self.connect(itk.ChangeInformationImageFilter[ImageType].New(
            ChangeSpacing=True))
        # and configure the pipeline
        if fileName:
            self.SetFileName(fileName)
        self.SetChannel(channel)
Beispiel #41
0
def read_meta_image(meta_name, cast_type=5):
    """
    Usually Meta Image is `unsigned short`
    No casting leads to wrong reslut!
    """
    reader = vtk.vtkMetaImageReader()
    reader.SetFileName(meta_name)

    # No cast
    if cast_type == 0:
        # vtkImageData with wrong dims and bounds value.
        return reader.GetOutput()

    # Cast the image to another data type
    elif cast_type in [i for i in range(2, 12)]:
        cast = vtk.vtkImageCast()
        # cast.SetInputData(img_vtk)
        cast.SetInputConnection(reader.GetOutputPort())
        cast.SetOutputScalarType(cast_type)
        cast.Update()
        return cast.GetOutput()  # The output of `cast` is a vtkImageData

    # Wrong cast type. Return the no-cast vtkImageData
    else:
        sys.stderr.write('Wrong Cast Type! It should be 2, 3, ..., or 11')
        return reader.GetOutput()
Beispiel #42
0
    def read_metaimage(self, fname_meta, cast_type=5):

        reader = vtk.vtkMetaImageReader()
        reader.SetFileName(fname_meta)

        # VTK image cast
        img_cast = vtk.vtkImageCast()
        if cast_type == 0:
            # return a vtkImageData with wrong dims and bounds value
            self.reader = reader.GetOutput()
            # return reader.GetOutput()

        elif cast_type in [i for i in range(2, 12)]:
            img_cast.SetInputConnection(reader.GetOutputPort())
            img_cast.SetOutputScalarType(cast_type)
            img_cast.Update()
            self.reader = img_cast.GetOutput()
            # return img_cast.GetOutput()  # a vtkImageData

        else:
            sys.stderr.write(('Wrong Cast Type! It should be 2, 3, ..., 11\n'
                              )('No Image Cast Applied'))
            self.reader = img_cast.GetOutput()
            # return reader.GetOutput()

        self.flag_read = True

        return self.reader
Beispiel #43
0
def vtkImageReader(file, segmentation=False):
    """
    using vtkMetaImageReader to read mhd file
    :param file: the path of the mhd file (note: using '/' instead of '\' in absolute path)
    :param segmentation: assign true when file is partial volume segmentation
    :return: updated reader
    """
    image = vtk.vtkMetaImageReader()
    image.SetFileName(file)
    image.Update()
    print(image.GetOutput())
    if segmentation:
        # turn datatype to ushort
        # and increase the voxel value by multiply a constant if it is a partial volume segmentation file
        cast = vtk.vtkImageCast()
        cast.SetInputConnection(image.GetOutputPort())
        cast.SetOutputScalarTypeToUnsignedShort()
        cast.Update()

        math = vtk.vtkImageMathematics()
        math.SetOperationToMultiplyByK()
        math.SetConstantK(1150.0)
        math.SetInputConnection(cast.GetOutputPort())
        math.Update()
        return math
    else:
        return image
Beispiel #44
0
    def execute(self, inputs=(1, 1), update=0, last=0):
        """
		Execute filter in input image and return output image
		"""
        if not lib.ProcessingFilter.ProcessingFilter.execute(self, inputs):
            return None

        self.eventDesc = "Calculating FFT"
        inputImage = self.getInput(1)

        # Convert image to float
        origType = inputImage.GetScalarType()
        castFloat = vtk.vtkImageCast()
        castFloat.SetOutputScalarTypeToFloat()
        self.filter = vtk.vtkImageFFT()
        #magnitude = vtk.vtkImageMagnitude()
        #fourierCenter = vtk.vtkImageFourierCenter()
        #logarithmic = vtk.vtkImageLogarithmicScale()
        #logarithmic.SetConstant(15)

        castFloat.SetInput(inputImage)
        self.filter.SetInputConnection(castFloat.GetOutputPort())
        #magnitude.SetInputConnection(self.filter.GetOutputPort())
        #fourierCenter.SetInputConnection(magnitude.GetOutputPort())
        #logarithmic.SetInputConnection(fourierCenter.GetOutputPort())
        #outputImage = logarithmic.GetOutput()
        outputImage = self.filter.GetOutput()

        if update:
            outputImage.Update()

        return outputImage
Beispiel #45
0
    def run(self):
        global vtk_error

        #----- verify extension ------------------
        extension = VerifyDataType(self.filepath)

        file_name = self.filepath.split(os.path.sep)[-1]

        n_array = ReadBitmap(self.filepath)
      
        if not(isinstance(n_array, numpy.ndarray)):
            return False
            
        image = converters.to_vtk(n_array, spacing=(1,1,1),\
                slice_number=1, orientation="AXIAL")


        dim = image.GetDimensions()
        x = dim[0]
        y = dim[1]

        img = vtk.vtkImageResample()
        img.SetInputData(image)
        img.SetAxisMagnificationFactor ( 0, 0.25 )
        img.SetAxisMagnificationFactor ( 1, 0.25 )
        img.SetAxisMagnificationFactor ( 2, 1 )    
        img.Update()

        tp = img.GetOutput().GetScalarTypeAsString()

        image_copy = vtk.vtkImageData()
        image_copy.DeepCopy(img.GetOutput())
        
        thumbnail_path = tempfile.mktemp()

        write_png = vtk.vtkPNGWriter()
        write_png.SetInputConnection(img.GetOutputPort())
        write_png.AddObserver("WarningEvent", VtkErrorPNGWriter)
        write_png.SetFileName(thumbnail_path)
        write_png.Write()

        if vtk_error:
            img = vtk.vtkImageCast()
            img.SetInputData(image_copy)
            img.SetOutputScalarTypeToUnsignedShort()
            #img.SetClampOverflow(1)
            img.Update()

            write_png = vtk.vtkPNGWriter()
            write_png.SetInputConnection(img.GetOutputPort())
            write_png.SetFileName(thumbnail_path)
            write_png.Write()
    
            vtk_error = False

        id = wx.NewId()

        bmp_item = [self.filepath, thumbnail_path, extension, x, y,\
                                str(x) + ' x ' + str(y), file_name, id]
        self.bmp_file.Add(bmp_item)
Beispiel #46
0
    def Execute(self):

        if self.Image == None:
            self.PrintError("Error: No input image.")

        if self.OutputType == "uchar" and self.ShiftScale:
            shiftScale = vtk.vtkImageShiftScale()
            shiftScale.SetInput(self.Image)
            if self.WindowLevel[0] == 0.0:
                scalarRange = self.Image.GetScalarRange()
                shiftScale.SetShift(-scalarRange[0])
                shiftScale.SetScale(255.0 / (scalarRange[1] - scalarRange[0]))
            else:
                shiftScale.SetShift(-(self.WindowLevel[1] - self.WindowLevel[0] / 2.0))
                shiftScale.SetScale(255.0 / self.WindowLevel[0])
            shiftScale.SetOutputScalarTypeToUnsignedChar()
            shiftScale.ClampOverflowOn()
            shiftScale.Update()
            self.Image = shiftScale.GetOutput()
        else:
            cast = vtk.vtkImageCast()
            cast.SetInput(self.Image)
            if self.OutputType == "float":
                cast.SetOutputScalarTypeToFloat()
            elif self.OutputType == "double":
                cast.SetOutputScalarTypeToDouble()
            elif self.OutputType == "uchar":
                cast.SetOutputScalarTypeToUnsignedChar()
            elif self.OutputType == "short":
                cast.SetOutputScalarTypeToShort()
            cast.Update()
            self.Image = cast.GetOutput()
Beispiel #47
0
def ndarray2vtkImageData(ndarray, cast_type=11, spacing=[1, 1, 1]):
    """
    Convert a NumPy array to a vtkImageData, with a default casting type VTK_DOUBLE
    :param ndarray: input NumPy array, can be 3D array
    :param cast_type: 11 means VTK_DOUBLE
    :return: a vtkImageData
    """
    # Convert numpy array to VTK array (vtkDoubleArray)
    vtk_data_array = numpy_support.numpy_to_vtk(
        num_array=ndarray.transpose(2, 1, 0).ravel(),
        deep=True,
        array_type=vtk.VTK_DOUBLE)

    # Convert the VTK array to vtkImageData
    img_vtk = vtk.vtkImageData()
    img_vtk.SetDimensions(ndarray.shape)
    img_vtk.SetSpacing(spacing[::-1])  # Note the order should be reversed!
    img_vtk.GetPointData().SetScalars(vtk_data_array)  # is a vtkImageData

    # casting
    cast = vtk.vtkImageCast()
    cast.SetInputData(img_vtk)
    cast.SetOutputScalarType(cast_type)
    cast.Update()

    return cast.GetOutput()  # vtkImageData
Beispiel #48
0
def main(argv):
   #Just get something working for testing...
    try:
        opts, args = getopt.getopt(argv,"hi:", ["ifile="])
    except getopt.GetoptError as err:
        print 'tviewer.py -i <inputfile.vtk>'
        print (str(err))
    for opt, arg in opts:
        if opt == '-h':
            print 'tviewer.py -i <inputfile.vtk>'
            sys.exit()
        elif opt in ("-i", "--ifile"):
            inputfile = arg
    print("Going to load and generate png from ", inputfile)
    #Read data
    reader = vtk.vtkXMLImageDataReader()
    reader.SetFileName(inputfile)
    reader.Update()

    image = reader.GetOutput()
    #image.SetSpacing(1,1,1)
    #image.GetPointData().SetScalars(image.GetPointData().GetVectors())
    #Compute Q Criterion for texture mapping
    
    #Now put this in a png file
    castFilter = vtk.vtkImageCast()
    castFilter.SetInputData(image)
    castFilter.Update()
    
    w = vtk.vtkPNGWriter()
    w.SetInputData(castFilter.GetOutput())
    w.SetFileName("xyslice.png")
    w.Write()
Beispiel #49
0
    def onApply(self):

        inputVolume = self.inputSelector.currentNode()
        outputVolume = self.outputSelector.currentNode()

        if not (inputVolume):
            qt.QMessageBox.critical(slicer.util.mainWindow(), 'Averaging',
                                    'Input volumes are required')
            return

        outVolumeNode = self.outputSelector.currentNode()
        volumesLogic = slicer.modules.volumes.logic()
        # newNode = volumesLogic.CloneVolume(slicer.mrmlScene, sourceVolumeNode, 'average volume')

        # create output volume by cloning the selected reference volume
        # volumesLogic = slicer.modules.volumes.logic()
        newNode = volumesLogic.CloneVolume(self.inputSelector.currentNode(),
                                           "average volume")

        # vtk function to average the images
        imgsum = vtk.vtkImageWeightedSum()
        imgsum.NormalizeByWeightOn()

        # add all of the input image data
        for (i, n) in enumerate(self.inputSelector.checkedNodes()):
            print("adding input image: {0}".format(n.GetName()))
            cast = vtk.vtkImageCast()
            cast.SetOutputScalarTypeToFloat()
            cast.AddInputConnection(n.GetImageDataConnection())
            imgsum.AddInputConnection(cast.GetOutputPort())
            imgsum.SetWeight(i, 1.)

        # run the filter and set the result to the output image
        imgsum.Update()
        newNode.SetAndObserveImageData(imgsum.GetOutput())
    def buildGradientBasedFeatureImage(self, imageData):
        '''
        '''
        # import the vmtk libraries
        try:
            import vtkvmtkSegmentationPython as vtkvmtkSegmentation
        except ImportError:
            logging.error("Unable to import the SlicerVmtk libraries")

        derivativeSigma = 0.0
        sigmoidRemapping = 1

        cast = vtk.vtkImageCast()
        cast.SetInputData(imageData)
        cast.SetOutputScalarTypeToFloat()
        cast.Update()

        if (derivativeSigma > 0.0):
            gradientMagnitude = vtkvmtkSegmentation.vtkvmtkGradientMagnitudeRecursiveGaussianImageFilter(
            )
            gradientMagnitude.SetInputData(cast.GetOutput())
            gradientMagnitude.SetSigma(derivativeSigma)
            gradientMagnitude.SetNormalizeAcrossScale(0)
            gradientMagnitude.Update()
        else:
            gradientMagnitude = vtkvmtkSegmentation.vtkvmtkGradientMagnitudeImageFilter(
            )
            gradientMagnitude.SetInputData(cast.GetOutput())
            gradientMagnitude.Update()

        featureImage = None
        if sigmoidRemapping == 1:
            scalarRange = gradientMagnitude.GetOutput().GetPointData(
            ).GetScalars().GetRange()
            inputMinimum = scalarRange[0]
            inputMaximum = scalarRange[1]
            alpha = -(inputMaximum - inputMinimum) / 6.0
            beta = (inputMaximum + inputMinimum) / 2.0

            sigmoid = vtkvmtkSegmentation.vtkvmtkSigmoidImageFilter()
            sigmoid.SetInputData(gradientMagnitude.GetOutput())
            sigmoid.SetAlpha(alpha)
            sigmoid.SetBeta(beta)
            sigmoid.SetOutputMinimum(0.0)
            sigmoid.SetOutputMaximum(1.0)
            sigmoid.Update()
            featureImage = sigmoid.GetOutput()
        else:
            boundedReciprocal = vtkvmtkSegmentation.vtkvmtkBoundedReciprocalImageFilter(
            )
            boundedReciprocal.SetInputData(gradientMagnitude.GetOutput())
            boundedReciprocal.Update()
            featureImage = boundedReciprocal.GetOutput()

        outImageData = vtk.vtkImageData()
        outImageData.DeepCopy(featureImage)

        return outImageData
Beispiel #51
0
def convert_vtk_to_itk_image(vtk_image_data, itk_pixel_type=None):
    """Get an ITK image from the provided vtkImageData object.
    This image can be passed to ITK filters."""

    # Save the VTKGlue optimization for later
    #------------------------------------------
    #itk_import = itk.VTKImageToImageFilter[image_type].New()
    #itk_import.SetInput(vtk_image_data)
    #itk_import.Update()
    #itk_image = itk_import.GetOutput()
    #itk_image.DisconnectPipeline()
    #------------------------------------------
    import itk
    import itkTypes
    import vtk
    from tomviz import utils

    itk_to_vtk_type_map = {
        itkTypes.F: vtk.VTK_FLOAT,
        itkTypes.D: vtk.VTK_DOUBLE,
        itkTypes.LD: vtk.VTK_DOUBLE,
        itkTypes.UC: vtk.VTK_UNSIGNED_CHAR,
        itkTypes.US: vtk.VTK_UNSIGNED_SHORT,
        itkTypes.UI: vtk.VTK_UNSIGNED_INT,
        itkTypes.UL: vtk.VTK_UNSIGNED_LONG,
        itkTypes.SC: vtk.VTK_CHAR,
        itkTypes.SS: vtk.VTK_SHORT,
        itkTypes.SI: vtk.VTK_INT,
        itkTypes.SL: vtk.VTK_LONG,
        itkTypes.B: vtk.VTK_INT
    }

    # See if we need to cast to a wrapped type in ITK.
    src_type = vtk_image_data.GetScalarType()

    if itk_pixel_type is None:
        dst_type = vtk_cast_map()[src_type]
    else:
        dst_type = vtk_cast_map()[itk_to_vtk_type_map[itk_pixel_type]]
    if src_type != dst_type:
        caster = vtk.vtkImageCast()
        caster.SetOutputScalarType(dst_type)
        caster.ClampOverflowOn()
        caster.SetInputData(vtk_image_data)
        caster.Update()
        vtk_image_data = caster.GetOutput()

    array = utils.get_array(vtk_image_data)

    image_type = _get_itk_image_type(vtk_image_data)
    itk_converter = itk.PyBuffer[image_type]
    itk_image = itk_converter.GetImageFromArray(array)
    spacing = vtk_image_data.GetSpacing()
    origin = vtk_image_data.GetOrigin()
    itk_image.SetSpacing(spacing)
    itk_image.SetOrigin(origin)

    return itk_image
Beispiel #52
0
 def __init__(self, module_manager):
     SimpleVTKClassModuleBase.__init__(self,
                                       module_manager,
                                       vtk.vtkImageCast(),
                                       'Processing.', ('vtkImageData', ),
                                       ('vtkImageData', ),
                                       replaceDoc=True,
                                       inputFunctions=None,
                                       outputFunctions=None)
    def buildGradientBasedFeatureImage(self, imageData):
        '''
        '''
        # import the vmtk libraries
        try:
            import vtkvmtkSegmentationPython as vtkvmtkSegmentation
        except ImportError:
            logging.error("Unable to import the SlicerVmtk libraries")

        derivativeSigma = 0.0
        sigmoidRemapping = 1

        cast = vtk.vtkImageCast()
        cast.SetInputData(imageData)
        cast.SetOutputScalarTypeToFloat()
        cast.Update()

        if (derivativeSigma > 0.0):
            gradientMagnitude = vtkvmtkSegmentation.vtkvmtkGradientMagnitudeRecursiveGaussianImageFilter()
            gradientMagnitude.SetInputData(cast.GetOutput())
            gradientMagnitude.SetSigma(derivativeSigma)
            gradientMagnitude.SetNormalizeAcrossScale(0)
            gradientMagnitude.Update()
        else:
            gradientMagnitude = vtkvmtkSegmentation.vtkvmtkGradientMagnitudeImageFilter()
            gradientMagnitude.SetInputData(cast.GetOutput())
            gradientMagnitude.Update()

        featureImage = None
        if sigmoidRemapping == 1:
            scalarRange = gradientMagnitude.GetOutput().GetPointData().GetScalars().GetRange()
            inputMinimum = scalarRange[0]
            inputMaximum = scalarRange[1]
            alpha = -(inputMaximum - inputMinimum) / 6.0
            beta = (inputMaximum + inputMinimum) / 2.0

            sigmoid = vtkvmtkSegmentation.vtkvmtkSigmoidImageFilter()
            sigmoid.SetInputData(gradientMagnitude.GetOutput())
            sigmoid.SetAlpha(alpha)
            sigmoid.SetBeta(beta)
            sigmoid.SetOutputMinimum(0.0)
            sigmoid.SetOutputMaximum(1.0)
            sigmoid.Update()
            featureImage = sigmoid.GetOutput()
        else:
            boundedReciprocal = vtkvmtkSegmentation.vtkvmtkBoundedReciprocalImageFilter()
            boundedReciprocal.SetInputData(gradientMagnitude.GetOutput())
            boundedReciprocal.Update()
            featureImage = boundedReciprocal.GetOutput()

        outImageData = vtk.vtkImageData()
        outImageData.DeepCopy(featureImage)

        return outImageData
Beispiel #54
0
    def setImage(self, dicomfile):
        logging.debug("In VTKImageView::setImage()")
        if dicomfile:
            if os.path.exists(dicomfile):
                self.reader = vtkgdcm.vtkGDCMImageReader()
                self.reader.SetFileName(dicomfile)
                self.reader.Update()

                vtkImageData = self.reader.GetOutput()
                vtkImageData.UpdateInformation()
                srange = vtkImageData.GetScalarRange()

                cast = vtk.vtkImageCast()
                cast.SetInput(vtkImageData)
                cast.SetOutputScalarType(4)
                cast.Update()
                cast.GetOutput().SetUpdateExtentToWholeExtent()

                table = vtk.vtkLookupTable()
                table.SetNumberOfColors(256)
                table.SetHueRange(0.0, 0.0)
                table.SetSaturationRange(0.0, 0.0)
                table.SetValueRange(0.0, 1.0)
                table.SetAlphaRange(1.0, 1.0)
                table.SetRange(srange)
                table.SetRampToLinear()
                table.Build()

                color = vtk.vtkImageMapToColors()
                color.SetLookupTable(table)
                color.SetInputConnection(cast.GetOutputPort())
                color.Update()

                self.cast = vtk.vtkImageMapToWindowLevelColors()
                self.cast.SetOutputFormatToLuminance()
                self.cast.SetInputConnection(color.GetOutputPort())
                self.cast.SetWindow(255.0)
                self.cast.SetLevel(127.0)
                self.cast.Update()
                self.cast.UpdateWholeExtent()

                self.render.RemoveActor(self.actor)
                self.actor = vtk.vtkImageActor()
                self.actor.SetInput(self.cast.GetOutput())
                self.render.AddActor(self.actor)
                self.render.ResetCamera()
                self.Render()
            else:
                self.render.RemoveActor(self.actor)
                self.Render()
        else:
            self.render.RemoveActor(self.actor)
            self.Render()
def GetNumPyData(filename):
  print filename
  vtiReader = vtk.vtkXMLImageDataReader()
  vtiReader.SetFileName(filename)
  vtiReader.Update()
  vtiData = vtk.vtkImageCast()
  vtiData.SetOutputScalarTypeToDouble()
  vtiData.SetInput( vtiReader.GetOutput() )
  vtiData.Update( )
  vti_image = vtiData.GetOutput().GetPointData() 
  vti_array = vtkNumPy.vtk_to_numpy(vti_image.GetArray(0)) 
  return vti_array 
Beispiel #56
0
def ProcessOneFilePublic(filename, outfilename, tmpfile):
  gdcm.ImageHelper.SetForceRescaleInterceptSlope(True)
  vtkreader = vtkgdcm.vtkGDCMImageReader()
  vtkreader.SetFileName( filename )
  vtkreader.Update()

  cast = vtk.vtkImageCast()
  cast.SetInput( vtkreader.GetOutput() )
  cast.SetOutputScalarTypeToUnsignedShort()

  # vtkGDCMImageWriter does not support Sequence, so let's write a tmp file first:
  # Some operation will actually be discarded (we simply need a temp storage)
  vtkwriter = vtkgdcm.vtkGDCMImageWriter()
  vtkwriter.SetFileName( tmpfile )
  vtkwriter.SetMedicalImageProperties( vtkreader.GetMedicalImageProperties() )
  vtkwriter.SetDirectionCosines( vtkreader.GetDirectionCosines() )
  print "Format:",vtkreader.GetImageFormat()
  vtkwriter.SetImageFormat( vtkreader.GetImageFormat() )
  vtkwriter.SetInput( cast.GetOutput() )
  #vtkwriter.Update()
  vtkwriter.Write()
  
  # ok now rewrite the exact same file as the original (keep all info)
  # but use the Pixel Data Element from the written file
  tmpreader = gdcm.ImageReader()
  tmpreader.SetFileName( tmpfile )
  if not tmpreader.Read():
    sys.exit(1)

  reader = gdcm.Reader()
  reader.SetFileName( filename )
  if not reader.Read():
    sys.exit(1)

  # Make sure to remove Slope/Rescale to avoid re-execution
  ds = reader.GetFile().GetDataSet()
  tags = [
    gdcm.Tag(0x0028,0x1052),
    gdcm.Tag(0x0028,0x1053),
    gdcm.Tag(0x0028,0x1053),
  ]
  for tag in tags:
    ds.Remove( tag )

  writer = gdcm.ImageWriter()
  writer.SetFileName( outfilename )
  # Pass image from vtk written file
  writer.SetImage( tmpreader.GetImage() )
  # pass dataset from initial 'reader'
  writer.SetFile( reader.GetFile() )
  if not writer.Write():
    sys.exit(1)
def GetNumpyPhaseData(filename):
  vtkReader = vtkImageReader() 
  vtkReader.SetFileName(filename) 
  vtkReader.Update() 
  vtkImageCast = vtk.vtkImageCast()
  vtkImageCast.SetOutputScalarTypeToDouble()
  vtkImageCast.SetInput( vtkReader.GetOutput() )
  vtkImageCast.Update( )
  phase_image = vtkImageCast.GetOutput().GetPointData() 
  # convert to phase
  phase_array =  vtkNumPy.vtk_to_numpy(phase_image.GetArray(0)) 
  #return (2.0 * numpy.pi / 4095. ) *phase_array 
  return phase_array.reshape(dimensions,order='F')