/ 
Image-DS9-0.13
River stage zero No dependents
/ Image::DS9

NAME

Image::DS9 - interface to the DS9 image display and analysis program

SYNOPSIS

use Image::DS9;
use Image::DS9 qw( :<group> );  # import constants from group <group>
use Image::DS9 qw( :all );	  # import all constants

$dsp = new Image::DS9;
$dsp = new Image::DS9( \%attrs );

DESCRIPTION

This class provides access to the DS9 image display and analysis program through its XPA access points.

DS9 is a rather flexible and feature-rich image display program. Rather than extol its virtues, please consult the website in "REQUIREMENTS".

This class is rather bare at present, providing a low level interface to the XPA access points. Eventually these will be hidden by an elegant framework that will make life wonderful.

To use this class, first construct a Image::DS9 object, and then apply its methods. It is possible to both address more than one DS9 with a single object, as well as having multiple Image::DS9 objects communicate with their own DS9 invocations. Eventually there will be documentation spelling out how to do this.

METHODS

The methods in this class closely follow the XPA access points. The documentation here tries to cover the mechanics of calling the methods. For more information on what the methods do, or how the arguments affect things, please consult the DS9 documentation.

Arguments

Commands sent to DS9 are sent as strings. To prevent typos (and other unwanted sideeffects) Image::DS9 makes many of the commands and subcommands available as Perl constants -- mistype these and the compiler will complain, not DS9. The complete set of constants is indexed in "Constants".

Boolean values

Some methods take boolean values; these may be the strings on, off, yes, no, or the integers 1 or 0. There are predifined constants available for these:

ON	=> 'on'
OFF	=> 'off'
YES	=> 'yes'
NO	=> 'no'

Return Values

Because a single Image::DS9 object may communicate with multiple instances of DS9, queries may return more than one value. Because one usually communicates with a single DS9 instance, if a query is made in scalar mode, the result is returned as a scalar, i.e.:

$cmap = $dsp->colormap();

In this mode, if more than one server responds, you'll get the results for a randomly chosen server.

When queries are made in list mode, the return values are hashes, rather than scalars. The hash has as keys the names of the servers, with the values being references to hashes with the keys name, buf and message. The message element is present if there was an error.

The buf element contains the results of a query. Ordinarily, the buf element will be unaltered (except for the removal of trailing newlines) from what DS9 outputs. Some methods, however, such as bin() will reformulate buf to make life easier.

For example,

use Data::Dumper;
%colormaps = $dsp->colormap;
print Dumper \%colormaps;

yields

$VAR1 = {
         'DS9:ds9 838e2ab4:32832' =>
          {
            'name' => 'DS9:ds9 838e2ab4:32832',
            'buf' => 'Grey'
          }
        };

Sending data usually doesn't result in a return:

$dsp->colormap( 'Grey' );

Error Returns

In case of error, an exception is thrown via croak(). The res() method will return a hash, keyed off of the servers' names. For each server which had an error, the hash value will be a reference to a hash containing the keys name and message; the latter will contain error information. For those commands which return data, and for those servers which did not have an error, the buf key will be available.

Administrative Methods

new
$dsp = new Image::DS9;
$dsp = new Image::DS9( \%attrs );

Construct a new object. It returns a handle to the object. It throws an exception (catch via eval) upon error.

The optional hash attrs may contain one of the following keys:

Server

An alternate server to which to communicate. It defaults to ds9.

WaitTimeOut

The default number of seconds that the wait() method should try to contact DS9 servers.

max_servers

The maximum number of servers to which to communicate. It defaults to the number of DS9 servers running at the time the constructor is called.

min_servers

The minimum number of servers which should respond to commands. If a response is not received from at least this many servers, an exception will be thrown. It defaults to 1.

For example,

$dsp = new Image::DS9( { max_servers => 3 } );
nservers
$nservers = $dsp->nservers;

This returns the number of servers which the object is communicating with.

wait
$dsp->wait();
$dsp->wait($timeout);

Try to contact the DS9 servers, and wait until at least min_servers have replied. It will attempt this for WaitTimeOut seconds if no timeout is supplied, else the given time. It returns true upon success. This routine is useful for doing things like:

$dsp = new Image::DS9;
unless ( $dsp->nservers )
{
  system("ds9 &" );
  $dsp->wait() or die( "unable to connect to DS9\n" );
}

Control Methods

array
$dsp->array( $image );
$dsp->array( $image, \%attrs );

This is a simple interface to the array access point, which displays images. If $image is a PDL object, all required information is extracted from it, and it is passed to DS9. Otherwise, it should be binary data suitable for DS9, and the attrs hash should be used to pass dimensional and size data to DS9. attrs may contain the following elements:

xdim

The X coordinate array extent.

ydim

The Y coordinate array extent.

bitpix

The number of bits per pixel. Negative values indicate a floating point number.

bin
$dsp->bin( $attr, [$attr_value, $attr_value] );
$dsp->bin( B_to_fit );
$attr_state = $dsp->bin( $attr );

This sets the attributes for binning of FITS bin tables. Constants for the attributes are available (importable by the bin tag, see "Constants"):

B_about      => 'about'
B_buffersize => 'buffersize'
B_cols       => 'cols'
B_factor     => 'factor'
B_filter     => 'filter'
B_function   => 'function'
B_average    => 'average'
B_sum        => 'sum'
B_to_fit     => 'to fit'

All of the attributes, except the to fit one, take one or more arguments (see the DS9 documentation for what they are). One can query the value of the attributes, except for to fit (which cannot be queried), by passing no arguments.

If an attribute is multi-valued, a query yields a reference to an array, not a scalar. For instance:

$res = $dsp->bin( B_about );
($x, $y ) = @$res;

returns a reference to an array, while

$res = $dsp->bin( B_buffersize );

returns a scalar. Don't attempt to do

($x, $y ) = $dsp->bin( B_about ); # ERROR DON"T DO THIS

As it will return a full blown hash as documented in "Return Values".

Queries called in list mode return results slightly different than documented in "Return Values". The buf element is left as a scalar for a single valued attribute, but is turned into a reference to an array for a multivalued attribute.

colormap
$dsp->colormap( $colormap );
$colormap = $dsp->colormap;

$dsp->colormap( CM_invert, $state );
$invert = $dsp->colormap( CM_invert );

The first form sets the colormap. The argument should be the name of a colormap (case is not important). If no argument is specified, the current colormap is returned.

In the second form the colormap can be inverted (or de-inverted). $state is a boolean. If no state is specified, it returns the current inversion state.

The following constants, importable via the colormap tag, are available (see "Constants":

CM_invert	=> 'invert'
crosshair
$dsp->crosshair( $x, $y [, $coord_system] );
$coords = $dsp->crosshair( [$coord_system] );
($x, $y ) = @$coords

Manipulate or query the position of the crosshair. Available values for the coordinate system are (as constants, importable by the coord tag):

Coord_fk4      => 'fk4'
Coord_fk5      => 'fk5'
Coord_icrs     => 'icrs'
Coord_galactic => 'galactic'
Coord_ecliptic => 'ecliptic'
Coord_linear   => 'linear'
Coord_image    => 'image'
Coord_physical => 'physical'

To query the position, pass no coordinates to the method. In scalar mode, a query will return a reference to an array. In list mode, it will return a hash, slightly modified from that described in the /Return Value section. The buf entries will be references to arrays.

cursor
$dsp->cursor( $x, $y );

Set the cursor position to the given position.

display
$dsp->display( $state );
%displays = $dsp->display;

If an argument is specified, this call will change how the data are displayed.

The available display states are available as constants, importable via the display tag (see "Constants"). The available constants and their values are:

D_tile   => 'tile'
D_single => 'single'
D_blink  => 'blink'

If no argument is specified, the current display state is returned. The state is will be returned as a string equivalent to the constants D_blink, D_tile or D_single. For instance:

my $ds9 = new DS9( { max_servers => 1 } );

print "We're blinking!\n" if D_blink eq $ds9->display;
file
$dsp->file( $file );
$dsp->file( $file, $type );
%files = $dsp->file;

Display the specified $file. If called without a value, it will return the current file name loaded for the current frame.

The file type is optional. The available file types are available as constants, importable by the filetype tag (see "Constants"). The available constants and their values are:

FT_MosaicImage	=> 'mosaicimage'
FT_MosaicImages	=> 'mosaicimages'
FT_Mosaic	=> 'mosaic'
FT_Array	=> 'array'
FT_Save		=> 'save'

The save type is a bit of a misnomer; it causes the current frame to be saved as a FITS image with the name given by $file.

frame
# get current frame(s) for server(s)
$frame = $dsp->frame;
@frames = $dsp->frame;

# get list of frames for server(s)
$frame_list = $dsp->frame( FR_all );
@frame_list = $dsp->frame( FR_all );

# perform a frame operation with no arguments
$dsp->frame( $frame_op );

# show the specified frame ($frame may be FR_all)
$dsp->frame( show => $frame );

# hide the current frame
$dsp->frame( FR_hide );

# show the specified frame ($frame may be FR_all)
$dsp->frame( FR_hide => $frame );

# delete the current frame
$dsp->frame( FR_delete );
  
# delete the specified frame  ($frame may be FR_all)
$dsp->frame( delete => $frame );

# delete all of the frames
$dsp->frame( delete => FR_all );

Command DS9 to do frame operations. Frame operations are nominally strings. As DS9 will interpret any string which isn't a frame operation as the name of frame to switch to (or create, if necessary), it's a really good idea to use the provided constants, importable by the frame tag, for the standard operations to prevent typos (see "Constants"). The available frame constants and their values are:

FR_active  => 'active'
FR_all	   => 'all'
FR_center  => 'center'
FR_clear   => 'clear'
FR_delete  => 'delete'
FR_first   => 'first'
FR_hide    => 'hide'
FR_last    => 'last'
FR_new     => 'new'
FR_next    => 'next'
FR_prev    => 'prev'
FR_refresh => 'refresh'
FR_reset   => 'reset'
FR_show    => 'show'

To load a particular frame, specify the frame name as the operator.

To show a frame which has been hidden, use the second form with the show operator.

For example,

$dsp->frame( FR_new );		# create a new frame
$dsp->frame( '3' );		# load frame 3
$dsp->frame( FR_hide );		# hide the current frame
$dsp->frame( show => 3 );	# show frame 3
$dsp->frame( FR_delete );	# delete the current frame

If frame() is called with no arguments, it returns a list of the current frames for all instances of DS9. If it is called with the argument FR_all, it returns a list of all of the frames. In scalar mode, this results in it returning a reference to an array containing the frame ids. In list mode, it returns the standard hash as documented in "Return Values", where the buf element is now a reference to an array containing the frame ids.

iconify
$dsp->iconify($bool);
$iconify_state = $dsp->iconify;

With a boolean argument, specify the iconification state, else return it.

lower
$dsp->lower();

Lowers the DS9 window in the stacking order

mode
$mode = $dsp->mode;
$dsp->mode( $state );

Change (or query) the first mouse button mode state. Predefined constants are available, importable via the mode tag (see "Constants"). The available constants and their values are:

MB_pointer	=> 'pointer'
MB_crosshair	=> 'crosshair'
MB_colorbar	=> 'colorbar'
MB_pan		=> 'pan'
MB_zoom		=> 'zoom'
MB_rotate	=> 'rotate'
MB_examine	=> 'examine'
orient
$state = $dsp->orient;
$dsp->orient( $state );

Change (or query) the orientation of the current frame. Predefined states are available, importable via the orient tag; see "Constants". The available constants and their values are:

OR_X	=> 'x'
OR_Y	=> 'y'
OR_XY	=> 'xy'
pan
# get current pan value(s) for server(s)
$pan = $dsp->pan;
@pan = $dsp->pan;

# absolute pan
$dsp->pan( abs => $x, $y, [$coord] );
$dsp->pan( $x, $y, [ $coord ] );

# relative pan
$dsp->pan( rel => $x, $y, [$coord] );

This changes the pan position for the current frame. Available values for the coordinate system are (as constants, importable by the coord tag):

Coord_fk4      => 'fk4'
Coord_fk5      => 'fk5'
Coord_icrs     => 'icrs'
Coord_galactic => 'galactic'
Coord_ecliptic => 'ecliptic'
Coord_linear   => 'linear'
Coord_image    => 'image'
Coord_physical => 'physical'

To query the pan position, pass no coordinates to the method. In scalar mode, a query will return a reference to an array containing the positions. In list mode, it will return a hash, slightly modified from that described in the /Return Value section. The buf entries will be references to arrays.

raise
$dsp->raise()

Raise the DS9 window in the windkow stacking order.

regions

This sets or queries regions. All of the constants mentioned below which share the prefix Rg are importable via the regions tag. See "Constants" for a concise list.

To query the current list of regions and receive the results using the current attribute formats,

$regions = $dsp->regions();

The structure of the returned data is described below in the discussion of the Rg_return_fmt attribute.

To change the current attribute formats, use the following call:

$dsp->regions( <attribute>, <format> );

The following attributes are available:

Rg_format (or format )

This governs which program the regions will be compatible with, and is one of the following

Rg_ds9         => 'ds9'
Rg_saotng      => 'saotng'
Rg_saoimage    => 'saoimage'
Rg_pros        => 'pros'
Rg_coord (or coord)

This specifies the WCS coordinate system, and may be one of

Coord_fk4      => 'fk4'
Coord_fk5      => 'fk5'
Coord_icrs     => 'icrs'
Coord_galactic => 'galactic'
Coord_ecliptic => 'ecliptic'
Coord_linear   => 'linear'
Coord_image    => 'image'
Coord_physical => 'physical'

(constants importable via the coords tag).

Rg_coordformat or coordformat

This specifies the format for the output coordinates, and may be one of

CoordFmt_degrees     => 'degrees'
CoordFmt_sexagesimal => 'sexagesimal'

(constants importable via the coord_fmts tag).

Rg_delim or delim

This specifies how regions should be separated, and may be one of

Rg_nl          => 'nl
Rg_semicolon   => 'semicolon'
Rg_return_fmt

This specifies the structure of the data that a query returns. If the query was done in scalar mode, the data are returned directly in on of the forms specified below. in list mode, the data are returned as specified in "Return Values", but with the buf element in the forms below.

This attribute may have the following values.

Rg_raw

The results are returned in exactly the form that DS9 sent them. This is the default.

For example,

$dsp->regions( Rg_delim, Rg_nl );
$dsp->regions( Rg_format, Rg_ds9 );

Alternatively, one can request a different attribute format directly in the query, but passing a hash reference:

  %attr = ( Rg_format, Rg_saotng,
	       Rg_coord, Coord_fk5,
               Rg_coordformat, Coord_sexagesimal );

  $regions = $dsp->regions( \%attr );

To add regions from a file, use the Rg_file or Rg_load tags:

$dsp->regions( Rg_file, $file );

To save regions to a file, use the Rg_save tag:

$dsp->regions( Rg_save, $file );

To add a region in a Perl variable, pass a reference to the variable:

$region = "circle 100 100 20";
$dsp->regions( \$region );

(Yes, this is kludgy, but if it were passed in directly, it couldn't be distinguished from a non region command, and error checking would be impossible)

To change the selection state of the regions:

$dsp->regions( Rg_selectall );
$dsp->regions( Rg_selectnone );

To delete all of the regions:

$dsp->regions( Rg_deleteall );

To change the stacking order of the currently selected region,

$dsp->regions( Rg_moveback );
$dsp->regions( Rg_movefront );
rotate
$rotate = $dsp->rotate;
$dsp->rotate( abs => $rotate );
$dsp->rotate( rel => $rotate );
$dsp->rotate( $rotate );

Change or query the rotation angle (in degrees) for the current frame. A rotatation may be absolute or relative; this is explicitly specified in the second and third forms of the method invocation. If not specified (as in the last form) it is relative.

If no argument is specified, it returns the rotatation angle for the current frame.

res
%res = $dsp->res;

In case of error, the returned results from the failing XPA call are available via this method. It returns a hash, keyed off of the server signature(s). See the IPC::XPA documentation for more information on what the hashes contain.

scale

The scale method has a variety of calling sequences. Various constants are available, importable via the scale tag; see "Constants".

To specify or query the algorithm:

$dsp->scale( $algorithm );
$scale = $dsp->scale;

The $algorithm constants and their values are

S_linear   => 'linear'
S_log	   => 'log'
S_squared  => 'squared'
S_sqrt     => 'sqrt'

The method of determining the data limits is set or queried via

$dsp->scale( mode => $mode );
$mode = $dsp->scale( S_mode );

The $mode constants are

S_minmax   => 'minmax'
S_zscale   => 'zscale'
S_user     => 'user'

User limits are set or queried via

$dsp->scale( limits => [ $min, $max ] );
$limits = $dsp->scale( S_limits );
($min, $max) = @$limits;

Since there are two limit values, querying the limits in a scalar context returns a reference to an array. In list mode, it returns a hash slightly modified from that described in "Return Values". The buf elements are converted to array references.

To specify (or query) whether limits are applied to one or all of the images in a mosaic, do this:

$dsp->scale( scope => $scope );
$scope = $dsp->scale( S_scope );

The $scope constants are

S_local    => 'local'
S_global   => 'global'

The scale subparameters (limits, mode, scope) are also available as constants:

S_limits   => 'limits'
S_mode     => 'mode'
S_scope    => 'scope'

Note however that using Perl constants to the left of the => operator causes Perl to try and convert it into a string, i.e.

$dsp->scale( S_mode => S_user )

is converted to

$dsp->scale( 'S_mode', 'user' )

which isn't quite what you want. Either of these

$dsp->scale( S_mode, S_user )
$dsp->scale( S_mode() => S_user )

does the trick.

Finally, to indicate whether only the data section of the image is to be displayed, use S_datasec, with a boolean value:

	$dsp->scale( S_datasec, ON );
        $datasec = $dsp->scale( S_datasec );
tile_mode
# get the tile mode
$mode = $dsp->tile_mode( );

# set the tile mode
$dsp->tile_mode( $mode );

# get the grid mode attributes
$attr = $dsp->tile_mode( T_grid, $attr );

# set the grid mode attributes
$dsp->tile_mode( T_grid, $attr, $arg1, ... );

Set (or get) the tiling mode. This does not switch into or out of tile mode; use display() to do that. If called without a value, it will return the current tiling mode.

Predefined constants for the modes, grid attributes, and grid mode are available, importable via the tile tag (see "Constants"). The modes are:

T_grid	 => 'grid'
T_column => 'column'
T_row	 => 'row'

The grid attributes are:

T_gap	 => 'gap'
T_layout => 'layout'
T_mode	 => 'mode'

and the grid mode values are.

T_auto	 => 'automatic'
T_manual => 'manual'

The grid mode can be either of the above values,

$dsp->tile_mode( T_grid, T_mode, T_auto );

The grid gap is a value in pixels:

$dsp->tile_mode( T_grid, T_gap, $pixels );

and the grid layout requires the values for the rows and columns:

$dsp->tile_mode( T_grid, T_layout, $row, $col );

Note that when getting the current grid layout parameter, it is returned as a references to an array containing the row and column values.

view
$view = $dsp->view( $element );
$view = $dsp->view( $element, $state );

The first form returns the visibility of the element (as true or false). The second sets the visibility of the element (as a boolean value).

$dsp->view( V_buttons, 1 )
  unless $dsp->view( V_buttons );

The element names are available as constants, importable via the view tag (see "Constants"). The available constants and their values are:

V_info      => 'info'
V_panner    => 'panner'
V_magnifier => 'magnifier'
V_buttons   => 'buttons'
V_colorbar  => 'colorbar'
V_horzgraph => 'horzgraph'
V_vertgraph => 'vertgraph'
V_wcs       => 'wcs'
V_detector  => 'detector'
V_amplifier => 'amplifier'
V_physical  => 'physical'
V_image     => 'image'
wcs

This is a complicated beast. Please note that the query calls shown are all done assuming a single DS9 server. For multiple servers, perform the queries in list mode (see "Return Values").

To set a particular WCS mapping or coordinate system, or determine what the current one is:

$dsp->wcs( $coord );
$wcs = $dsp->wcs();

where $coord is one of the following coordinate systems (constants importable via the coords tag, see "Constants")

Coord_fk4      => 'fk4'
Coord_fk5      => 'fk5'
Coord_icrs     => 'icrs'
Coord_galactic => 'galactic'
Coord_ecliptic => 'ecliptic'
Coord_linear   => 'linear'

Constants used below in the other wcs() commands are importable via the wcs tag:

WCS_align   => 'align'
WCS_format  => 'format'
WCS_reset   => 'reset'
WCS_replace => 'replace'
WCS_append  => 'append'

To align or de-align the image to equatorial WCS, or to determine the current alignment state:

$dsp->wcs( WCS_align, $bool );
$align = $dsp->wcs( WCS_align );

To set the output format, or determine what it is:

$dsp->wcs( WCS_format, $format );
$format = $dsp->wcs( WCS_format );

where format is one of

CoordFmt_degrees     => 'degrees'
CoordFmt_sexagesimal => 'sexagesimal'

(constants importable via coord_fmts ).

To reset the WCS:

$dsp->wcs( WCS_reset );

To replace or append to the WCS, using a DS9 compatible WCS record in a file:

$dsp->wcs( WCS_replace, $file );
$dsp->wcs( WCS_append, $file );

To do the same, but with a WCS record in a Perl variable:

$dsp->wcs( $wcs_action, \$wcs );
$dsp->wcs( $wcs_action, \%wcs );
$dsp->wcs( $wcs_action, \@wcs );

where $wcs_action is either WCS_append or WCS_replace. Note that the second argument is a reference, to distinguish it from the previous form which loads the WCS from a file. If it is scalar reference, the scalar should hold the WCS record. If it is a hash reference, a WCS record is constructed from the keys and values. If it is an array reference, the record is constructed by appending a newline to each array value and concatenating the resultant strings.

zoom
$zoom = $dsp->zoom;
$dsp->zoom( abs => $zoom );
$dsp->zoom( rel => $zoom );
$dsp->zoom( $zoom );

This changes the zoom value for the current frame. $zoom is a positive numerical value. A zoom value may be absolute or relative. This is explicitly specified in the second and third forms of the method invocation. If not specified (as in the last form) it is absolute. To zoom such that the image fits with in the frame, specify a zoom value of 0.

If no argument is specified, it returns the zoom value for the current frame.

Set
$dsp->Set( $cmd, $buf )

Send an arbitrary XPA Set command to the DS9 server. If there was an error sending the command to the server, or fewer than expected servers responded, it'll croak(). Messages from the server will be made available via the res() method. See IPC::XPA for more information on the format of those messages.

Get
%results = $dsp->Get( $cmd )

Send an arbitrary XPA Get command to the DS9 Server. If there was an error sending the command to the server, or fewer than expected servers responded, it'll croak(). Messages from the server will be made available via the res() method.

Upon success, it'll return the results of the command. If called in scalar mode, it'll return just one result (if there is more than one server, it returns results from an arbitrary server). In array mode, It'll return a hash, with the hash keys being the names of the server. The hash values are themselves references to hashes containing the results, with a key of buf.

Constants

Many constants have been defined to avoid typographic errors. By default they are not imported into the caller's namespace; they are available via the Image::DS9 namespace, e.g. Image::DS9::CM_invert. Since this is quite a mouthful, various import tags are available which will import some, or all of the constants into the caller's namespace. For example:

use Image::DS9 qw( :frame :tile :filetype :display );

The following tags are available

all
bin
colormap
display
filetype
frame
mode
orient
scale
tile
view
all

This tag imports all of the symbols defined by the other tags, as well as

ON	=> 1
OFF	=> 0
YES	=> 'yes'
NO	=> 'no'
bin
B_about      => 'about'
B_buffersize => 'buffersize'
B_cols       => 'cols'
B_factor     => 'factor'
B_filter     => 'filter'
B_function   => 'function'
B_average    => 'average'
B_sum        => 'sum'
B_to_fit     => 'to fit'
colormap
CM_invert    => 'invert'
coord_fmts
CoordFmt_degrees     => 'degrees'
CoordFmt_sexagesimal => 'sexagesimal'
coords
Coord_fk4      => 'fk4'
Coord_fk5      => 'fk5'
Coord_icrs     => 'icrs'
Coord_galactic => 'galactic'
Coord_ecliptic => 'ecliptic'
Coord_linear   => 'linear'
Coord_image    => 'image'
Coord_physical => 'physical'
display
D_tile   => 'tile'
D_single => 'single'
D_blink  => 'blink'
file
FT_MosaicImage	=> 'mosaicimage'
FT_MosaicImages	=> 'mosaicimages'
FT_Mosaic	=> 'mosaic'
FT_Array	=> 'array'
FT_Save		=> 'save'
frame
FR_active  => 'active'
FR_all	   => 'all'
FR_center  => 'center'
FR_clear   => 'clear'
FR_delete  => 'delete'
FR_first   => 'first'
FR_hide    => 'hide'
FR_last    => 'last'
FR_new     => 'new'
FR_next    => 'next'
FR_prev    => 'prev'
FR_refresh => 'refresh'
FR_reset   => 'reset'
FR_show    => 'show'
mode
MB_pointer	=> 'pointer'
MB_crosshair	=> 'crosshair'
MB_colorbar	=> 'colorbar'
MB_pan		=> 'pan'
MB_zoom		=> 'zoom'
MB_rotate	=> 'rotate'
MB_examine	=> 'examine'
orient
OR_X	=> 'x'
OR_Y	=> 'y'
OR_XY	=> 'xy'
regions
Rg_movefront   => 'movefront'
Rg_moveback    => 'moveback'
Rg_selectall   => 'selectall'
Rg_selectnone  => 'selectnone'
Rg_deleteall   => 'deleteall'
Rg_file        => 'file'
Rg_load	       => 'load'
Rg_save	       => 'save'

Rg_format      => 'format'
Rg_coord       => 'coord'
Rg_coordformat => 'coordformat'
Rg_delim       => 'delim'

Rg_nl          => 'nl
Rg_semicolon   => 'semicolon'

Rg_ds9         => 'ds9'
Rg_saotng      => 'saotng'
Rg_saoimage    => 'saoimage'
Rg_pros        => 'pros'

Rg_return_fmt
Rg_raw
scale
	S_linear   => 'linear'
	S_log	   => 'log'
	S_squared  => 'squared'
	S_sqrt     => 'sqrt'

	S_minmax   => 'minmax'
	S_zscale   => 'zscale'
	S_user     => 'user'

	S_local    => 'local'
	S_global   => 'global'

	S_limits   => 'limits'
	S_mode     => 'mode'
	S_scope    => 'scope'
        S_datasec  => 'datasec'
tile
T_grid	 => 'grid'
T_column => 'column'
T_row	 => 'row'
T_gap	 => 'gap'
T_layout => 'layout'
T_mode	 => 'mode'
T_auto	 => 'automatic'
T_manual => 'manual'
view
V_info      => 'info'
V_panner    => 'panner'
V_magnifier => 'magnifier'
V_buttons   => 'buttons'
V_colorbar  => 'colorbar'
V_horzgraph => 'horzgraph'
V_vertgraph => 'vertgraph'
V_wcs       => 'wcs'
V_detector  => 'detector'
V_amplifier => 'amplifier'
V_physical  => 'physical'
V_image     => 'image'
wcs
WCS_align   => 'align'
WCS_format  => 'format'
WCS_reset   => 'reset'
WCS_replace => 'replace'
WCS_append  => 'append'

REQUIREMENTS

Image::DS9 requires IPC::XPA to be installed. At present, both DS9 and xpans (part of the XPA distribution) must be running prior to any attempts to access DS9. DS9 will automatically start xpans if it is in the user's path.

DS9 is available at http://hea-www.harvard.edu/RD/ds9/.

XPA is available at http://hea-www.harvard.edu/RD/xpa/.

AUTHOR

Diab Jerius ( djerius@cfa.harvard.edu )

SEE ALSO

perl(1), IPC::XPA.