What tools (or self-rolled code) do people prefer when making big publishable figures of spectra?  The example given was an echelle spectrum, where the spectrum is loooong, and has many spectral orders to stack onto one or more pages of the journal.

Since this is a shamelessly self-generated Ask AstroBetter, I will award a beer for the best answer (or source code.)

Here’s a common workflow:  ”I want to overplot a curve from the literature on my new plot.  I could write the author and wait several days for them to dig up the plot file and send me the digitized version, but I want to compare now!” One solution is to digitize the published plot.

I used to use Dexter, but now I’m in love with GraphClick ($8, shareware.)  Just screengrab the plot, paste it

Matthew K. sent in a question for our Ask AstroBetter series:

What vector graphics drawing package do you use for your figures?

I’ve been using xfig for all my “hand drawn” plots, but I wonder if anyone has successfully moved on to more recent drawing packages … [a package] to draw simple figures like optical layouts or circuit diagrams, where freehand drawing is not good enough and you want text boxes with aligned text in them, something similar to Inkscape.

Ideally, Matthew would like the package to

• have binary/compilable versions for all major platforms
• be able to organize each item in a layer
• snap items to grids of definable size
• include other graphics (both vector and pixel) as input elements
• export to PS/PDF

While IDL does support math equations and symbols—often made easier by routines like sunsymbol.pro and textoidl.pro—the results are not aesthetically pleasing. One particular instance that has annoyed many of us astronomers has been the sunsymbol (⦿).

The available solutions are not ideal: the dot inside the circle is off-center in sunsymbol.pro, the vertical alignment is off in textoidl.pro, and only Hershey fonts are supported when using Unicode. In the figure, I have produced the M_⦿ symbol using textoidl.pro, sunsymbol.pro, and LaTeX’s PSfrag package (left to right); the improvement represented by the third method is clear and expected. as this is produced directly using LaTeX. Also see the Coyote’s post for a more detailed discussion.

One way to resolve this issue is to use LaTeX’s PSfrag package (solution via Manodeep S. via IDL Google Groups), which basically “precisely superimposes any LaTeX construction” (e.g. symbols, equations) into over EPS figures. So you have to create a tag for your LaTeX construction, which then is replaced by the appropriate symbol during TeX compilation. Let me give an example for the M_⦿ in IDL; but this can be used for EPS figures made in any program.

SET_PLOT, 'PS',/Encapsulated
!P.FONT=0
DEVICE, FILENAME='figure.eps',/times
plot,findgen(10),xtitle='Msun'
DEVICE, /CLOSE

\documentclass{article}
\usepackage{geometry, graphicx, psfrag}
\pagestyle{empty}
\geometry{paperwidth=12.1cm,paperheight=8.1cm,margin=0pt}
 
\begin{document}
 %%% Msun is the tag in the eps file to be replaced by M⦿
\psfrag{Msun}[c][][1.75]{Mass (M$_{\odot}$)}
\includegraphics[width=11.9cm,height=7.9cm]{figure.eps}
\end{document}

latex figure.tex
dvips -o fig.ps figure.dvi
ps2epsi fig.ps fig.epsi
### strip out the preview part from fig.epsi
perl -ne 'print unless /^%%BeginPreview/../^%%EndPreview/' < fig.epsi > fig.eps

Converting astronomical data taken in multiple filters into representative-color RGB images often provides one of the most visually appealing (and informative) views of a target. This can be done in ds9 very easily; however, if you want a little more control, then python/matplotlib can be used in a very similar fashion. I also note that APLpy has excellent capabilities for images with proper World Coordinate System headers already (see the APLpy RGB tutorial). APLpy is far easier to use, but if you don’t have that choice, then you can use matplotlib as I am going to show below.

First, lets assume we are starting with three images, say J.fits, H.fits, and K.fits and that these images all have the same plate scale, the same angle, and the same position on the sky but lacks WCS information (as is often the case for ground-based OIR observations). Load up the images into numpy arrays using the pyfits module.

import pyfits
import numpy as np
import pylab as py
import img_scale
 
j_img = pyfits.getdata('J.fits')
h_img = pyfits.getdata('H.fits')
k_img = pyfits.getdata('K.fits')

img = np.zeros((j_img.shape[0], j_img.shape[1], 3), dtype=float)
img[:,:,0] = img_scale.sqrt(k_img, scale_min=0, scale_max=10000)
img[:,:,1] = img_scale.sqrt(h_img, scale_min=0, scale_max=10000)
img[:,:,2] = img_scale.sqrt(j_img, scale_min=0, scale_max=10000)

py.clf()
py.imshow(img, aspect='equal')
py.title('Blue = J, Green = H, Red = K')
py.savefig('my_rgb_image.png')

from pyraf import iraf as ir
 
h_img = pyfits.getdata('H.fits')
k_img = pyfits.getdata('K.fits')
scaleK = 0.1   # arcsec per pixel
scaleJ = 0.15 # arcsec per pixel)
paJ = 30.0  # degrees
 
ir.unlearn('imlintran')
 
ir.imlintran.boundary = 'constant'
ir.imlintran.constant = 0
ir.imlintran.interpolant = 'spline3'
ir.imlintran.fluxconserve = 'yes'
 
# the input pixel position of a reference source
ir.imlintran.xin = 0
ir.imlintran.yin = 0
 
# the output pixel position of a reference source
ir.imlintran.xout = 10
ir.imlintran.yout = 10
 
# Set the output size of the final image
ir.imlintran.ncols = k_img.shape[1]
ir.imlintran.nlines = k_img.shape[0]
 
ir.imlintran('j.fits', 'j_rot_scale.fits', angleJ, angleJ, scaleK/scaleJ, scaleK/scaleJ)
 
j_img = pyfits.getdata('j_rot_scale.fits')

from scipy.ndimage import interpolation as interp
 
old_j = pyfits.getdata('j.fits')
new_j = interp.shift(old_j, [shiftY, shiftX])

I recently needed to do some simple 3D plotting in python. The strongest choice as discussed on the web is Mayavi, which is part of the Enthought Python distribution. However, I have a previous python distribution already installed (via scisoft) with all of my favorite packages updated to the latest and greatest versions (e.g. matplotlib, PyEphem, slalib for python, etc.). I wanted to install Mayavi into my existing pythong distribution. In theory this should have been straightforward as there are eggs (a python package zip-type file). However, no matter how hard I tried, I could not get Mayavi, and all its required software, installed properly. Part of this may have been that I was doing a local install without admin privileges.

After spending an entire day with Mayavi issues, just in my attempt to make a very simple 3D scatter plot, I ran across a much easier option. The latest edition of matplotlib (0.99.1) comes with a toolkit called mplot3d. After looking over examples here and here, it took me about 5 minutes to download and install the latest matplotlib version and I was ready to go! Simple 3D figures are a snap to put together and you can interact in order to zoom and rotate around. The toolkit uses matplotlib on the backend, so if you are familiar with all of the plotting options there, then mplot3d follows on logically.

My plot from matplotlib.mplot3d

There are still a few bugs/features that I haven’t quite figured out. Most notably, in wire or surface plots, I can’t seem to set the rstride and cstride (row and column segment step sizes) to anything less than 1. But one of my favorite things about python is that I should be able to go into the source code for mplot3d and figure out what the issue is.

If you have experience with either Mayavi or mplot3d, let us know in the comments when you would need to use Mayavi over the simpler functionality of mplot3d or if you have run into other issues with either.

Do you use the tool “convert” to manipulate plots and images?  It’s simple, powerful and downright great!  Quick examples:

Modify a plot for presentation use, by swapping to a black background with white lines, so it’s easier to read on a screen:

> convert  -negate frompaper.ps  forscreen.jpg

Make a thumbnail:

> convert -geometry 50×50 big.jpg thumbnail.gif

Today APLpy 0.9.3 is out! It is a Python plotting package made to generate publication-quality plots in multiple formats such as EPS, PDF, PS, PNG, and SVG.

APLpy was created by Thomas Robitaille and Eli Bressert, who come from a Fortran and IDL background. With Python’s ease of use, portability, and programming they decided to make a plotting package for astronomers. APLpy’s objective is easy usage with great looking publication plots. In other words, more bang for the buck. Here’s an example of what an APLpy plot looks like:

A color generated APLpy plot from FITS files with grid lines.

To see more examples and how to make the plots in Python check out this link.

APLpy has quite a few features (some listed below – from the APLpy site) and is continuing to expand. Fortunately, there’s good documentation to accompany the features.

• Make plots interactively or using scripts
• Show grayscale, colorscale, and 3-color RGB images of FITS files
• Generate co-aligned FITS cubes to make 3-color RGB images
• Overlay any number of contour sets
• Overlay markers with fully customizable symbol
• Plot customizable shapes like circles, ellipses, and rectangles
• Overlay coordinate grids
• Customize the appearance of labels and ticks
• Hide, show, and remove different contour and marker layers
• Pan, zoom, and save any view as a full publication-quality plot
• Save plots as EPS, PDF, PS, PNG, and SVG

The plotting package is under active development and there has been extensive interaction between the users and developers. We should be seeing some exciting features added to APLpy in the next few releases.