Molecules in Blender

tl;dr – A github repo containing all of this and much more can be found here. Follow the readme to use.

As a whole, science and technology have made incredible advancements in aesthetics. Programming presentations are succinct, biologists have made videos like this and this, and physicists can point to, like, every image of space ever taken.

However, most chemistry graphics look like they were thrown together by a toddler. I understand the sentiment behind this – “it’s the science that matters”, “I can’t waste time learning how to do this”, blah blah blah. While that’s kind of true, no one will even read your paper if it has these graphics. Seriously, anything short of a cure for cancer will be skimmed over if it isn’t visually appealing. You’ve spent months to years working toward a paper; you can afford yourself a week or two to make your graphics not look like crap.

As my inaugural scientific visualization post, let’s start with one of the most common visualization tasks for chemists. I will show you how to easily draw any molecule in blender.

What people are doing

The typical approach involves Powerpoint (or Photoshop/GIMP for the more artistically inclined) and a 3D molecule renderer like JMol. This approach is easy to learn and produces graphics that meet the industry standard. Let’s take an example molecule – caffeine – and work through the process.

First, we get the molecular structure from wikipedia or the nearest nerdy coffee mug (ie. why I chose this example). It looks like this:

Next, we download JMol and optimize / render the structure, giving us this:

God, that’s awful. From here, we make the black background transparent and copy and paste it around a coffee mug or something.

Pictured: Scientific art, 2012.

Now, you submit this graphic to Nature or Science with your manuscript. When you get your reviewer comments, there’s a good chance they will be harsh and almost nonsensical. Why? Because no one actually read your work. They saw no pretty pictures, which means they didn’t read any of it in depth, which then caused the aforementioned comments. It’s not fair by any means, but you can’t really blame them. It’s exactly what you would do if you were told to critique a pile of manuscripts.

A better approach

Enter Blender, an open-source 3D modeling program with the most active community of developers I have seen outside of Ubuntu. With training, it can be used to create movie-quality computer graphics. With almost no training, it can still produce scientific visualizations orders of magnitude better than what’s currently out there. The best part is its incredibly organized Python API, which makes it easy to automate repetitive tasks.

Blender works like most 3D graphical editors. We draw primitive objects (ie. spheres, cylinders, etc.), overlay them with materials and textures, and adjust our viewport and lighting. In order to draw molecules without adding shapes by hand, we need to use Python for some heavy automation.

Parsing molecules

First, let’s look into how we will want to specify chemical structures. The world of chemistry is littered with terrible file formats, and, due to the general resilience of legacy standards, we will need to consider them. Before we get to that, however, let’s decide upon a good extensible representation of molecular data. The common representation used in coding is called JavaScript Object Notation, or json, and it is very good at succinctly representing arbitrary data. If you’ve never heard of it before, I highly recommend reading up on it before continuing. Here’s the wiki.

As molecules are a subset of “arbitrary data”, json should suit our needs. Our drawer will need atom element types and 3D locations, and bond connections and orders. Therefore, let’s use something like shown below (the example is for ethane).

This is easy to parse in Python -  import json; data = json.loads(string) . In two lines, we now have a Python data structure! If we wanted to print, say, the y coordinate of the first atom, we could do so with  print(data["atoms"][0]["location"][1]) . This will come in handy later.

Now, back to the matter at hand. We want to offer support for the hundreds of file formats out there (molfiles, smiles, sdf, cif, pdb, etc.), but parsing them all is an absolute nightmare. In a previous version of this post, I recommended parsing a molfile directly. I now take that back. That was stupid. Let’s use Pybel, a Python wrapper on the openbabel library. Download it, and then we can unify all of these file formats in one line of code -  molecule = pybel.readstring(format, string) . If there is no positional data in the input file format, we can generate it by simply calling  molecule.make3D() .

Now, if we can convert this unified format to json, we will have a unified data format without needing to write any more parsing logic.

There is some additional messiness in the github repository to handle corner cases, but this function should generally work.

Converting from the molecule object to json will help us out in many ways. For example, we can test the quality of our file format converter without even needing to involve blender (it’s better to debug code in isolated chunks than it is to debug the whole thing). If your script is creating valid json, then it should load into this website without any problems. Cool, right?

Remembering that the task at hand was to create a caffeine molecule, let’s do so. I’m partial to the SMILES representation of small molecules, which can be found all over the internet. Caffeine’s SMILES is O=C1C2=C(N=CN2C)N(C(=O)N1C)C, which can be loaded directly into our pipeline.

This will create a file called “caffeine.json” that will reflect the json example shown above. (Note: in the sample code shown here, the json will be printed on one line without most of its whitespace. If you want to add whitespace back in, add indent=4 to the  json.dumps(...)  method in the converter.)

With a single data format and no more need of external libraries, we are ready to use Blender!

Python in Blender

Using Python in Blender requires a bit of explanation. While its API is through a Python package, this library only works in Blender’s own script editor (there are workarounds that I’m not getting in to… let’s use Blender the way the developers intended). Rather than thinking of Blender as a Python library, think of Python like a feature of Blender. Backwards, I know, but it makes sense when you start using it. Start up Blender, click and drag the top right tab to create multiple windows, and then select the text editor. Repeat to add in a Python console.

That’s it. You have your Python editor directly in Blender.

As you become comfortable with 1. your terminal (especially on mac/linux) and 2. Blender, you can now run Blender Python scripts directly in a terminal. Typing  blender -P my_script.py will open a new Blender window with the results of the script loaded. However, for the sake of learning, I recommend following the previous approach for at least a little while.

All example renders shown below were done with no lamps. I used ambient occlusion with environment lighting. This produces good results in this example with minimal work on our part. (To copy this setup, click the little globe in the right-hand panel. There will be checkboxes for both of these options.)

Drawing atoms

We’re already starting to see the shape of the molecule forming, and we can see Blender’s awesome rendering capabilities. With nothing more than a few spheres, the molecule is looking pretty good. For the next step, let’s reduce the size of the atoms and add in bonds.

Drawing Bonds

It’s getting close. Before moving forward, let’s add in support for double and triple bonds. This will require the ability to translate cylinders orthogonal to their current direction. With our previous vector math, this should be easy. Let’s make translation rules for each type of bond, and then use those as needed.

We create a list of translation vectors based on the number of bonds that exist. For single and triple bonds, one cylinder remains unmoved. All other bonds are in the direction of the local object axis, with the constants of 1.4 and 2.0 chosen as separation values. Adding this results in, well, exactly what you’d expect.