Astro::Catalog::Item - A generic star object in a stellar catalogue.

  $star = new Astro::Catalog::Item(
               ID	    => $id,
               Coords	    => new Astro::Coords(),
               Morphology   => new Astro::Catalog::Item::Morphology(),
               Fluxes	    => new Astro::Fluxes(),
	       Quality      => $quality_flag,
               Field	    => $field,
               GSC	    => $in_gsc,
               Distance     => $distance_to_centre,
               PosAngle     => $position_angle,
               X	    => $x_pixel_coord,
               Y	    => $y_pixel_coord,
               WCS	    => new Starlink::AST(),
               Comment      => $comment_string
	       SpecType     => $spectral_type,
	       StarType     => $star_type,
	       LongStarType => $long_star_type,
	       MoreInfo     => $url,
               InsertDate   => new Time::Piece(),
				  );

package Astro::Catalog::Item;

# ---------------------------------------------------------------------------

#+
#  Name:
#    Astro::Catalog::Item

#  Purposes:
#    Generic star in a catalogue

#  Language:
#    Perl module

#  Description:
#    This module provides a generic star object for the Catalog object

#  Authors:
#    Alasdair Allan (aa@astro.ex.ac.uk)

#  Revision:
#     $Id: Item.pm,v 1.11 2006/01/17 23:43:40 cavanagh Exp $

#  Copyright:
#     Copyright (C) 2002 University of Exeter. All Rights Reserved.

#-

# ---------------------------------------------------------------------------

# L O A D   M O D U L E S --------------------------------------------------

use 5.006;
use strict;
use warnings;
use vars qw/ $VERSION /;
use Carp;
use Astro::Coords;
use Astro::Catalog::Item::Morphology;
use Astro::Fluxes;
use Astro::Flux;
use Astro::FluxColor;

# Register an Astro::Catalog::Item warning category
use warnings::register;

# Radians to arcseconds
# Copied from Astro::SLA just in case Astro::Coords ever loses Astro::SLA
# dependency. I am not really happy about this - TJ
# This is not meant to part of the documented public interface.
use constant DR2AS => 2.0626480624709635515647335733077861319665970087963e5;

'$Revision: 1.11 $ ' =~ /.*:\s(.*)\s\$/ && ($VERSION = $1);

# Internal lookup table for Simbad star types
my %STAR_TYPE_LOOKUP = (
          'vid' => 'Underdense region of the Universe',
          'Er*' => 'Eruptive variable Star',
          'Rad' => 'Radio-source',
          'Q?' => 'Possible Quasar',
          'IR' => 'Infra-Red source',
          'SB*' => 'Spectrocopic binary',
          'C*' => 'Carbon Star',
          'Gl?' => 'Possible Globular Cluster',
          'DNe' => 'Dark Nebula',
          'GlC' => 'Globular Cluster',
          'No*' => 'Nova',
          'V*?' => 'Star suspected of Variability',
          'LeG' => 'Gravitationnaly Lensed Image of a Galaxy',
          'mAL' => 'metallic Absorption Line system',
          'LeI' => 'Gravitationnaly Lensed Image',
          'WU*' => 'Eclipsing binary of W UMa type',
          'Be*' => 'Be Star',
          'PaG' => 'Pair of Galaxies',
          'Mas' => 'Maser',
          'LeQ' => 'Gravitationnaly Lensed Image of a Quasar',
          'mul' => 'Composite object',
          'SBG' => 'Starburst Galaxy',
          '*' => 'Star',
          'gam' => 'gamma-ray source',
          'bL*' => 'Eclipsing binary of beta Lyr type',
          'S*' => 'S Star',
          'El*' => 'Elliptical variable Star',
          'GNe' => 'Galactic Nebula',
          'DQ*' => 'Cataclysmic Var. DQ Her type',
          '?' => 'Object of unknown nature',
          'WV*' => 'Variable Star of W Vir type',
          'SR?' => 'SuperNova Remnant Candidate',
          'Bla' => 'Blazar',
          'G' => 'Galaxy',
          'SCG' => 'Supercluster of Galaxies',
          'OH*' => 'Star with envelope of OH/IR type',
          'Lev' => '(Micro)Lensing Event',
          'BNe' => 'Bright Nebula',
          'RV*' => 'Variable Star of RV Tau type',
          'IR0' => 'IR source at lambda < 10 microns',
          'OVV' => 'Optically Violently Variable object',
          'a2*' => 'Variable Star of alpha2 CVn type',
          'IR1' => 'IR source at lambda > 10 microns',
          'Em*' => 'Emission-line Star',
          'PM*' => 'High proper-motion Star',
          'X' => 'X-ray source',
          'HzG' => 'Galaxy with high redshift',
          'Sy*' => 'Symbiotic Star',
          'LXB' => 'Low Mass X-ray Binary',
          '*i*' => 'Star in double system',
          'Sy1' => 'Seyfert 1 Galaxy',
          'Sy2' => 'Seyfert 2 Galaxy',
          'LIN' => 'LINER-type Active Galaxy Nucleus',
          'rG' => 'Radio Galaxy',
          'Cl*' => 'Cluster of Stars',
          'NL*' => 'Nova-like Star',
          'HV*' => 'High-velocity Star',
          'EmG' => 'Emission-line galaxy',
          '*iA' => 'Star in Association',
          'grv' => 'Gravitational Source',
          '*iC' => 'Star in Cluster',
          'SyG' => 'Seyfert Galaxy',
          'RNe' => 'Reflection Nebula',
          'EmO' => 'Emission Object',
          'Ce*' => 'Classical Cepheid variable Star',
          'CV*' => 'Cataclysmic Variable Star',
          '*iN' => 'Star in Nebula',
          'BY*' => 'Variable of BY Dra type',
          'Pe*' => 'Peculiar Star',
          'AM*' => 'Cataclysmic Var. AM Her type',
          'FU*' => 'Variable Star of FU Ori type',
          'HVC' => 'High-velocity Cloud',
          'ClG' => 'Cluster of Galaxies',
          'Ir*' => 'Variable Star of irregular type',
          'PN?' => 'Possible Planetary Nebula',
          'ALS' => 'Absorption Line system',
          'cm' => 'centimetric Radio-source',
          'As*' => 'Association of Stars',
          'V*' => 'Variable Star',
          'Fl*' => 'Flare Star',
          'EB*' => 'Eclipsing binary',
          'CGG' => 'Compact Group of Galaxies',
          'UV' => 'UV-emission source',
          'Ro*' => 'Rotationally variable Star',
          'SN*' => 'SuperNova',
          'pr*' => 'Pre-main sequence Star',
          'CH*' => 'Star with envelope of CH type',
          'Al*' => 'Eclipsing binary of Algol type',
          'Pu*' => 'Pulsating variable Star',
          'Cld' => 'Cloud of unknown nature',
          'QSO' => 'Quasar',
          'Psr' => 'Pulsars',
          'GiC' => 'Galaxy in Cluster of Galaxies',
          'V* RI*' => 'Variable Star with rapid variations',
          'sh' => 'HI shell',
          'GiG' => 'Galaxy in Group of Galaxies',
          'OpC' => 'Open (galactic) Cluster',
          'WR*' => 'Wolf-Rayet Star',
          'BCG' => 'Blue compact Galaxy',
          'blu' => 'Blue object',
          'GiP' => 'Galaxy in Pair of Galaxies',
          'LyA' => 'Ly alpha Absorption Line system',
          'CGb' => 'Cometary Globule',
          '**' => 'Double or multiple star',
          'H2G' => 'HII Galaxy',
          'RR*' => 'Variable Star of RR Lyr type',
          'HB*' => 'Horizontal Branch Star',
          'RC*' => 'Variable Star of R CrB type',
          'SNR' => 'SuperNova Remnant',
          'MoC' => 'Molecular Cloud',
          'HXB' => 'High Mass X-ray Binary',
          'mR' => 'metric Radio-source',
          'TT*' => 'T Tau-type Star',
          'DN*' => 'Dwarf Nova',
          'eg sr*' => 'Semi-regular pulsating Star',
          'HII' => 'HII (ionized) region',
          'HH' => 'Herbig-Haro Object',
          'HI' => 'HI (neutral) region',
          'WD*' => 'White Dwarf',
          'Or*' => 'Variable Star in Orion Nebula',
          'dS*' => 'Variable Star of delta Sct type',
          'DLy' => 'Dumped Ly alpha Absorption Line system',
          'AGN' => 'Active Galaxy Nucleus',
          'GrG' => 'Group of Galaxies',
          'Mi*' => 'Variable Star of Mira Cet type',
          'RS*' => 'Variable of RS CVn type',
          'mm' => 'millimetric Radio-source',
          'red' => 'Very red source',
          'BLL' => 'BL Lac - type object',
          'reg' => 'Region defined in the sky',
          'PN' => 'Planetary Nebula',
          'ZZ*' => 'Variable White Dwarf of ZZ Cet type',
          'gB' => 'gamma-ray Burster',
          'PoC' => 'Part of Cloud',
          'XB*' => 'X-ray Binary',
          'PoG' => 'Part of a Galaxy',
          'Neb' => 'Nebula of unknown nature'
        );


# C O N S T R U C T O R ----------------------------------------------------

sub new {
  my $proto = shift;
  my $class = ref($proto) || $proto;

  # bless the query hash into the class
  my $block = bless { ID         => undef,
                      FLUXES     => undef,
                      MORPHOLOGY => undef,
                      QUALITY    => undef,
                      FIELD      => undef,
                      GSC        => undef,
                      DISTANCE   => undef,
                      POSANGLE   => undef,
		      COORDS     => undef,
                      X          => undef,
                      Y          => undef,
                      WCS        => undef,
                      COMMENT    => undef,
		      SPECTYPE   => undef,
		      STARTYPE   => undef,
		      LONGTYPE   => undef,
		      MOREINFO   => undef,
                      INSERTDATE => undef,
                      PREFERRED_MAG_TYPE => undef,
		    }, $class;

  # If we have arguments configure the object
  $block->configure( @_ ) if @_;

  return $block;

}

# A C C E S S O R  --------------------------------------------------------

sub id {
  my $self = shift;
  if (@_) {
    $self->{ID} = shift;

    my $c = $self->coords;
    $c->name( $self->{ID} ) if defined $c;
  }
  return $self->{ID};
}

sub coords {
  my $self = shift;
  if (@_) {
    my $c = shift;
    croak "Coordinates must be an Astro::Coords object"
      unless UNIVERSAL::isa($c, "Astro::Coords");

    # force the ID and comment to match
    $self->id( $c->name ) if defined $c->name;
    $self->comment( $c->comment ) if $c->comment;

    # Store the new coordinate object
    # Storing it late stops looping from the id and comment methods
    $self->{COORDS} = $c;

  }
  return $self->{COORDS};
}

sub ra {
  my $self = shift;
  if (@_) {
    my $ra = shift;

    # Issue a warning specifically for this call
    my @info = caller();
    warnings::warnif("deprecated","Use of ra() method for setting RA now deprecated. Please use the coords() method instead, at $info[1] line $info[2]");


    # Get the coordinate object
    my $c = $self->coords;
    if (defined $c) {
      # Need to tweak RA?
      croak "Can only adjust RA with Astro::Coords::Equatorial coordinates"
	unless $c->isa("Astro::Coords::Equatorial");

      # For now need to kluge since Astro::Coords does not allow
      # you to change the position (it is an immutable object)
      $c = $c->new( type => 'J2000',
		    dec => $c->dec(format => 's'),
		    ra => $ra,
		  );

    } else {
      $c = new Astro::Coords( type => 'J2000',
			      ra => $ra,
			      dec => '0',
			    );
    }

    # Update the object
    $self->coords($c);
  }

  my $outc = $self->coords;
  return unless defined $outc;

  # Astro::Coords inserts colons by default. Grab the old delimiter
  # and number of decimal places if we're using a recent enough
  # version of Astro::Coords.
  my $ra = $outc->ra;
  if (UNIVERSAL::isa( $ra, "Astro::Coords::Angle" ) ) {

    $ra->str_delim( ' ' );
    $ra->str_ndp( 2 );
    return "$ra";

  } else {

    my $outra = $outc->ra(format => 's');
    $outra =~ s/:/ /g;
    $outra =~ s/^\s*//;

    return $outra;
  }
}

sub dec {
  my $self = shift;
  if (@_) {
    my $dec = shift;

    # Issue a warning specifically for this call
    my @info = caller();
    warnings::warnif("deprecated","Use of ra() method for setting RA now deprecated. Please use the coords() method instead, at $info[1] line $info[2]");

    # Get the coordinate object
    my $c = $self->coords;
    if (defined $c) {
      # Need to tweak RA?
      croak "Can only adjust Dec with Astro::Coords::Equatorial coordinates"
	unless $c->isa("Astro::Coords::Equatorial");

      # For now need to kluge since Astro::Coords does not allow
      # you to change the position (it is an immutable object)
      $c = $c->new( type => 'J2000',
		    ra => $c->ra(format => 's'),
		    dec => $dec,
		  );

    } else {
      $c = new Astro::Coords( type => 'J2000',
			      dec => $dec,
			      ra => 0,
			    );
    }

    # Update the object
    $self->coords($c);
  }

  my $outc = $self->coords;
  return unless defined $outc;

  # Astro::Coords inserts colons by default. Grab the old delimiter
  # and number of decimal places if we're using a recent enough
  # version of Astro::Coords.
  my $dec = $outc->dec;
  if( UNIVERSAL::isa( $dec, "Astro::Catalog::Angle" ) ) {

    $dec->str_delim( ' ' );
    $dec->str_ndp( 2 );
    $dec = "$dec";
    $dec = (substr($dec,0,1) eq '-' ? '' : '+' ) . $dec;
    return $dec;

  } else {

    my $outdec = $outc->dec(format => 's');
    $outdec =~ s/:/ /g;
    $outdec =~ s/^\s*//;

    # require leading sign for backwards compatibility
    # Sign will be there for negative
    $outdec = (substr($outdec,0,1) eq '-' ? '' : '+' ) . $outdec;

    return $outdec;
  }
}

sub fluxes {
  my $self = shift;
  if (@_) {
    my $flux = shift;
    my $flag = shift;
    croak "Flux must be an Astro::Fluxes object"
      unless UNIVERSAL::isa($flux, "Astro::Fluxes");

    if ( defined $self->{FLUXES} ) {
      if ( defined $flag ) {
        $self->{FLUXES} = $flux;
      } else {
        $self->{FLUXES}->merge( $flux );
      }
    } else {
      $self->{FLUXES} = $flux;
    }
  }
  return $self->{FLUXES};
}

sub what_filters {
  my $self = shift;

  my $fluxes = $self->{FLUXES};
  
  #use Data::Dumper; print Dumper( $self->{FLUXES} );
  my @mags = $fluxes->original_wavebands('filters') if defined $fluxes;
  
  # return array of filters or number if called in scalar context
  return wantarray ? @mags : scalar( @mags );
}

sub what_colours {
  my $self = shift;

  my $fluxes = $self->{FLUXES};
  my @cols = $fluxes->original_colors() if defined $fluxes;
    
  # return array of colours or number if called in scalar context
  return wantarray ? @cols : scalar( @cols );
}

sub get_magnitude {
  my $self = shift;
  #warnings::warn("Astro::Item::get_magnitude is deprecated") 
  #					  if warnings::enabled();
					   
  my $magnitude;
  if (@_) {

     # grab passed filter
     my $filter = shift;
     my $fluxes = $self->{FLUXES};
     $magnitude = $fluxes->flux( waveband => $filter,
                                 type => $self->preferred_magnitude_type );

     if( defined( $magnitude ) ) {
       return $magnitude->quantity( $self->preferred_magnitude_type );
     } else {
       return undef;
     }
  }
}

sub get_flux_quantity {
  my $self = shift;
  my %args = @_;

  if( ! defined( $args{'waveband'} ) ) {
    croak "Must supply waveband to Astro::Catalog::Item->get_flux_quantity()";
  }
  if( ! defined( $args{'type'} ) ) {
    croak "Must supply flux type to Astro::Catalog::Item->get_flux_quantity()";
  }

  my $waveband;
  if( ! UNIVERSAL::isa( $args{'waveband'}, "Astro::WaveBand" ) ) {
    $waveband = new Astro::WaveBand( Filter => $args{'waveband'} );
  } else {
    $waveband = $args{'waveband'};
  }

  my $fluxes = $self->fluxes;
  if( defined( $fluxes ) ) {
    my $flux = $fluxes->flux( waveband => $waveband, type => $args{'type'} );
    if( defined( $flux ) ) {
      return $flux->quantity( $args{'type'} );
    }
  }
  return undef;
}

sub get_errors {
  my $self = shift;
  #warnings::warn("Astro::Item::get_errors is deprecated") 
  #					  if warnings::enabled();

  my $mag_error;
  if (@_) {

    # grab passed filter
    my $filter = shift;
    my $fluxes = $self->{FLUXES};
    my $magnitude = $fluxes->flux( waveband => $filter,
                                   type => $self->preferred_magnitude_type );
    if( defined( $magnitude ) ) {
      return $magnitude->error( $self->preferred_magnitude_type );
    } else {
      return undef;
    }
  }
  return $mag_error;
}

sub get_flux_error {
  my $self = shift;
  my %args = @_;

  if( ! defined( $args{'waveband'} ) ) {
    croak "Must supply waveband to Astro::Catalog::Item->get_flux_error()";
  }
  if( ! defined( $args{'type'} ) ) {
    croak "Must supply flux type to Astro::Catalog::Item->get_flux_error()";
  }

  my $waveband;
  if( ! UNIVERSAL::isa( $args{'waveband'}, "Astro::WaveBand" ) ) {
    $waveband = new Astro::WaveBand( Filter => $args{'waveband'} );
  } else {
    $waveband = $args{'waveband'};
  }
  my $fluxes = $self->fluxes;
  if( defined( $fluxes ) ) {
    my $flux = $fluxes->flux( waveband => $waveband, type => $args{'type'} );
    if( defined( $flux ) ) {
      return $flux->error( $args{'type'} );
    }
  }
  return undef;
}

sub get_colour {
  my $self = shift;
  #warnings::warn("Astro::Item::get_colour is deprecated") 
  #					  if warnings::enabled();
  
  my $value;
  if (@_) {

     # grab passed colour
     my $colour = shift;
     my @filters = split "-", $colour;
     my $fluxes = $self->{FLUXES};
     my $color = $fluxes->color( 
        upper => new Astro::WaveBand( Filter => $filters[0] ),
        lower => new Astro::WaveBand( Filter => $filters[1] ) );
     $value = $color->quantity('mag');	
  }
  return $value;
}

sub get_colourerr {
  my $self = shift;
  #warnings::warn("Astro::Item::get_colourerr is deprecated") 
  #					  if warnings::enabled();

  my $col_error;
  if (@_) {

     # grab passed colour
     my $colour = shift;
     my @filters = split "-", $colour;
     my $fluxes = $self->{FLUXES};
     my $color = $fluxes->color( 
        upper => new Astro::WaveBand( Filter => $filters[0] ),
        lower => new Astro::WaveBand( Filter => $filters[1] ) );
	
     #use Data::Dumper; print Dumper( $color );
     $col_error = $color->error('mag');	
     
    
  }
  return $col_error;
}

sub preferred_magnitude_type {
  my $self = shift;
  if( @_ ) {
    my $type = shift;
    $self->{PREFERRED_MAG_TYPE} = $type;
  }

  if( ! defined( $self->{PREFERRED_MAG_TYPE} ) ) {
    $self->{PREFERRED_MAG_TYPE} = 'MAG';
  }

  return $self->{PREFERRED_MAG_TYPE};
}

sub morphology {
  my $self = shift;
  if (@_) {
    my $m = shift;
    croak "Morphology must be an Astro::Catalog::Item::Morphology object"
      unless UNIVERSAL::isa($m, "Astro::Catalog::Item::Morphology");

    # Store the new coordinate object
    # Storing it late stops looping from the id and comment methods
    $self->{MORPHOLOGY} = $m;
  }
  return $self->{MORPHOLOGY};
}

sub quality {
  my $self = shift;
  if (@_) {
  
    # 2MASS hack
    # ----------
    # quick, dirty and ultimately icky hack. The entire quality flag
    # code is going to have to be rewritten so it works like mag errors,
    # and gets assocaited with a magnitude. For now, if the JHK QFlag
    # for 2MASS is A,B or C then the internal quality flag is 0 (good),
    # otherwise it gets set to 1 (bad). This pretty much sucks.
    
    # Yes Tim, I know I'm doing this in the wrong place. I'm panicing 
    # I'll fix it later. I've moved the Cluster specific hack about the
    # star ID's out of Astro::Catalog::query::USNOA2 and into the Cluster
    # IO module and used Scalar::Util to figure out whether I've got a
    # number (neat solution) before blowing it away.
    
    # Anyway...
    my $quality = shift;
    
    # Shouldn't happen?
    unless ( defined $quality ) {
      $self->{QUALITY} = undef;
      return undef;
    }  

    if ( $quality =~ /^[A-Z][A-Z][A-Z]$/ ) {
       
       $_ = $quality;
       m/^([A-Z])([A-Z])([A-Z])$/;
       
       my $j_quality = $1;
       my $h_quality = $2;
       my $k_quality = $3;
       
       if ( ($j_quality eq 'A' || $j_quality eq 'B' || $j_quality eq 'C') &&
            ($h_quality eq 'A' || $h_quality eq 'B' || $h_quality eq 'C') ) {
       
          # good quality
          $self->{QUALITY} = 0;
          
       } else { 
          # bad quality  
          $self->{QUALITY} = 1;
       }
       
    } else {
    
       $self->{QUALITY} = $quality;
    }
          
  }
  return $self->{QUALITY};
}

sub field {
  my $self = shift;
  if (@_) {
    $self->{FIELD} = shift;
  }
  return $self->{FIELD};
}

sub gsc {
  my $self = shift;
  if (@_) {
    $self->{GSC} = shift;
  }
  return $self->{GSC};
}

sub distance {
  my $self = shift;
  if (@_) {
    $self->{DISTANCE} = shift;
  }
  return $self->{DISTANCE};
}

sub posangle {
  my $self = shift;
  if (@_) {
    $self->{POSANGLE} = shift;
  }
  return $self->{POSANGLE};
}

sub x {
  my $self = shift;
  if (@_) {
    $self->{X} = shift;
  }

  if( ! defined( $self->{X} ) &&
      defined( $self->wcs ) &&
      defined( $self->coords ) ) {

    # We need to get a template FK5 SkyFrame to be able to convert
    # properly between RA/Dec and X/Y, but we can only do this if
    # we load Starlink::AST. So that we don't have a major dependency
    # on that module, load it here at runtime.
    eval( "require Starlink::AST" );
    if( $@ ) {
      croak "Attempted to convert from RA/Dec to X position and cannot load Starlink::AST. Error: $@";
    }
    my $template = new Starlink::AST::SkyFrame( "System=FK5" );
    my $wcs = $self->wcs;
    my $frameset = $wcs->FindFrame( $template, "" );
    if( ! defined( $frameset ) ) {
      croak "Could not find FK5 SkyFrame to do RA/Dec to X position translation";
    }
    my( $ra, $dec ) = $self->coords->radec();
    my( $x, $y ) = $frameset->Tran2( [$ra->radians],
                                     [$dec->radians],
                                     0 );
    $self->{X} = $x->[0];
  }
  return $self->{X};
}

sub y {
  my $self = shift;
  if (@_) {
    $self->{Y} = shift;
  }

  if( ! defined( $self->{Y} ) &&
      defined( $self->wcs ) &&
      defined( $self->coords ) ) {

    # We need to get a template FK5 SkyFrame to be able to convert
    # properly between RA/Dec and X/Y, but we can only do this if
    # we load Starlink::AST. So that we don't have a major dependency
    # on that module, load it here at runtime.
    eval( "require Starlink::AST" );
    if( $@ ) {
      croak "Attempted to convert from RA/Dec to Y position and cannot load Starlink::AST. Error: $@";
    }
    my $template = new Starlink::AST::SkyFrame( "System=FK5" );
    my $wcs = $self->wcs;
    my $frameset = $wcs->FindFrame( $template, "" );
    if( ! defined( $frameset ) ) {
      croak "Could not find FK5 SkyFrame to do RA/Dec to Y position translation";
    }
    my( $ra, $dec ) = $self->coords->radec();
    my( $x, $y ) = $frameset->Tran2( [$ra->radians],
                                     [$dec->radians],
                                     0 );
    $self->{Y} = $y->[0];
  }

  return $self->{Y};
}

sub wcs {
  my $self = shift;
  if( @_ ) {
    my $wcs = shift;
    if( ! defined( $wcs ) ) {
      $self->{WCS} = undef;
    } elsif( UNIVERSAL::isa( $wcs, "Starlink::AST" ) ) {
      $self->{WCS} = $wcs;
    }
  }
  return $self->{WCS};
}

sub comment {
  my $self = shift;
  if (@_) {
    $self->{COMMENT} = shift;

    my $c = $self->coords;
    $c->comment( $self->{COMMENT} ) if defined $c;
  }
  return $self->{COMMENT};
}

sub spectype {
  my $self = shift;
  if (@_) {
    $self->{SPECTYPE} = shift;
  }
  return $self->{SPECTYPE};
}

sub startype {
  my $self = shift;
  if (@_) {
    $self->{STARTYPE} = shift;
  }
  return $self->{STARTYPE};
}

sub longstartype {
  my $self = shift;
  if (@_) {
    $self->{LONGTYPE} = shift;
  }
  # if we have nothing, attempt a look up
  if (!defined $self->{LONGTYPE} && defined $self->startype
     && exists $STAR_TYPE_LOOKUP{$self->startype}) {
    return $STAR_TYPE_LOOKUP{$self->startype};
  } else {
    return $self->{STARTYPE};
  }
}

sub moreinfo {
  my $self = shift;
  if (@_) {
    $self->{MOREINFO} = shift;
  }
  return $self->{MOREINFO};
}

sub insertdate {
  my $self = shift;
  if( @_ ) {
    $self->{INSERTDATE} = shift;
  }
  return $self->{INSERTDATE};
}

sub fluxdatestamp {
  my $self = shift;
  if( @_ ) {
    my $datetime = shift; 
    croak "Astro::Catalog::Item::fluxdatestamp()\n".
          "Error: Not a DateTime object\n"
                      unless UNIVERSAL::isa( $datetime, "DateTime" );   
    $self->{FLUXES}->datestamp( $datetime );
  }
  return $self->{FLUXES};
}

sub distancetostar {
  my $self = shift;
  my $other = shift;
  
  croak "Astro::Catalog::Item::distancetostar()\n".
        "Error: Not an Astro::Catalog::Item object\n"
        unless UNIVERSAL::isa( $other, "Astro::Catalog::Item" );    
  
  my $radsep = $self->coords->distance( $other->coords );
  my $assep = $radsep * Astro::Catalog::Item::DR2AS;
  
  my $distance = $assep;
  return $distance;
}

sub within {
  my $self = shift;
  my $other = shift;
  my $max = shift;
 
  croak "Astro::Catalog::Item::within()\n".
        "Error: Not an Astro::Catalog::Item object\n"
        unless UNIVERSAL::isa( $other, "Astro::Catalog::Item" );    
	  
  my $distance = $self->distancetostar( $other );
  return 1 if $distance < $max;
  return 0;  
}

sub magnitudes {
  my $self = shift;
  croak "Astro::Catalog::Item::magnitudes()\n" .
        "This method is no longer supported, use fluxes() instead.\n";
}

sub magerr {
  my $self = shift;
  croak "Astro::Catalog::Item::magerr()\n" .
        "This method is no longer supported, use fluxes() instead.\n";
}


sub colours {
  my $self = shift;
  croak "Astro::Catalog::Item::colours()\n" .
        "This method is no longer supported, use fluxes() instead.\n";

}

sub colerr {
  my $self = shift;
  croak "Astro::Catalog::Item::colerr()\n" .
   "This method is no longer supported, use fluxes() instead.\n";

}


# C O N F I G U R E -------------------------------------------------------

sub configure {
  my $self = shift;

  # return unless we have arguments
  return unless @_;

  # grab the argument list
  my %args = @_;

  # First check for duplicate keys (case insensitive) with different
  # values and store the unique lower-cased keys
  my %check;
  for my $key (keys %args) {
    my $lckey = lc($key);
    if (exists $check{$lckey} && $check{$lckey} ne $args{$key}) {
      warnings::warnif("Duplicated key in constructor [$lckey] with differing values ".
	" '$check{$lckey}' and '$args{$key}'\n");
    }
    $check{$lckey} = $args{$key};
  }

  # Now that we have lower cased keys we can look to see if we have
  # ra & dec as well as coords and also verify that they are actually
  # the same if we have them
  if (exists $check{coords} && (exists $check{ra} || exists $check{dec})) {
    # coords + one of ra or dec is a mistake
    if (exists $check{ra} && exists $check{dec}) {
      # Create a new coords object - assume J2000
      my $c = new Astro::Coords( type => 'J2000',
				 ra => $check{ra},
				 dec => $check{dec},
#				 units => 'sex',
			       );

      # Make sure we have the same reference place and time
      $c->datetime( $check{coords}->datetime ) 
	if $check{coords}->has_datetime;
      $c->telescope( $check{coords}->telescope ) 
	if defined $check{coords}->telescope;


      # Check the distance
      my $d = $c->distance( $check{coords} );

      # Raise warn if the error is more than 1 arcsecond
      my $arcsec = $d * DR2AS;
      warnings::warnif( "Coords and RA/Dec were specified and they differ by more than 1 arcsec [$arcsec sec]. Ignoring RA/Dec keys.\n")
	if $arcsec > 1;

    } elsif (!exists $check{ra}) {
      warnings::warnif("Dec specified in addition to Coords but without RA. Ignoring it.");
    } elsif (!exists $check{dec}) {
      warnings::warnif("RA specified in addition to Coords but without Dec. Ignoring it.");
    }

    # Whatever happens we do not want ra and dec here
    delete $check{dec};
    delete $check{ra};
  } elsif (exists $check{ra} || $check{dec}) {
    # Generate a Astro::Coords object here in one go rather than
    # relying on the old ra() dec() methods individually
    my $ra = $check{ra} || 0.0;
    my $dec = $check{dec} || 0.0;
    $check{coords} = new Astro::Coords( type => 'J2000',
					ra => $ra,
					dec => $dec );
    delete $check{ra};
    delete $check{dec};
  }

  # Loop over the allowed keys storing the values
  # in the object if they exist. Case insensitive.
  for my $key (keys %check) {
    my $method = lc($key);
    $self->$method( $check{$key} ) if $self->can( $method );
  }
  return;
}

# T I M E   A T   T H E   B A R  --------------------------------------------

# L A S T  O R D E R S ------------------------------------------------------

1;