Other Links

AAOGlimpse recent changes

Version 1.6:

Download AAOGlimpse 1.6 for OS X 

Download AAOGlimpse 1.6 for OS X (includes Qt libraries)

Download AAOGlimpse 1.6 for Windows

The program now supports multiple concurrent images, rather than just a main image and a secondary image. This turned out to be quite a significant change, mainly because of the need to provide a number of new features in the GUI to support more than two images at a time.

A new keyword display strip can be used to display the value of a selected FITS keyword.

AAOGlimpse has also gained the ability to produce a 'true' colour image from three separate coloured images (usually red, green and blue, although the facility is more flexible than that).

A new, more or less experimental, option for displaying 3D data using dots for each pixel to provide a sort of simple transparency is now provided.

3D data cubes now have a Z-axis drawn as well as the X-Y axes provided to date.

And there are a couple of bug fixes.

Multiple concurrent images:
(Note: To maintain some backwards compatibility, as a special case, if there is no image numbered 3, the '3' key will display the main and secondary images together, as before.)
FITS keywords:

'True' colour images:

glimpse setDefaultPath `pwd`
glimpse openNth red_image.fits 2, lut red
glimpse openNth green_image.fits 3, lut green
glimpse openNth blue_image.fits 4, lut blue
glimpse newFromThreeColours 2 3 4

newFromThreeColours takes an optional 4th argument, the number of the resulting image, which defaults to 1, ie the result becomes the new main image. In practice, the scales for the images will probably need to be set to control the contribution of each image to the final colours.)
3D data - dots and axes

Bug fixes
Internal and experimental things

    Although this has clearly always been the case, it was only in testing this version that it was realised that it is possible to use the various 'open' socket commands ('open', 'openSecondary' and the new 'openNth' and 'openNew') to open images in FITS files that are not the first image in the file. The cfitsio library supports the syntax 'filename[n]' where 'n' is the number of the image in the FITS file. The main image is number 0, so 'myfile.fits' and 'myfile.fits[0]' will both have the same effect. (Strictly, the numbers refer to HDUs or Header Data Units, and these can be extensions of various types, not all of which are images.) Note that cfitsio is very strict about enforcing the FITS format, and there are files around that are supposedly FITS files with multiple images that do not conform and which cfitsio (and hence AAOGlimpse) will noy read. In testing, the original file used was rejected because all extensions contained the keyword SIMPLE=T, which is in fact forbidden in extension headers.

Version 1.5:

Download AAOGlimpse 1.5 for OS X 

Download AAOGlimpse 1.5 for OS X (includes Qt libraries)

This version provides a few new features, such as a center-of-gravity estimate for the data in the selected area and some new socket commands. It also has a number of relatively minor changes to the way some aspects of the interface operate, all intended to make the program just that bit easier to use. And, of course, a couple of bug fixes.

New features:

Changes to the way the program operates:

Bug fixes:

Version 1.4:

Download AAOGlimpse 1.4 for OS X 

Download AAOGlimpse 1.4 for OS X (includes Qt libraries)

Download AAOGlimpse 1.4 for Linux.

Download AAOGlimpse 1.4 for Windows

Version 1.4 introduces two new windows to help simplify navigation around the data being displayed, adds a facility for fitting Gaussian profiles to plotted iines, allows AAOGlimpse to be run automatically by double clicking on FITS files, allows the data values in the selected area to be written out to a text file, and also - finally - introduces support for printing. There is a new menu item used to control opacity effects in plots.


The changes introduced in version 1.3 made it rather easier to navigate around an image. Nonetheless, in practice it became obvious that zooming in on one part of an image, then zooming out to locate another part and zooming in on it, was still not as easy as it ought to be. In fact, it became obvious why programs such as Skycat and DS9 have two extra windows along with the main display window, one showing a zoomed display of the portion of the image under the mouse, and one showing the area currently displayed in the main window in the overall context of the whole image.

So with version 1.4, AAOGlimpse now provides similar capabilities:

Line fitting:

The 'face-on' plots at the bottom of the main screen now include a facility for fitting single Gaussian profiles to emission lines in the plot. If the mouse is over a feature that can be fitted reasonably sensibly to such a profile, the profile is superimposed in a highlit colour over the data, and the fitted full-width at half maximum and line center at displayed in the readout at top left of the main screen. There is not much control over the details of the fit; the algorithm looks for the strongest line close to the mouse position, and so may not always choose the line you have in mind. The range over which it looks is fixed (I'm thinking about nice ways to be able to control it) but it is limited to the range of data being displayed, so zooming in on the line you want may help. Menu options allow a 'top-hat' profile to be fitted if the data looks as if that would be more appropriate.

There are two new menu options in the 'Plots' menu:

Opacity control

Normally, the plots at the bottom of the main window controlled by the 'Plots' menu make use of an opacity effect to make them stand out against the background of  the main image. If the cursor is within the plot window, the plot background is opaque, if outside it is semi-transparent. Some machines (in particular a rather old Windows XP laptop in use at AAO) do not seem to support this effect properly, with the result that the plots become almost impossible to distinguish. There is now a new item in the 'Plots' menu called 'Enable opaque effect'. This is selected by default and gives the usual behaviour. If unselected, the plots are drawn without any background of their own, with the image showing through undimmed. This allows the plots to be seen on machines that do not support the feature properly, and some users may find they prefer not have have the opaque effect anyway, even on machines where it does work. (Eventually, this and other items should go in a 'Preferences' control panel.)

Listing the data in the selected pixels:

A new menu item in the File menu, "List selected area..." will cause AAOGlimpse to write a text file listing the data values of all the pixels in the selected area. A dialogue box is put up to allow the user to specify the name of the output text file.


There is - at long last! - now a 'Print' item in the File menu. Selecting this puts up a print dialogue which will print a copy of what is being displayed in the main window. You get an exact copy of what is in the main window, including any plots at the bottom of the screen. The effect is like a screenshot of the main window. (Note that as currently implemented, it really is a screenshot of the main window, and so has the same resolution as does the main window. In principle, it is possible to regenerate the display first at higher resolution, but that is something for a later release, perhaps.)

Double-clicking on FITS files:

It is possible on both Windows and OS X to specify AAOGlimpse as the program to be run when double-clicking on a file with a specified extension. On Linux it can be run with a filename as a command line argument. AAOGlimpse now supports being run in this way. You can set it as the default program to be run to open ".fits" or ".fts" files (or even ".jpg" or ".jpeg" files, if you really want it as your default photo viewer), and double-clicking on such a file will load AAOGlimpse and get it to automatically open the selected file.

Note: The behaviour is slightly different between Windows and OS X if AAOGlimpse is already running when such a file is selected. Windows will run a new copy of AAOGlimpse to open the file, OS X will get the existing copy of AAOGlimpse to open the new file. At present, dragging a file into the AAOGlimpse window does not open it (it does nothing at all).


The introduction of the zoom and navigation windows meant supporting multiple OpenGL windows in AAOGlimpse for the first time, and some significant internal changes have been needed, including the introduction of a whole new 'display coordinator' layer to handle interactions between the windows. The documentation still needs to catch up.

Version 1.3:

There is a new menu item in the File menu called 'Center on mouse'. This is tied to the command-C keyboard short-cut. It re-centers the display so that whatever was underneath the mouse cursor position is now at the center of the display. This is always going to be used with the key combination, because, of course, you have to move the mouse to select the menu item; but the menu item serves as a reminder that the facility exists.

Pixel sampling now supports both 'min' and 'extreme' options as well as 'sparse', 'mean' and 'max'. At present these can only be changed through the socket interface, using the SetSamplingMode command. 'Min' simply picks the minimum value from the range of possible data values (and so emphasises negative spikes, for example). 'Extreme' picks the value from the range of possible data values that is furthest from the mean. This will be either the maximum or the minimum value, and so emphasises both positive and negative spikes in the data. 'Extreme' is the slowest of the options currently provided, and 'sparse' is the fastest - this may be noticeable on big images.

Bug fixes:


Version 1.2:

Download AAOGlimpse 1.2 for OS X 

Download AAOGlimpse 1.2 for OS X (includes Qt libraries)

Download AAOGlimpse 1.2 for Windows

A number of changes aimed at making the graphs plotted at the bottom of the display (sometimes called the 'face-on' graphs, because they don't rotate with the main image display) more useful. The graphs themselves are more flexible, able to be resized and with control over the scales in both axes, and can now be used to display cuts through the data.

One minor bug fix: The sigma filter code in the spike removal algorithm was miscalculating the mean value. This had little effect on the way it was being used in AAOGlimpse, but showed up when the code was 'borrowed' for another application.

Version 1.1:

The main change with version 1.1 is that it has now been built for Windows, and the release now includes a Windows executable.

There are very few functional changes and bug fixes:

There have been some quite significant changes to the internals of the program to cope with the addition of Windows support. Most of these are too esoteric to be mentioned here (the history section at the start of each source file has the details), but the following may be worth noting:

Version 1.0:

Download AAOGlimpse 1.0 for OS X without the Qt libraries.

Download AAOGlimpse 1.0 for OS X with the Qt libraries.

Download AAOGlimpse 1.0 for Linux.

A sudden jump to version 1.0. This is finally the long-awaited portable version of AAOGlimpse, now released for Linux and for OS X. (A Windows release is perfectly feasible, and is being investigated, but isn't included yet.)

Version 1.0 has very few changes to the system-independent code, apart from a couple of bug fixes and some changes to the interface connected with the location of font files. Until now the only version of the system-dependent code available was one written in Objective-C++ for OS X. The big change in version 1.0 is that there is now a version of the system-dependent code written, not for one specific system, but for Qt.

Qt is an application development framework that allows code written for it to be built and run on a number of different systems, including Windows, OS X and Linux. This means that this new version of the "system-dependent" code can in principle be built on any of these systems. Strictly speaking, I suppose this layer is now 'framework-dependent' rather than 'system-dependent'.

The system-dependent code implements most of the GUI aspects of AAOGlimpse, including the various menus and the widgets used to control the display scale options and the highlit area. In earlier versions these had not had much effort devoted to making them work nicely, partly because any such effort was going to have to be redone for each implementation of this code. This is no longer the case with the Qt-based version, and so a little more effort has gone into producing a more integrated GUI:

Now that there are multiple versions of AAOGlimpse that can be downloaded, the download links for the new version on these web pages now lead to a page that lets you choose the required version (there are two versions for OS X, one of which includes the required Qt libraries - and is quite large as a result - and one that does not, for systems that already have the libraries installed).

Version 0.87:


A quick bug fix release when it was realized that 0.86 had introduced a bug that meant that zooming in on an image could subsequently prevent display of parts of the image that had been outside the zoomed area. This should be fixed in 0.87.

Version 0.86:


Some tidying up of the way 3D data cubes - particularly large ones - are handled.

Version 0.85:


A number of changes all directed at the question: 'Can this program be used on really large files?'. (That is, ones that are larger than the physical memory available - I was experimenting with a 25GByte data cube on my 8GB laptop.) It now does so much better than it used to, and some of the changes make working with less ambitious large images faster too. Most of these changes are purely internal, except for the way the 'show graph through planes' option works with files that won't fit in physical memory, and even that change is quite subtle. Bottom line - the program has been tested and is usable with a 25GByte data cube, and should be able to go much larger.

The main AAOGlimpse web page now has a table of contents and should be a bit easier to move around in.

Version 0.83:


Added support for drawing more 'traditional' 2D graphs of data in the lower part of the screen. These can be used to display plots of things such as a histogram of data values. The plots can be zoomed and panned interactively, and can be used to delineate ranges of data. Interacting with these plots can be control some details of how the main data is displayed. If the mouse is moved over the graph its background goes opaque to show that it is now the active part of the screen, and the scroll wheel now controls zooming in on the data plotted just under the mouse. Enabling axes (usually using command-G) will add an X-axis to the graph, and dragging with the left mouse button down will pan a zoomed graph in X, following the mouse. Limit lines in the graph (drawn in orange) can provide additional information, and can be picked up with the mouse and dragged to affect the display of the main data. How the limit lines work depends on the type of plot being displayed.

Two types of such plots have been implemented:

The File menu now has a 'Data histogram' menu option, as mentioned above.

The Scale Control panel now has a 'Show graph through planes' check box, also as mentioned above.

Version 0.82:


A number of small changes, mainly to improve the facilities available through the socket interface, to make it easier to generate reproducible effects for use in presentations. Some of these socket commands were introduced earlier on a tentative basis, but have now been documented properly in the section on the socket interface. Look in there for the full list - there are too many new ones to list here.

Other changes:

Implemented a fix to the surface generation code that has the efect of reducing the a number of times the displayed surface is regenerated when zooming in and out. This makes zooming somewhat smoother.

Dragging with the mouse down in the highlit area no longer changes the orientation of the display if the mouse is moved quickly enough that it escapes the highlit area before it gets redrawn. (This was a rather irritating bug.)

Version 0.8:


Continues (and pretty much completes) the re-working of the code to reduce the system-dependent part to as thin a layer as possible. The text drawing code has all been completely revised, and no longer uses the Apple-specific GLString code. Instead, the FTGL font library is now used for all text output. The result is not quite as pretty as that from the original Apple code, but the difference is hard to spot and could be improved further by the use of textures instead of pixmap fonts if anyone felt the improvement was worth the effort. At the same time, quite a bit of work has gone into commenting the code properly, and while this is not yet completely satisfactory, it is probably close enough that I can release the source without feeling too embarrassed (but it needs a bit of housekeeping to sort out which files are actually needed for the release).

Some slight text-related changes as a result:

Other changes:

Version 0.75:

A serious restructuring of the higher levels of the code to split them into a large system-independent part (the DisplaySupervisor code) and a much smaller system-dependent part. This is a necessary precursor to ports to systems other than Mac OS X. However, at present, there is only an implementation of the system-dependent layer for OS X.

Version 0.75 should be functionally the same as 0.7, except that:

And there were a couple of new features added:

Version 0.7:


Much improved handling of large data sets:

A significant reworking of the internal code that handles the calculation of WCS values in order to speed up the opening of large data cubes and to reduce the amount of memory used to hold the coordinate values. Instead of holding X,Y and Z coordinate values for every single pixel in the data (which meant that the memory used for coordinates was three times that used for the data itself) the code now runs a quick pass through the WCS coordinates to see how they change and only allocates the minimum amount of memory needed. For example, if the X and Y values are the same for every plane of 3D data, only a single 2D array is needed to hold the X and Y values. If the Z values are the same across each plane, a 1D array will be enough to hold them. The downside is that the code to access the coordinate values as the data is surfaced is now more complex than the simple 3D array look-up it used to be, as it has to check how the coordinates are being stored. But this is a worthwhile trade-off - the new code is still much faster than calculating the coordinate values on the fly.

Added the option of surfacing by 'cubes':

By defaut, AAOGlimpse produces its display surfaces by drawing quadrilaterals between the centers of groups of four pixels. This means that the number of surface elements generated for an image is equal to the number of pixels in the image (strictly slightly less, because of the way the edge pixels are handled). It would be more 'traditional' (is that the right word?) to have drawn individual cuboids for each pixel, but this involves generating three times as many surfaces. However, particularly for images with very few pixels in one or more dimensions - a set of a small number of spectra, for example - the cuboid surfaces do seem to look better, and this has now been added as an option. It is a slower option, however, particularly when there are large number of pixels involved, because not only are there more surfaces to be generated, but the calculations for the vertices are more complex.

User interface changes:

Bug fixes:

(The main delay now in the handling of large data sets comes from the time taken to scale the data for display, and this is under investigation.)

Version 0.65:

Implementation of a 'plug-out' scheme for running utility tasks from AAOGlimpse:

On startup, AAOGlimpse looks for a 'Glimpse' sub-directory of the user's home directory. Any executable file in there with a '.glimpse' extension is treated as a 'plug-out' program that can be run from AAOGlimpse. An item for each such file will be added to the new 'Plug-outs' menu and can be run by selecting that menu item. Any program at all can be run in this way - shell scripts, python programs, etc. The idea is that any such program will use the socket interface to interact with AAOGlimpse to get the required effect.

More revisions to the highlit area selection code:

Other changes:

Version 0.6:


A large amount of internal re-working of the code that allows you to select an area with the mouse. A lot of the work for this release was intended to support one particular application: we wanted to be able to read in images from an optical test setup and interactively try to select the ellipse that best fitted the peak in the image. Because these images were most conveniently available as JPEG files, the ability to read JPEG images was added. Because we needed to be able to draw an ellipse around a feature in an image and expand and rotate it interactively until it matched, the whole of the code that allowed an area of the image to be selected using the mouse was re-worked. Adding the ability to read JPEG images led to the introduction of a number of experimental features for playing with these, although not all of them are likely to remain in the production code. All in all:

Version 0.53:

Added drawEllipse socket command.

An earlier change had led to cut plots being drawn with too thick a line as an unwanted side effect. Now reverts properly to thin lines.

It's no longer so critical to press the shift key before clicking the mouse in order to start a selection. You can now press the shift key after clicking the mouse, so long as the mouse hasn't actually moved. This makes starting a selection rather easier.

The selectPixels socket command no longer ignores the z values. Values set to zero (not a valid pixel number, as they start from 1) are treated as unspecified.

Internally: Code for drawing the collapsed data plots has been reorganised and simplified, ready for a substantial review of how the selection code itself operates.

Version 0.52:


A number of bug fixes, most showing up in testing with DSS images.

Version 0.51:

Version 0.5:


Basically, faster, more flexible when working wth two images, and with more control over how data cubes are displayed.

Speed changes:

Working with two images:

Control over what's displayed:

Internal changes: