DICOM in Python: Importing medical image data into NumPy with PyDICOM and VTK


I’ll be showing how to use the pydicom package and/or VTK to read a series of DICOM images into a NumPy array. This will involve reading metadata from the DICOM files and the pixel-data itself.

Introduction: The DICOM standard

Anyone in the medical image processing or diagnostic imaging field, will have undoubtedly dealt with the infamous Digital Imaging and Communications in Medicine (DICOM) standard the de-facto solution to storing and exchanging medical image-data.

Applications such as RadiAnt or MicroDicom for Windows and OsiriX for Mac, do a great job of dealing with DICOM files. However, there are as many flavors of DICOM as there are of ice-cream. Thus, when it comes to programmatically reading and processing DICOM files things get a little hairier depending on whether the files store the pixel data in a compressed form or not.

In this post I will show how to read in uncompressed DICOM file series through either the pydicom package or VTK. Take a look at the Resources section for tips on how to tackle compressed DICOM files.

DICOM Datasets

There’s a wealth of freely available DICOM datasets online but here’s a few that should get you started:

Despite the fact that its easy to get DICOM datasets, most databases forbid their re-distribution by third parties. Therefore, for the purposes of these posts I decided to use a dataset from an MR examination of my own fat head. You can find a .zip file with with .dcm files on the sagittal plane here. In order to follow this post extract the contents of this file alongside the IPython Notebooks, the contents of which I’ll be presenting in the pydicom Usage section and the VTK Usage section.

The pydicom package

In this, first of two posts I will show how to use the pydicom package, which consists of pure-python code, is hosted on pypi, and can be easily installed through pip as such:

pip install pydicom

As is often the case with many Python packages, while this package is called pydicom it simply goes by dicom within Python and needs to be imported with import dicom.

Usage

In this example I’m gonna use the MR dataset of my own head, discussed in the DICOM Datasets section, and the pydicom package, to load the entire series of DICOM data into a 3D NumPy array and visualize two slices through matplotlib. You can find the entire IPython Notebook here.

Obviously we’ll start with importing the packages we’ll need:

import dicom
import os
import numpy
from matplotlib import pyplot, cm

The only point of interest here is, as I mentioned in the The pydicom package section, that the pydicom package is imported as dicom so be careful with that. Next we use os.path.walk to traverse the MyHead directory, and collect all .dcm files into a list named lstFilesDCM:

PathDicom = "./MyHead/"
lstFilesDCM = []  # create an empty list
for dirName, subdirList, fileList in os.walk(PathDicom):
    for filename in fileList:
        if ".dcm" in filename.lower():  # check whether the file's DICOM
            lstFilesDCM.append(os.path.join(dirName,filename))

If you check the MyHead folder you’ll see that the .dcm files are named MR000000.dcm, MR000001.dcm, etc. Therefore, the walk function will return them in order since they’re sorted lexicographically by the OS. However, in many cases DICOM files don’t have all those leading zeros, with names like MR1, MR2, etc which would result in lstFilesDCM having the filenames ordered in a fashion such as MR1, MR10, MR100, etc. Since, the typical sorting functions in python, such as sorted and the sort method of list objects (docs here), are lexicographical as well (unless dealing with pure numbers), I strongly suggest using the very useful natsort package which can be found on PyPI here (and can be installed with a simple pip install natsort).

Now, lets get into the pydicom part of the code. A notable aspect of this package is that upon reading a DICOM file, it creates a dicom.dataset.FileDataset object where the different metadata are assigned to object attributes with the same name. We’ll see this below:

# Get ref file
RefDs = dicom.read_file(lstFilesDCM[0])

# Load dimensions based on the number of rows, columns, and slices (along the Z axis)
ConstPixelDims = (int(RefDs.Rows), int(RefDs.Columns), len(lstFilesDCM))

# Load spacing values (in mm)
ConstPixelSpacing = (float(RefDs.PixelSpacing[0]), float(RefDs.PixelSpacing[1]), float(RefDs.SliceThickness))

In the first line we load the 1st DICOM file, which we’re gonna use as a reference named RefDs, to extract metadata and whose filename is first in the lstFilesDCM list. We then calculate the total dimensions of the 3D NumPy array which are equal to (Number of pixel rows in a slice) x (Number of pixel columns in a slice) x (Number of slices) along the x, y, and z cartesian axes. Lastly, we use the PixelSpacing and SliceThickness attributes to calculate the spacing between pixels in the three axes. We store the array dimensions in ConstPixelDims and the spacing in ConstPixelSpacing.

If you were to open one of the DICOM files with an application such as the ones mentioned in the Intro section and checked the metadata you’d see that Rows, Columns, PixelSpacing, and SliceThickness are all metadata entries. pydicom simply creates attributes with the same names and assigns appropriate values to those, making them easily accessible.

The next chunk of code is:

x = numpy.arange(0.0, (ConstPixelDims[0]+1)*ConstPixelSpacing[0], ConstPixelSpacing[0])
y = numpy.arange(0.0, (ConstPixelDims[1]+1)*ConstPixelSpacing[1], ConstPixelSpacing[1])
z = numpy.arange(0.0, (ConstPixelDims[2]+1)*ConstPixelSpacing[2], ConstPixelSpacing[2])

where we simply use numpy.arange, ConstPixelDims, and ConstPixelSpacing to calculate axes for this array. Next, comes the last pydicom part:

# The array is sized based on 'ConstPixelDims'
ArrayDicom = numpy.zeros(ConstPixelDims, dtype=RefDs.pixel_array.dtype)

# loop through all the DICOM files
for filenameDCM in lstFilesDCM:
    # read the file
    ds = dicom.read_file(filenameDCM)
    # store the raw image data
    ArrayDicom[:, :, lstFilesDCM.index(filenameDCM)] = ds.pixel_array  

As you can see, what we do here is first create a NumPy array named ArrayDicom with the dimensions specified in ConstPixelDims calculated before. The dtype of this array is the same as the dtype of the pixel_array of the reference-dataset RefDs which we originally used to extract metadata. The point of interest here is that the pixel_array object is a pure NumPy array containing the pixel-data for the particular DICOM slice/image. Therefore, what we do next is loop through the collected DICOM filenames and use the dicom.read_file function to read each file into a dicom.dataset.FileDataset object. We then use the pixel_array attribute of that object, and toss it into ArrayDicom, stacking them along the z axis.

And that’s it! Using the pyplot module in matplotlib we can create a nice lil’ plot as such:

pyplot.figure(dpi=300)
pyplot.axes().set_aspect('equal', 'datalim')
pyplot.set_cmap(pyplot.gray())
pyplot.pcolormesh(x, y, numpy.flipud(ArrayDicom[:, :, 80]))

which results in the following image:

A plot of my heads DICOM data

Reading DICOM through VTK

Now while skimming the previous section you might have thought ‘pfff that’s way too easy, why did we bother reading your rants?’. Well, in the interest of keeping you interested, I decided – against my better judgement – to provide the VTK approach to the above process.

Usage

You can find a separate notebook here, while I’ll be using the same dataset. Make sure to check that notebook cause I’ll only be detailing the VTK parts of the code here. You will find that the VTK solution is quite a bit more succinct. Now let’s start with reading in the series of .dcm files:

PathDicom = "./MyHead/"
reader = vtk.vtkDICOMImageReader()
reader.SetDirectoryName(PathDicom)
reader.Update()

As you can see, unlike the approach in the previous section, here we saved ourselves the two loops, namely populating the filename list, and reading in the data slice-by-slice. We first create a vtkDICOMImageReader object (docs here), and pass the path to the directory where all the .dcm files are through the SetDirectoryName method. After that, its just a matter of calling the Update method which does all the reading. If you were dealing with huge datasets, you’d be surprised how much faster than pydicom VTK does that.

Don’t let the above approach fool you entirely. It worked only cause the OS sorted the files correctly by itself. As I mentioned in the previous section, if the files weren’t properly named, lexicographical sorting would have given you a messed up array. In that case you would either need to loop and pass each file to a separate reader through the SetFileName method, or you’d have to create a vtkStringArray, push the sorted filenames, and use the vtkDICOMImageReader.SetFileNames method. Keep your eyes open! VTK is not forgiving 🙂

Next we need access to the metadata in order to calculate those ConstPixelDims and ConstPixelSpacing variables:

# Load dimensions using `GetDataExtent`
_extent = reader.GetDataExtent()
ConstPixelDims = [_extent[1]-_extent[0]+1, _extent[3]-_extent[2]+1, _extent[5]-_extent[4]+1]

# Load spacing values
ConstPixelSpacing = reader.GetPixelSpacing()

As you can see, the vtkDICOMImageReader class comes with a few useful methods that provide the metadata straight-up. However, only a few of those values are available in a straightforward manner. Thankfully, by using the GetDataExtent method of the reader we get a 6-value tuple with the starting and stopping indices of the resulting array on all three axes. Obviously, that’s all we need to calculate the size of the array. Getting the pixel-spacing is even easier than with pydicom and simply accomplished with the GetPixelSpacing method.

Now, onto the fun part :). You might have read my previous post on how to convert arrays between NumPy and VTK. You might have thought that we can use that functionality and get a nice NumPy array with a one-liner. Well, I hate to disappoint you but it’s not that straightforward (remember, VTK).

If you dig a little into the vtkDICOMImageReader docs, you will see that it inherits vtkImageReader2, which in turn inherits vtkImageAlgorithm. The latter, sports a GetOutput method returning a vtkImageData object pointer. However, the numpy_support.vtk_to_numpy function only works on vtkArray objects so we need to dig into the vtkImageData object till we get that type of array. Here’s how we do that:

# Get the 'vtkImageData' object from the reader
imageData = reader.GetOutput()
# Get the 'vtkPointData' object from the 'vtkImageData' object
pointData = imageData.GetPointData()
# Ensure that only one array exists within the 'vtkPointData' object
assert (pointData.GetNumberOfArrays()==1)
# Get the `vtkArray` (or whatever derived type) which is needed for the `numpy_support.vtk_to_numpy` function
arrayData = pointData.GetArray(0)

# Convert the `vtkArray` to a NumPy array
ArrayDicom = numpy_support.vtk_to_numpy(arrayData)
# Reshape the NumPy array to 3D using 'ConstPixelDims' as a 'shape'
ArrayDicom = ArrayDicom.reshape(ConstPixelDims, order='F')

As you can see, we initially use reader.GetOutput() to get a vtkImageData object pointer into imageData. We then use the GetPointData method of that object to ‘extract’ a vtkPointData object pointer into pointData. Now, these vtkPointData may hold multiple arrays but we should only have one in there (being the entirety of the DICOM data). Since these ‘internal’ arrays are numerically indexed, we get this vtkArray through index 0 so the array we were looking for can be retrieved through arrayData = pointData.GetArray(0). We can now finally ‘convert’ that pesky array to NumPy through vtk_to_numpy and store it in ArrayDicom. As a final step, we reshape that array using ConstPixelDims et voila!

From that point, we use our lovely NumPy array and get the same plots we got with the previous approach.

Note that we reshape ArrayDicom with a ‘Fortran’ order. Don’t ask me why, but when I tried to reshape in C order I got misaligned rubbish so there. Trial-n-error.

Resources

Should you want to learn more about pydicom do check the project’s official website, its wiki, and its user guide.

‘Whoa’ you might say though, what about those JPEG-based compressed DICOM files you mentioned in the intro?. Well unfortunately, neither pydicom, nor the admittedly convenient vtkDICOMImageReader class can handle those. At least, the pydicom package will warn you and return a NotImplementedError upon reading such a DICOM file, while VTK will just return an array full of 0s and leave you wondering. At this point I can only think of two viable solutions to this:

  • Go the hardcore route, install the GDCM library with Python bindings on your system, and use the mudicom package to handle it in Python. GDCM is a breeze to install on Windows and Linux systems as it provides pre-compiled binaries for those. You should also be able to install it on Mac using Homebrew and this recipe but I haven’t tested it yet.
  • Go the cheater’s route, or as I like to call it the lazy engineer’s route. Simply open that data in one of the applications mentioned in the Intro, such as OsiriX, and save it as uncompressed DICOM (yes you can do that).

Anyway, enough for today, hope you’ve learned enough to start butchering medical image data on your own, as there are a million awesome things you can do with those. We’ll see a few nifty things in subsequent posts. Next up, I’m going to regale you with bone-chilling tales of marching-cubes and surface extraction :). Thanks for reading!

Advertisements

40 thoughts on “DICOM in Python: Importing medical image data into NumPy with PyDICOM and VTK

  1. Pingback: Surface Extraction: Creating a mesh from pixel-data using Python and VTK | PyScience

  2. Thanks for this document.

    FYI: in an attempt to work with compressed DICOM, I found that the GDCM recipe for Homebrew was lacking an option for the python bindings. I ended up contributing it myself, and am waiting for Homebrew/homebrew-science to accept the pull-request.

    In the meantime, this should get it installed:

    brew install https://raw.githubusercontent.com/bollig/homebrew-science/0e20fd89055dc23be36ed745ce918b2d5cfb3a00/gdcm.rb –with-python3

    Test with:

    python3 -c ‘import gdcm’

    Cheers,
    -E

    Like

    • Hey Evan,

      thanks a lot for the link, GDCM is definitely the answer to all the funky DICOM files out there.

      In my upcoming post I’m going to talk about SimpleITK which comes with GDCM out-of-the-box and allows for easy reading of compressed DICOM (tested it on Osirix datasets that wouldn’t play well with PyDICOM or VTK). Post is coming out in a few days 🙂

      Thanks for reading!
      Adam

      Like

      • Hello Adam,

        I would really appreciate your post about reading and also displaying compressed DICOM images using SimpleITK in Python. I am new in Python and I am on the crossroad whether to dive in Python and start to use it as a main programming langue instead of Matlab or not. Main issue for me is an easy way to work with DICOM images. So far I came to problem with compressed DICOM images, so I am waiting for your post:-)

        Thanks!

        Petr

        Like

      • Hey Petr! I’m not going to start the age-old Python vs Matlab flame war cause I’m terribly biased towards the former (Python rules!). The next post is coming out in a couple days (Monday morning, Melbourne time) cause I still need to revise the text a bit :). Just follow the blog via email and you’ll get a notification when it’s out :). Thanks for reading! I hope I’ll manage to win you over to our side 😀

        Like

  3. Pingback: Image Segmentation with Python and SimpleITK | PyScience

  4. Pingback: Multi-Modal Image Segmentation with Python & SimpleITK | PyScience

  5. Nice post, again 🙂

    Only, to display the slice with pyplot, a pyplot.show() is missing below.

    Thanks for your crystal-clear explanations!

    Like

    • Actually by using `@matplotlib inline` you should get the plot directly as the cell output. However, that depends on the version/behavior of the IPython Notebook version. I can’t quite vouch for the behavior of the 3.0.x version that came out recently

      Thanks for reading 🙂

      Like

    • Haha I’m really glad you’ve found it useful! The reason I wrote posts like this was cause I wished someone had done so back in the day when I was struggling with stupid DICOM :). Thanks for reading!

      Like

  6. Hi Adam,

    Thanks for such informative. It’s really good starter for freshers like me.

    Well my scenario something different.
    I’m going to create a search for this dicom images (like when you type specific ‘word’ it will retentive all the dicom(using metadata) images which has this word).

    Here i need to create a (.xml or .json) file for each .dcm file and store all (.xml or .json) files in one directory. Later i will index entire directory using solr to create.

    Can you please help me how i can convert each (.dcm file metadata into .xml or .json) and store them.

    Appreciate your help.

    Thanks
    Karthik Vadla

    Like

    • Sounds like an interesting startup idea 🙂

      Well you can easily use PyDicom to read the metadata and then simply toss them into a Python dictionary and subsequently JSON file. As you can see under https://code.google.com/p/pydicom/wiki/PydicomUserGuide all DICOM attributes are read as key-value pairs.

      Also you shouldn’t have to read all DICOM files in a series as they typically share metadata between slices. If not I would simply concatenate the results and have lists of dictionaries of nested dictionaries.

      However, I wonder how much information you think you can draw from DICOM metadata. Most doctors are very lazy and don’t input much information in the imaging systems. Thus, I haven’t seen many DICOM sets where you could search for “hypothalamic carcinoma” and get back any matches. Good luck nonetheless though 🙂

      Like

  7. Great tutorial.
    I’m have been trying to generate a new set of DICOM files after manipulating the original dataset with pydicom. I noticed a compatibility problem with Python3. I wonder if you have faced the same problem.

    pydicom was initially written for Python2.6-7. In Python2.6-7 has a string datatype str which represents both 8-bit text and binary data. In Python3 str only represents the 8-bit text.
    The module filewriter in pydicom has a lot of writing statements for the metadata and the preamble which mixes the two types and produces lots of error statements.
    I have not found a work around for this problem yet. If you have run into this problem before, please let me know how did you get it to work.

    Thanks

    Like

    • Hi there, unfortunately I haven’t used pydicom in Python3. Actually, I do 99% of my work in Python 2 predominantly due to compatibility issues like the one you’ve described. The errors you’re describing sound entirely reasonable given that Python3 entirely revamped the way it handles strings.

      however, it would seem that the newest version of pydicom supports Python3 as stated under https://github.com/darcymason/pydicom/wiki/Porting-to-pydicom-1.0. If you’re using the PyPI version (current version being v0.9.9) it still says that a lot of Python3 issues have been resolved. Are you on the newest version? If you are and still getting said issues you may want to use an up-to-date dev version straight off the Git repo (https://github.com/darcymason/pydicom)

      Hope you work it out 🙂

      Like

      • Hi,

        Thanks for the quick response. I’m actually using the latest dev version of pydicom. I think I should report it to the development team.

        Also, I have tried converting Numpy array to binary before passing the array to pydicom-write routine but it failed to write the array to the output file. I will post here if I find a solution to this problem.

        HKS

        Liked by 1 person

  8. Hi Somada,

    I finally got it to work and I thought I should put this here. I have been using conda for python package handling. The current conda/pip does not supply pydicom1.0. I worked around it and after getting conda to install the latest dev version of pydicom1.0 it works fine.

    HKS

    Like

    • Oh awesome that’s good to know. I’m a little surprised it took fiddling with conda to get it to install, I mean conda doesn’t have compiled versions of all latest packages but it still supports pip, but at least you fixed it. Kudos!

      Like

  9. Hi, many thanks for your blog post.

    Couldn’t you just have done this to display an image (requires import pylab)?

    RefDs = dicom.read_file(lstFilesDCM[0])
    pylab.imshow(RefDs.pixel_array, cmap=pylab.cm.bone)
    pylab.show()

    Like

    • Yeah probably to an extent but you’re missing the axes so if you have different spacing along different directions the image would appear squished/stretched. Nonetheless I’m sure there’s a dozen ways to display it 🙂

      Like

      • Sorry, in hindsight, my comment seems depreciatory. I am not playing on your level at all but I would consider myself a novice. I just wanted to know the rationale behind it since I am playing with the current Kaggle competition which is based on DICOM images.

        Like

      • Haha no worries, no offense taken whatsoever. I’m not trying to come across like a guru anyway so I don’t mind constructive criticism :). Good luck on the Kaggle competition btw, I’ll check out the topic but I’m too lazy to commit to competing :p

        Like

  10. It is really helpful. Thank you.

    I have one question, I’ve wrote a code that convert dicom images to jpg and then encrypt the jpg file. The decryption part will save the output as jpg. is there any methods to save it back as dcm?

    Like

  11. Hi, what is actually 80 in “pyplot.pcolormesh(x, y, numpy.flipud(ArrayDicom[:, :, 80]))”. When I use it I get an error: IndexError: index 80 is out of bounds for axis 2 with size 1. Is it the size of photos you have? Should it be len(lstFilesDCM)-1?

    Irma

    Like

    • I meant number of photos, not size. By the way, thank you for the post. I don’t fully understand how to manipulate the dcm format in python, but this helped me in getting the png format for some further visualizations.

      Irma

      Like

    • hey irma, the `80` is merely the 81st slice (along the Z-axis) of the DICOM dataset I used and loaded into `ArrayDicom`. Obviously is you used your dataset and didn’t account for the different dimensions, i.e., the number of pixels along the x-y axes and number of slices along the z-axis you’ll get the error you did get. Check your dimensions with `ArrayDicom.shape` and that should get you on the right path 🙂

      Like

  12. Good morning, nice article. I’ve been working only with PNG/JPEG images for Head CT, but at this time I need to work with DICOM files and it has been a pain. I’ve been studying the pydicom module for some weeks and I had a really mess with this all. Until now, I used the DicomLibrary platform for opening DICOM files.

    After a file is open, you can switch between two windowing: default and auto. Automatic windowing is the result I get from the algorithm you wrote. But I would like to get the result by applying the Default windowing. I’ve gone to the matplot lib colormap reference, but that couldn’t help.

    Do you know how what that works? Better, how can I get the results I can see searching “Head CT” images in the web?

    Another thing, I would like to save the result I get from the pyplot (I use pyplot.savefig(PathDicom + “foo.png”) after your last code), but I always get the axes, a few values in the axes, a big white border and at the middle the result I want to save. Do you know how can you get only the result?

    Like

    • hey there,

      re the figure saving what you’re doing there isn’t saving the figure you plotted but creating and saving an empty figure. The `savefig` method needs to be applied to the figure you created and plotted upon, e.g., http://matplotlib.org/faq/howto_faq.html#save-transparent-figures

      Now for the windowing I honestly have no idea what you’re trying to achieve, are we talking about a different colormap or an actual windowing of the voxel intensity values?

      Like

    • I use this method to save the image based on the code above (without axes). Mind that I here also rescale them to a new_size, img2 is the orginal image but cropped to the new size. So you can just use your original image, and new_size equal to the size of your image. Sorry I don’t have much time to modify, but some .axis(‘off’) might be important for your problem of having axes.

      def save_image(output_image_path,im_dcm,img2,new_size,label):
      ConstPixelDims = (int(im_dcm.Rows), int(im_dcm.Columns), 1)
      ConstPixelSpacing = (float(im_dcm.PixelSpacing[0]), float(im_dcm.PixelSpacing[1]), float(im_dcm.SliceThickness))
      spacing_x=ConstPixelSpacing[0]
      spacing_y=ConstPixelSpacing[1]
      x = numpy.arange(0.0, (new_size+1)*spacing_x, spacing_x)
      y = numpy.arange(0.0, (new_size+1)*spacing_y, spacing_y)
      array_drawn=image2pixelarray(img2)

      fig = pyplot.figure(figsize=(new_size*0.01,new_size*0.01))
      pyplot.axis(‘off’)
      pyplot.set_cmap(pyplot.gray())

      pyplot.gca().set_axis_off()
      pyplot.subplots_adjust(top = 1, bottom = 0, right = 1, left = 0, hspace = 0, wspace = 0)
      pyplot.margins(0,0)
      pyplot.gca().xaxis.set_major_locator(pyplot.NullLocator())
      pyplot.gca().yaxis.set_major_locator(pyplot.NullLocator())

      res=pyplot.pcolormesh(x, y, numpy.flipud(array_drawn[:,:]))
      print “Saving: “,output_image_path
      pyplot.savefig(output_image_path,bbox_inches=’tight’,pad_inches=0)

      pyplot.close(fig)
      pyplot.clf()
      pyplot.cla()

      Like

    • Good morning, I’ve already solved my problem. Basically is what user irma wrote: the code somada141 wrote before the sagittal plane of the head, I put:
      ————————————————————————————————-
      pyplot.figure(dpi=2000) #2250
      pyplot.axes().set_aspect(‘equal’, ‘datalim’)
      pyplot.axis(‘off’)
      pyplot.set_cmap(pyplot.gray())

      for dicomIndex in range(0, len(lstFilesDCM)):
      pyplot.pcolormesh(x, y, numpy.flipud(ArrayDicom[:, :, dicomIndex]))
      pyplot.pcolormesh(x, y, vec)

      # Get the created image
      file1 = PathDicom + “tmp.png”
      file2 = PathDicom + “foo.png”
      pyplot.savefig(file1, bbox_inches=’tight’, pad_inches=0)
      im = Image.open(file1)
      # remove pyplot borders
      bg = Image.new(im.mode, im.size, im.getpixel((0,0)))
      diff = ImageChops.difference(im, bg)
      diff = ImageChops.add(diff, diff, 2.0, -100)
      bbox = diff.getbbox()
      if bbox:
      # Create and initialize the auto windowing
      img2 = im.crop(bbox)
      os.unlink(file1)

      final = numpy.array(img2)
      ————————————————————————————————-
      But then I wasn’t getting the results I wanted. I used RadiAnt and DicomLibrary for opening DICOM files and the results I get from both are a lot different. The solution I found for this problem was here: https://github.com/pieper/pydicom/blob/master/source/dicom/contrib/pydicom_Tkinter.py

      With the code wrote there, I can get the image I need in the default window. Hope this helps another users with the same problem as I.

      Like

  13. Hi,

    I have to make a GUI for Image registration, where there will be one window for reference image, another is moving image window. The image files are DICOM or NIFTI. I will be putting one slider to view different slices and another window to show the results after registration. The registration code, I have written in Python. Please suggest what to use for this GUI. I have tries pyQt, but there is no api for reading images and display it to window.

    Thanks

    Like

    • Ok so I’m no means a subject-matter-expert when it comes to GUIs, (1) cause I hate them and (2) cause I never learned how to make them properly which leads me to hate them. That being said I know that there’s a way to integrate Qt and VTK so that’d be the way I’d go about it. There’s already several projects out there integrating the two for pretty much what you’re doing now. Googs’ your friend 😀

      Like

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s