# VTKWithNumpy

VTKExamples/Python/Utilities/VTKWithNumpy

### Code

VTKWithNumpy.py

    # An example from scipy cookbook demonstrating the use of numpy arrays in vtk

    import numpy as np
    import vtk

    def main():
        colors = vtk.vtkNamedColors()

        # We begin by creating the data we want to render.
        # For this tutorial, we create a 3D-image containing three overlaping cubes.
        # This data can of course easily be replaced by data from a medical CT-scan or anything else three dimensional.
        # The only limit is that the data must be reduced to unsigned 8 bit or 16 bit integers.
        data_matrix = np.zeros([75, 75, 75], dtype=np.uint8)
        data_matrix[0:35, 0:35, 0:35] = 50
        data_matrix[25:55, 25:55, 25:55] = 100
        data_matrix[45:74, 45:74, 45:74] = 150

        # For VTK to be able to use the data, it must be stored as a VTK-image.
        #  This can be done by the vtkImageImport-class which
        # imports raw data and stores it.
        dataImporter = vtk.vtkImageImport()
        # The previously created array is converted to a string of chars and imported.
        data_string = data_matrix.tostring()
        dataImporter.CopyImportVoidPointer(data_string, len(data_string))
        # The type of the newly imported data is set to unsigned char (uint8)
        dataImporter.SetDataScalarTypeToUnsignedChar()
        # Because the data that is imported only contains an intensity value
        #  (it isnt RGB-coded or someting similar), the importer must be told this is the case.
        dataImporter.SetNumberOfScalarComponents(1)
        # The following two functions describe how the data is stored and the dimensions of the array it is stored in.
        #  For this simple case, all axes are of length 75 and begins with the first element.
        #  For other data, this is probably not the case.
        # I have to admit however, that I honestly dont know the difference between SetDataExtent()
        #  and SetWholeExtent() although VTK complains if not both are used.
        dataImporter.SetDataExtent(0, 74, 0, 74, 0, 74)
        dataImporter.SetWholeExtent(0, 74, 0, 74, 0, 74)

        # The following class is used to store transparency-values for later retrival.
        #  In our case, we want the value 0 to be
        # completely opaque whereas the three different cubes are given different transparency-values to show how it works.
        alphaChannelFunc = vtk.vtkPiecewiseFunction()
        alphaChannelFunc.AddPoint(0, 0.0)
        alphaChannelFunc.AddPoint(50, 0.05)
        alphaChannelFunc.AddPoint(100, 0.1)
        alphaChannelFunc.AddPoint(150, 0.2)

        # This class stores color data and can create color tables from a few color points.
        #  For this demo, we want the three cubes to be of the colors red green and blue.
        colorFunc = vtk.vtkColorTransferFunction()
        colorFunc.AddRGBPoint(50, 1.0, 0.0, 0.0)
        colorFunc.AddRGBPoint(100, 0.0, 1.0, 0.0)
        colorFunc.AddRGBPoint(150, 0.0, 0.0, 1.0)

        # The previous two classes stored properties.
        #  Because we want to apply these properties to the volume we want to render,
        # we have to store them in a class that stores volume properties.
        volumeProperty = vtk.vtkVolumeProperty()
        volumeProperty.SetColor(colorFunc)
        volumeProperty.SetScalarOpacity(alphaChannelFunc)

        volumeMapper = vtk.vtkFixedPointVolumeRayCastMapper()
        volumeMapper.SetInputConnection(dataImporter.GetOutputPort())

        # The class vtkVolume is used to pair the previously declared volume as well as the properties
        #  to be used when rendering that volume.
        volume = vtk.vtkVolume()
        volume.SetMapper(volumeMapper)
        volume.SetProperty(volumeProperty)

        # With almost everything else ready, its time to initialize the renderer and window, as well as
        #  creating a method for exiting the application
        renderer = vtk.vtkRenderer()
        renderWin = vtk.vtkRenderWindow()
        renderWin.AddRenderer(renderer)
        renderInteractor = vtk.vtkRenderWindowInteractor()
        renderInteractor.SetRenderWindow(renderWin)

        # We add the volume to the renderer ...
        renderer.AddVolume(volume)
        renderer.SetBackground(colors.GetColor3d("MistyRose"))

        # ... and set window size.
        renderWin.SetSize(400, 400)

        # A simple function to be called when the user decides to quit the application.
        def exitCheck(obj, event):
            if obj.GetEventPending() != 0:
                obj.SetAbortRender(1)

        # Tell the application to use the function as an exit check.
        renderWin.AddObserver("AbortCheckEvent", exitCheck)

        renderInteractor.Initialize()
        # Because nothing will be rendered without any input, we order the first render manually
        #  before control is handed over to the main-loop.
        renderWin.Render()
        renderInteractor.Start()

    if __name__ == '__main__':
        main()