For anyone who uses python and ds9 to visualize their FITS files, I think pyds9 is now a must-have. It is officially written and developed through SAOImage ds9 so it will be supported for the long haul. Here are the primary links to get going:

• TARball for installation: Source
• Documentation for installation and use: Docs

The documentation is pretty basic so I put together a very small tutorial of a way I might typically use it. Most of the controls work through the XPA interface, which seems very flexible, if a little tricky to figure out exactly how to make it work for specific use-cases. If you have samples of how you use pyds9 or ds9 xpa, post them in the comments or on this wiki page.

from scipy import stats
import numpy as np
import ds9
 
# Make a 2D gaussian image that is stored in a 2D numpy array
x = np.arange(-3, 3, 0.1)
xx, yy = np.meshgrid(x, x)
gauss2d = stats.norm.pdf(xx) * stats.norm.pdf(yy)
 
# Now open ds9 (this assumes no ds9 instance is yet running)
d = ds9.ds9()
 
# Load up our 2D gaussian
d.set_np2arr(gauss2d)
 
# Zoom to fit
d.set('zoom to fit')
 
# Change the colormap and scaling
d.set('cmap bb')
d.set('scale log')
 
# Add a label
d.set('regions command {text 30 20 #text="Fun with pyds9" font="times 18 bold"}')
 
# Now you can play in ds9 to your heart's content.
# Check back to see what the current color scale is.
print d.get('scale')
 
# Finally, save your completed image (including regions or labels)
d.set('saveimage png my_pyds9_img.png')

Interpolation

Interpolation: Filter profiles may be reported as transmission vs. wavelength data points. To resample the filter profiles to a different (regularly spaced) wavelength grid, I used scipy's interpolation package.

Interpolation is a used for many astronomical applications. Interpolation is required to combine sub-pixel dithered images or spectroscopy, sample grids of stellar evolution or stellar atmosphere models, calculate extinction from observed extinction curves, and many many more applications. The scipy.interpolate package in python has some nice built-in interpolation functions and I have gathered a few links describing the capabilities (in addition to the documentation). I would recommend using splrep/splev over interp1d for speed.

• Scipy cookbook on interpolation
• A slideshow outlining the interpolation capabilities in Scipy
• A thread explaining terms in spline interpolation/smoothing

Integration

Within Scipy, there is an integrate package with several different functions that perform definite or indefinite integrals. I have only played with these briefly; however, I tested both the scipy.integrate.quad() and scipy.integrate.romberg() functions. These all work in roughly the same way by taking a user-defined function, and the upper and lower boundaries of the integral. Here is a brief example:

from scipy import integrate
def myfunc(x, a, b):
return (x**b) + a
 
# These are the arguments that will be passed as a and b to myfunc()
args = (1.0, -2.0)
 
# Integrate myfunc() from 0.5 to 1.5
results = integrate.quad(myfunc, 0.5, 1.5, args)
print 'Integral = ', results[0], ' with error = ', results[1]

The well-established Fortran QUADPACK integration code lies underneath quad() while romberg() appears to be a python only implementation (??). While I would much rather use quad() for its robustness, it only supports user-functions that accept single value floats; while romberg() will pass in vectors of values. For some of my applications, myfunc() is computationally intensive, so there is an order of magnitude speed gain by having a properly vectorized myfunc() used in vector-form by the integration code. Only with romberg() have I matched the speed of IDL’s qpint1d (from Markwardt library, also based on QUADPACK, but vectorized) for identical myfunc().

I have been using ds9 to display images primarily due to inertia. I like the catalog tool for existing catalogs available online; but I wish there were a way to use custom catalog files without RA and Dec (just pixel coordinates) as well. I commonly resort to making ds9 region files, but this requires knowing exactly what you want to see (or filter on) ahead of time.

So three questions arise:

1. what FITS file viewer do you use (I am talking about interactive image viewing here, not plotting and saving image files)?
2. what is your favorite way to work with catalogs and images together?
3. are there hidden interfaces to ds9 for custom catalog types (e.g. image coordinates rather than WCS)?

In your comments, consider adding in how steep of a learning curve you had to climb when learning to use your favorite tools in this area.

There are many applications for taking fourier transforms of images (noise filtering, searching for small structures in diffuse galaxies, etc.). I wanted to point out some of the python capabilities that I have found useful in my particular application, which is to calculate the power spectrum of an image (for later separation of the distribution of stars from the PSF and the noise; see Sheehy et al. 2006).

Below I have posted an example snippet of code, which you can also find on the wiki. But first, some figures to show what we are doing —  an astronomical image (left), the 2D power spectrum of the image (middle), and the azimuthally averaged 1D power spectrum (right).


The bulk of the heavy lifting can be done using SciPy’s fftpack. I also wrote radialProfile.py and it is very crude at the moment.
[code lang="python"]
from scipy import fftpack
import pyfits
import numpy as np
import pylab as py
import radialProfile

image = pyfits.getdata('myimage.fits')

# Take the fourier transform of the image.
F1 = fftpack.fft2(image)

# Now shift the quadrants around so that low spatial frequencies are in
# the center of the 2D fourier transformed image.
F2 = fftpack.fftshift( F1 )

# Calculate a 2D power spectrum
psd2D = np.abs( F2 )**2

# Calculate the azimuthally averaged 1D power spectrum
psd1D = radialProfile.azimuthalAverage(psd2D)

# Now plot up both
py.figure(1)
py.clf()
py.imshow( np.log10( image ), cmap=py.cm.Greys)

py.figure(2)
py.clf()
py.imshow( np.log10( psf2D ))

py.figure(3)
py.clf()
py.semilogy( psf1D )
py.xlabel('Spatial Frequency')
py.ylabel('Power Spectrum')

py.show()
[/code]

If you have suggestions for the above examples or other related code snippets or helper functions, let me know or comment below. I have posted this example on the wiki and will keep it updated with your suggestions.

It’s time for another session of, “Which tool do you use to accomplish a given astro-task, and why that tool?”  The topic:  fitting surface brightness profiles.  Two likely suspects:  the Archangel package, and iraf’s stsdas.analysis.isophote.  OK, go.

Given the useful responses to Jane’s question about spectral line analysis, here’s another query for the community. This one is about making large image mosaics and it comes from Adam Ginsburg, a grad student at the University of Colorado, Boulder.

I want to make a large-scale mosaic of the Galactic Plane covering 90-180 degrees x a few degrees. There are a few ways to do this:

• IRAF’s imcombine with offset=wcs is a quick and dirty path to a mosaic. It is very fast, but very inaccurate over large scales and it sometimes does things flat-out wrong.
• IDL’s hastrom and related astrolib utils generally work, but for large arrays (96000×4000 pixels) I’ve seen IDL just crash.
• IRSA’s Montage works well, but is slow and consumes a lot of hard drive space in the process of making mosaics. The setup is also kind of a pain; you need to make a lot of subdirectories and .tbl files in the process.
• SSC’s mopex must work quite well, but I just discovered it today and, like Montage, it has a learning curve.

So, I’m curious, what do others use? For example, what did GigaGalaxy Zoom use? If you’re trying to build a large near-IR finder chart using 2MASS, do you just go to montage? Does anyone have convenient wrapper scripts written up? Let’s hear it in the comments.

Here’s a guest post from Mark Westmoquette at the University College London.

Do you currently work with, or are you thinking about applying for integral field unit (IFU) observations? If so, then the Integral Field Spectroscopy wiki is for you.

With IFS instruments installed on all the main optical telescope facilities around the world, it is likely that you will come across IFS data sooner or later. Unfortunately IFS continues to be avoided by large sections of the astronomical community due to perceived difficulties with data handling, reduction and analysis. There is no doubt that dealing with IFS data is more complicated than simple imaging or long-slit spectroscopy, but many of the problems that arise could benefit from the experience and knowledge of others. We have set up the IFS wiki in order to facilitate exchange of IFS knowledge, and to be a repository of information, tips, codes, tools, references, etc., accessible and editable by the whole community. The wiki is intended for use by IFS beginners for any questions or issues with IFS data and for more expert users. All are invited to contribute – tips, experience of particular instrumental quirks, pieces of code, etc, are particularly welcome.

Topics covered by the wiki are:
• current and future integral field spectrographs;
• observational techniques and planning;
• data reduction, including overview of procedures for different types of IFS;
• more advanced tasks like mosaicing or differential atmospheric refraction (DAR) correction;
• analysis techniques, from visualisation to line fitting and source extraction.

The founders and maintainers of this site are currently Mark Westmoquette (University College London, UK) and Katrina Exter (Katholieke Universiteit Leuven, Belgium). To access the wiki go to: http://ifs.wikidot.com.

This is an embarrassing post, but I’m going to forge ahead.  Time was, we used IRAF and we hated it, but what else was there?  Now, there are many choices, lots of them buggy and badly documented, some of them superb.

Say I have a one-dimensional, flux-calibrated, wavelength-calibrated spectrum.  (So, all the hard work of calibration is already done.) I want to measure equivalent widths, fluxes, and wavelengths of lines, interactively and then non-interactively.  What software packages can people can recommend?

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.

Often we have datasets in which quantities are not detected.  Those upper limits contain information — the flux was definitely below X.  It turns out, there’s a rich statistical literature on how to consider both detections and upper limits.   Yet often astronomers don’t properly incorporate those upper limits in their analysis.

Fortunately, several authors have explained those techniques for astronomers, shown examples using astrophysical datasets, and written a package that does the analysis for you.  Interested?

The first paper is Feigelson & Nelson 1985, which deals with univariate distributions (luminosity functions, line ratios, mean values, etc.)

The second paper is Isobe, Feigelson, and Nelson 1986, which deals with correlation and regression.

The package ASURV implements these techniques.   The included manual is very helpful.

It took me 2 hrs to figure out the funky syntax required for the data files (stupid fortran),  and after that, bingo, I generated reconstructed distribution functions and the probability that my samples were drawn from the same parent.  Exactly what I needed to solve my, “So, is this result significant, or what?” problem.