voruby 1.1.1 → 2.0.0

data/lib/voruby/sky_query/sky_query.rb

@@ -0,0 +1,192 @@
+require 'ostruct'
+
+begin
+  require 'rubygems'
+rescue LoadError; end
+
+gem 'soap4r'
+require 'soap/wsdlDriver'
+
+require 'voruby/votable/1.1/votable'
+
+module VORuby
+  module SkyQuery
+    class Service
+      attr_accessor :namespace
+      attr_reader :end_point
+      
+      # Query the SkyQuery service. A VOTable::V1_1::VOTable is returned.
+      #   Service.query('SELECT o.objid, o.ra, o.dec FROM SDSS:PhotoPrimary o WHERE o.type = 3')
+      # This is a convenience method for
+      #   Service.new.query('SELECT o.objid, o.ra, o.dec FROM SDSS:PhotoPrimary o WHERE o.type = 3')
+      def self.query(adql, node=nil, options={})
+        self.new(options).query(adql, node)
+      end
+      
+      # Create a new SkyQuery service instance.
+      # Currently the only valid keys in the <tt>options</tt> hash is <tt>:end_point</tt>
+      # representing the location of the SkyQuery soap service and <tt>:namespace</tt>
+      # representing the namespace of that service.  The default is to use OpenSkyQuery
+      # (i.e. end_point = http://openskyquery.net/Sky/SkyPortal/SkyPortal.asmx and
+      # namespace = SkyPortal.ivoa.net)
+      #   portal = SkyQuery.new
+      def initialize(options={})
+        self.namespace = options[:namespace] || 'SkyPortal.ivoa.net'
+        self.end_point = options[:end_point] || 'http://openskyquery.net/Sky/SkyPortal/SkyPortal.asmx'
+      end
+      
+      # Set the locaton of the SkyPortal webservice.
+      def end_point=(end_point)
+        @end_point = end_point
+
+        # Create the driver.
+        # We don't use the WSDL since we won't expose all possible methods.
+        @portal = SOAP::RPC::Driver.new(self.end_point, self.namespace)
+        #@extractor.wiredump_dev = STDOUT
+        @portal.return_response_as_xml = true  # in prep for dumping the result into a VORuby::VOTable
+        
+        # Below, we're assuming the namespace prefix for SkyPortal.ivoa.net will always be n1.
+        
+        # Queries
+        @portal.add_method_with_soapaction(
+          'SubmitDistributedQuery',
+          "#{self.namespace}/SubmitDistributedQuery",
+          'n1:qry', 'n1:outputType'
+        )
+        @portal.add_method_with_soapaction(
+          'SubmitQuery',
+          "#{self.namespace}/SubmitQuery",
+          'n1:qry', 'n1:node', 'n1:outputType'
+        )
+        
+        # Table data
+        @portal.add_method_with_soapaction(
+          'GetTables',
+          "#{self.namespace}/GetTables",
+          'n1:node'
+        )
+        @portal.add_method_with_soapaction(
+          'GetTableInfo',
+          "#{self.namespace}/GetTableInfo",
+          'n1:node', 'n1:table'
+        )
+        
+        # Column data
+        @portal.add_method_with_soapaction(
+          'GetMetaColumns',
+          "#{self.namespace}/GetMetaColumns",
+          'n1:node', 'n1:table'
+        )
+        @portal.add_method_with_soapaction(
+          'GetColumnInfo',
+          "#{self.namespace}/GetColumnInfo",
+          'n1:node', 'n1:table', 'n1:column'
+        )
+        @portal.add_method_with_soapaction(
+          'GetColumns',
+          "#{self.namespace}/GetColumns",
+          'n1:node', 'n1:table'
+        )
+        
+        # Misc
+        @portal.add_method_with_soapaction(
+          'GetAllSkyNodesVOTable',
+          "#{self.namespace}/GetAllSkyNodesVOTable"
+        )
+      end
+      
+      # Find all nodes available from the SkyPortal service.
+      # Returns a VOTable::V1_1::VOTable.
+      def sky_nodes
+        response = @portal.call('GetAllSkyNodesVOTable')
+        parse_votable(response, 'GetAllSkyNodesVOTableResult')
+      end
+      
+      # Query the SkyQuery service.  A VOTable::V1_1::VOTable is returned.
+      #   votable = portal.query('SELECT o.objid, o.ra, o.dec FROM SDSS:PhotoPrimary o WHERE o.type = 3') # typical, distributed query
+      #   votable = portal.query('SELECT o.objid, o.ra, o.dec FROM SDSS:PhotoPrimary o WHERE o.type = 3', 'SDSS') # query a particular node (unusual)
+      def query(adql, node=nil)
+        response = node ?
+          @portal.call('SubmitQuery', adql.to_s, node, 'votable') :
+          @portal.call('SubmitDistributedQuery', adql.to_s, 'votable')
+          
+        parse_votable(response)
+      end
+      
+      # Retrieve the list of tables associated with the specified node.
+      # Returns a list of objects with #name, #description and #rows fields.
+      #   tables = portal.tables('SDSS')
+      def tables(node)
+        response = @portal.call('GetTables', node.to_s)
+        XML::Parser.string(response).parse.root.find("//*[local-name()='MetaTable']").collect{ |mt| parse_meta_table(mt) }
+      end
+      
+      # Retrieve the metadata associated with the specified table.
+      # Returns an object with #name, #description and #rows fields.
+      #   info = portal.table_info('SDSS', 'PhotoPrimary')
+      def table_info(node, table)
+        response = @portal.call('GetTableInfo', node.to_s, table.to_s)
+        xml = XML::Parser.string(response).parse.root.find_first("//*[local-name()='GetTableInfoResult']")
+        parse_meta_table(xml)
+      end
+      
+      # Retrieve the metadata associated with the columns of the specified table.
+      # Returns a list of objects with #name, #unit, #description and #ucd fields.
+      #  columns = portal.meta_columns('SDSS', 'PhotoPrimary')
+      def meta_columns(node, table)
+        response = @portal.call('GetMetaColumns', node.to_s, table.to_s)
+        XML::Parser.string(response).parse.root.find("//*[local-name()='MetaColumn']").collect{ |mc| parse_meta_column(mc) }
+      end
+      
+      # Retrieve the metadata associated with the specified column.
+      # Returns an object with #name, #unit, #description and #ucd fields.
+      #   info = portal.column_info('SDSS', 'PhotoPrimary', 'modelMag_i')
+      def column_info(node, table, column)
+        response = @portal.call('GetColumnInfo', node.to_s, table.to_s, column.to_s)
+        xml = XML::Parser.string(response).parse.root.find_first("//*[local-name()='GetColumnInfoResult']")
+        parse_meta_column(xml)
+      end
+      
+      # Retrieve the list of columns associated with the specified table.
+      # Returns a list of column names.
+      #   column_names = portal.columns('SDSS', 'PhotoPrimary')
+      def columns(node, table)
+        response = @portal.call('GetColumns', node.to_s, table.to_s)
+        XML::Parser.string(response).parse.root.find("//*[local-name()='string']").collect { |c| c.content }
+      end
+      
+      private
+      
+      def parse_meta_table(xml)
+        return nil if !xml.child?
+        
+        defn = {}
+        xml.each_child do |child|
+          defn[child.name.downcase.to_sym] = child.name == 'Rows' ? Integer(child.content) : child.content.strip
+        end
+        
+        defn.empty? ? nil : OpenStruct.new(defn)
+      end
+      
+      def parse_meta_column(xml)
+        return nil if !xml.child?
+        
+        defn = {}
+        xml.each_child do |child|
+          defn[child.name.downcase.to_sym] = child.content.strip
+        end
+        
+        defn.empty? ? nil : OpenStruct.new(defn)
+      end
+      
+      def parse_votable(xml, element='VOTABLE')
+        root = XML::Parser.string(xml).parse.root
+        vot_node = root.find_first("//*[local-name()='#{element}']")
+        raise "Unable to find votable in response: #{root}" if !vot_node
+        
+        VORuby::VOTable.from_xml(vot_node)
+      end
+    end
+    
+  end
+end

data/lib/voruby/stc/1.10/coords.rb

@@ -0,0 +1,2272 @@
+require 'date'
+require 'uri'
+require 'voruby/stc/support'
+
+module VORuby
+  module STC
+    module V1_10
+      module Coords
+        include XMLUtilities
+
+        # Basic unit type
+        class Unit < Enumeration; end
+        
+        # Time units may be second (s), hour (h: 3600 s), day (d: 86400 s),
+        # Julian year (a, yr: 365.25 d), Julian century (cy: 36525 d), or
+        # empty (i.e., dimensionless) for ISO-8601 format
+        class TimeUnit < Unit
+          def self.choices
+            ['s', 'h', 'd', 'a', 'yr', 'cy', '']
+          end
+          
+          def initialize(u='')
+            u ||= ''
+            super(u.to_s)
+          end
+        end
+        
+        # Coordinate units may be angular (degrees, radians, hours, arcmins, arcsecs),
+        # linear (meters, km, mm, AUs, parsecs, kpc, Mpc, lightyears), or empty
+        # (i.e., dimensionless)
+        class PosUnit < Unit
+          def self.choices
+            [
+              'deg', 'deg deg m', 'rad', 'h', 'arcmin', 'arcsec', 'm', 'km',
+              'mm', 'au', 'pc', 'kpc', 'Mpc', 'lyr', ''
+            ]
+          end
+          
+          def initialize(u='')
+            u ||= ''
+            super(u.to_s)
+          end
+        end
+        
+        # Angular coordinate units may be degrees, radians, hours, arcmins, arcsecs
+        class AngleUnit < Unit
+          def self.choices
+            ['deg', 'rad', 'h', 'arcmin', 'arcsec']
+          end
+        end
+        
+        # Velocity units are a posUnitType / velTimeType; the latter may be second,
+        # day, hour, year (a or yr), century, but not empty
+        class VelTimeUnit < Unit
+          def self.choices
+            ['s', 'h', 'd', 'a', 'yr', 'cy']
+          end
+        end
+        
+        # Spectral units may be frequency (Hz, kHz, MHz, GHz), wavelength (meters,
+        # mm, micron, nm, Angstrom), or energy (eV, keV, MeV, GeV, TeV)
+        class SpectralUnit < Unit
+          def self.choices
+            [
+              'Hz', 'kHz', 'MHz', 'GHz',
+              'm', 'mm', 'micron', 'nm', 'A',
+              'eV', 'keV', 'MeV', 'GeV', 'TeV'
+            ]
+          end
+        end
+        
+        # The actual time scale used: TT, TAI, UTC, TDB, etc.
+        class TimeScale < Enumeration
+          def self.choices
+            [
+              'TT', 'TDT', 'ET',
+              'TDB', 'TCG', 'TCB',
+              'TAI', 'IAT',
+              'UTC', 'LST', 'LOCAL'
+            ]
+          end
+        end
+        
+        # Substitution group for AbsoluteTime component of AstronTime
+        module AbsoluteTime
+          include SerializableToXml
+          
+          def ==(time)
+            self.value == time.value
+          end
+        end
+        
+        # ISO8601 time; note: only a limited subset of ISO 8601 is allowed: yyyy-mm-ddThh:mm:ss.sss...
+        class ISOTime
+          include AbsoluteTime
+          
+          attr_reader :value
+          
+          def initialize(dt)
+            self.value = dt
+          end
+          
+          def value=(dt)
+            @value = dt.is_a?(DateTime) ? dt : DateTime.parse(dt.to_s)
+          end
+          
+          def to_s
+            self.value.strftime("%FT%T.000")
+          end
+          
+          def to_xml
+            el = element()
+            el.text = self.to_s
+            collapse_namespaces(el)
+            el
+          end
+          
+          def self.from_xml(xml)
+            ISOTime.new(element_from(xml).text)
+          end
+        end
+        
+        # IDREF to an ISO8601 time
+        class ISOTimeRef < IdRef
+          include AbsoluteTime
+        end
+        
+        # JD time
+        class JDTime
+          include AbsoluteTime
+          
+          attr_reader :value
+          
+          def initialize(dt)
+            self.value = dt
+          end
+          
+          def value=(dt)
+            @value = Float(dt)
+          end
+          
+          def to_s
+            self.value.to_s
+          end
+          
+          def to_datetime
+            DateTime.jd(self.value)
+          end
+          
+          def to_xml
+            el = element()
+            el.text = self.value.to_s
+            collapse_namespaces(el)
+            el
+          end
+          
+          def self.from_xml(xml)
+            JDTime.new(element_from(xml).text)
+          end
+        end
+        
+        # IDREF to a JD time
+        class JDTimeRef < IdRef
+          include AbsoluteTime
+        end
+        
+        # MJD time (=JD - 2400000.5)
+        class MJDTime
+          include AbsoluteTime
+          
+          attr_reader :value
+          
+          def initialize(dt)
+            self.value = dt
+          end
+          
+          def value=(dt)
+            @value = Float(dt)
+          end
+          
+          def to_s
+            self.value.to_s
+          end
+          
+          def to_datetime
+            DateTime.jd(DateTime.mjd_to_jd(self.value))
+          end
+          
+          def to_xml
+            el = element()
+            el.text = self.value.to_s
+            collapse_namespaces(el)
+            el
+          end
+          
+          def self.from_xml(xml)
+            MJDTime.new(element_from(xml).text)
+          end
+        end
+        
+        # IDREF to an MJD time
+        class MJDTimeRef < IdRef
+          include AbsoluteTime
+        end
+        
+        # A relocatable time origin for simulations
+        class TimeOrigin < Enumeration
+          include AbsoluteTime
+          
+          def self.choices; ['RELOCATABLE'] end
+          
+          def initialize(to='RELOCATABLE')
+            self.value = to
+          end
+          
+          def to_xml
+            el = element()
+            el.text = self.value.to_s
+            collapse_namespaces(el)
+            el
+          end
+          
+          def self.from_xml(xml)
+            TimeOrigin.new(element_from(xml).text)
+          end
+        end
+        
+        # Substitution group: Relative time is elapsed time relative to the absolute reference time component
+        module RelativeTime
+          include SerializableToXml
+          
+          def ==(time)
+            self.offset == time.offset and self.unit == time.unit
+          end  
+        end
+        
+        # Actual elapsed time offset
+        class TimeOffset
+          include RelativeTime
+          
+          attr_reader :offset, :unit
+          
+          def initialize(offset, unit=TimeUnit.new('s'))
+            self.offset = offset
+            self.unit = unit
+          end
+          
+          def offset=(offset)
+            @offset = Float(offset)
+          end
+          
+          def unit=(u)
+            @unit = u.is_a?(TimeUnit) ? u : TimeUnit.new(u)
+          end
+          
+          def to_s
+            "#{self.offset} #{self.unit}"
+          end
+          
+          def to_xml
+            el = element()
+            el.text = self.offset.to_s
+            el.attributes["#{obj_ns.prefix}:unit"] = self.unit.to_s
+            collapse_namespaces(el)
+            el
+          end
+          
+          def self.from_xml(xml)
+            node = element_from(xml)
+            TimeOffset.new(
+              Float(node.text),
+              node.attributes.get_attribute_ns(obj_ns.uri, 'unit').value
+            )
+          end
+        end
+        
+        class TimeOffsetRef < IdRef
+          include RelativeTime
+          
+          attr_reader :unit
+          
+          def initialize(ref, unit=TimeUnit.new('s'))
+            super(ref)
+            self.unit = unit
+          end
+          
+          def unit=(u)
+            @unit = u.is_a?(TimeUnit) ? u : TimeUnit.new(u)
+          end
+          
+          def offset; self.value end
+          def offset=(offset); self.value = offset end
+          
+          def to_s
+            "#{self.value} #{self.unit}"
+          end
+          
+          def to_xml
+            el = element()
+            el.text = self.value.to_s
+            el.attributes["#{obj_ns.prefix}:unit"] = self.unit.to_s
+            collapse_namespaces(el)
+            el
+          end
+          
+          def self.from_xml(xml)
+            node = element_from(xml)
+            TimeOffsetRef.new(
+              node.text,
+              node.attributes.get_attribute_ns(obj_ns.uri, 'unit').value
+            )
+          end
+        end
+        
+        # AstronTime is the generalized astronomical time type and consists of two or three elements:
+        # TimeScale, optional relative time offset, and an absolute time (ISO8601 or a decimal JD or MJD;
+        # or it may be an IDREF to one of those three)
+        class AstronTime
+          include SerializableToXml
+          
+          attr_reader :timescale, :relative_time, :absolute_time
+          
+          def initialize(timescale, absolute_time, relative_time=nil)
+            self.timescale = timescale
+            self.absolute_time = absolute_time
+            self.relative_time = relative_time
+          end
+          
+          def timescale=(ts)
+            raise_argument_required_error('timescale') if !ts
+            @timescale = ts.is_a?(TimeScale) ? ts : TimeScale.new(ts)
+          end
+          
+          def absolute_time=(at)
+            raise TypeError, "invalid value '#{at}', expected AbsoluteTime" if !at.is_a?(AbsoluteTime)
+            @absolute_time = at 
+          end
+          
+          def relative_time=(rt)
+            raise TypeError, "invalid value '#{rt}', expected RelativeTime" if rt and !rt.is_a?(RelativeTime)
+            @relative_time = rt
+          end
+          
+          def to_xml(name=nil, ns=nil)
+            el = element(name, ns)
+            
+            timescale = REXML::Element.new("#{obj_ns.prefix}:Timescale")
+            timescale.text = self.timescale.to_s
+
+            el.add_element(timescale)
+            el.add_element(self.relative_time.to_xml) if self.relative_time
+            el.add_element(self.absolute_time.to_xml)
+            
+            collapse_namespaces(el)
+            
+            el
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {
+              :timescale => TimeScale.new(REXML::XPath.first(root, 'x:Timescale', {'x' => obj_ns.uri}).text),
+              :absolute_time => xml_to_obj(root, AbsoluteTime, true)
+            }
+            options[:relative_time] = xml_to_obj(root, RelativeTime, true)
+            
+            AstronTime.new(options[:timescale], options[:absolute_time], options[:relative_time])
+          end
+          
+          def ==(time)
+            self.timescale == time.timescale and
+            self.absolute_time == time.absolute_time and
+            self.relative_time == time.relative_time
+          end
+        end
+        
+        # For vector coordinates we need arrays of doubles
+        class DoubleArray < TypedArray
+          include SerializableToXml
+          
+          def self.restricted_to; [Float] end
+          
+          def self.from_xml(xml)
+            self.new(element_from(xml).text.split(' ').collect{ |n| Float(n) })
+          end
+          
+          def to_xml(name=nil, ns=nil)
+            el = element(name, ns)
+            el.text = self.to_s
+            collapse_namespaces(el)
+            el
+          end
+        end
+        
+        # A vector of 2 doubles
+        class Double2 < DoubleArray
+          def self.maximum_length; 2 end
+          def self.minimum_length; 2 end
+        end
+        
+        # A vector of 3 doubles
+        class Double3 < DoubleArray
+          def self.maximum_length; 3 end
+          def self.minimum_length; 3 end
+        end
+        
+        # A vector of 4 doubles
+        class Double4 < DoubleArray
+          def self.maximum_length; 4 end
+          def self.minimum_length; 4 end
+        end
+        
+        # A vector of 9 doubles
+        class Double9 < DoubleArray
+          def self.maximum_length; 9 end
+          def self.minimum_length; 9 end
+        end
+        
+        # The head element for the CoordinateValue substitution group
+        module CoordValue
+          include SerializableToXml
+        end
+        
+        # Substitution group for a scalar coordinate value
+        module CValue
+          include CoordValue
+          
+          def to_s
+            self.value.to_s
+          end
+          
+          def ==(value)
+            self.value == value.value
+          end
+          
+          def to_xml(name=nil, ns=nil)
+            el = element(name, ns)
+            el.text = self.value.to_s
+            collapse_namespaces(el)
+            el
+          end
+        end
+        
+        # double
+        class Value
+          include CValue
+          
+          attr_reader :value
+          
+          def initialize(value)
+            self.value = value
+          end
+          
+          def value=(v)
+            @value = Float(v)
+          end
+          
+          def self.from_xml(xml)
+            Value.new(element_from(xml).text)
+          end
+        end
+        
+        # IDREF to a Value
+        class ValueRef < IdRef
+          include CValue
+        end
+        
+        # Substitution group for a scalar coordinate error
+        module CError
+          include SerializableToXml
+          
+          def to_s
+            self.value.to_s
+          end
+          
+          def ==(error)
+            self.value == error.value
+          end
+          
+          def to_xml
+            el = element()
+            el.text = self.value.to_s
+            collapse_namespaces(el)
+            el
+          end
+        end
+        
+        # double
+        class Error
+          include CError
+          
+          attr_reader :value
+          
+          def initialize(value)
+            self.value = value
+          end
+          
+          def value=(v)
+            @value = Float(v)
+          end
+          
+          def self.from_xml(xml)
+            Error.new(element_from(xml).text)
+          end
+        end
+        
+        # IDREF to an Error
+        class ErrorRef < IdRef
+          include CError
+        end
+        
+        # Substitution group for a scalar coordinate resolution
+        module CResolution
+          include SerializableToXml
+          
+          def to_s
+            self.value.to_s
+          end
+          
+          def ==(res)
+            self.value == res.value
+          end
+          
+          def to_xml
+            el = element()
+            el.text = self.value.to_s
+            collapse_namespaces(el)
+            el
+          end
+        end
+        
+        # double
+        class Resolution
+          include CResolution
+          
+          attr_reader :value
+          
+          def initialize(value)
+            self.value = value
+          end
+          
+          def value=(v)
+            @value = Float(v)
+          end
+          
+          def self.from_xml(xml)
+            Resolution.new(element_from(xml).text)
+          end
+        end
+        
+        class ResolutionRef < IdRef
+          include CResolution
+        end
+        
+        # Substitution group for a scalar coordinate size
+        module CSize
+          include SerializableToXml
+          
+          def to_s
+            self.value.to_s
+          end
+          
+          def ==(size)
+            self.value == size.value
+          end
+        end
+        
+        # double
+        class Size
+          include CSize
+          
+          attr_reader :value
+          
+          def initialize(value)
+            self.value = value
+          end
+          
+          def value=(v)
+            @value = Float(v)
+          end
+          
+          def to_xml
+            el = element()
+            el.text = self.value.to_s
+            collapse_namespaces(el)
+            el
+          end
+          
+          def self.from_xml(xml)
+            Size.new(element_from(xml).text)
+          end
+        end
+        
+        # IDREF to a Size
+        class SizeRef < IdRef
+          include CSize
+        end
+        
+        # Substitution group for a scalar coordinate pixel size
+        module CPixSize
+          include SerializableToXml
+          
+          def to_s
+            self.value.to_s
+          end
+          
+          def ==(pixsize)
+            self.value == pixsize.value
+          end
+        end
+        
+        # double
+        class PixSize
+          include CPixSize
+          
+          attr_reader :value
+          
+          def initialize(value)
+            self.value = value
+          end
+          
+          def value=(v)
+            @value = Float(v)
+          end
+          
+          def to_xml
+            el = element()
+            el.text = self.value.to_s
+            collapse_namespaces(el)
+            el
+          end
+          
+          def self.from_xml(xml)
+            PixSize.new(element_from(xml).text)
+          end
+        end
+        
+        # IDREF to a PixelSize
+        class PixSizeRef < IdRef
+          include CPixSize
+        end
+        
+        # Abstract coordinate type; a concrete Coordinate consists of a Value, Error,
+        # Resolution, Size, and PixSize
+        class CoordinateType
+          include SerializableToXml
+          
+          attr_reader :name
+          
+          def initialize(options)
+            if options.is_a?(Hash)
+              options.each { |key, value| send("#{key}=", value) }
+            else
+              self.name = options
+            end
+          end
+          
+          def name=(n)
+            @name = n ? n.to_s : nil
+          end
+          
+          def ==(c)
+            self.name == c.name
+          end
+        end
+        
+        # Generic scalar coordinate type.
+        # Single CError, CResolution, CSize, CPixSize elements indicate
+        # definite values; pairs indicate ranges.
+        class ScalarCoordinateType < CoordinateType
+          attr_reader :value, :error, :resolution, :size, :pix_size
+          
+          def initialize(options={})
+            options.each { |key, value| send("#{key}=", value) }
+          end
+          
+          def value=(val)
+            raise_type_mismatch_error(val, CValue) if val
+            @value = val
+          end
+          
+          def error=(err)
+            if err
+              err = [err] if !err.is_a?(Array)
+            
+              if err.size > 0
+                raise ArgumentError, "#{err.size} > maximum length of 2" if err.size > 2
+                err.each { |e| raise_type_mismatch_error(e, CError) if e }
+                @error = err
+              else
+                @error = nil
+              end
+            end
+          end
+          
+          def resolution=(res)
+            if res
+              res = [res] if !res.is_a?(Array)
+            
+              if res.size > 0
+                raise ArgumentError, "#{res.size} > maximum length of 2" if res.size > 2
+                res.each { |r| raise_type_mismatch_error(r, CResolution) if r }
+                @resolution = res
+              else
+                @resolution = nil
+              end
+            end
+          end
+          
+          def size=(sz)
+            if sz
+              sz = [sz] if !sz.is_a?(Array)
+            
+              if sz.size > 0
+                raise ArgumentError, "#{sz.size} > maximum length of 2" if sz.size > 2
+                sz.each { |s| raise_type_mismatch_error(s, CSize) if s }
+                @size = sz
+              else
+                @size = nil
+              end
+            end
+          end
+          
+          def pix_size=(psz)
+            if psz
+              psz = [psz] if !psz.is_a?(Array)
+            
+              if psz.size > 0
+                raise ArgumentError, "#{psz.size} > maximum length of 2" if psz.size > 2
+                psz.each { |p| raise_type_mismatch_error(p, CPixSize) if p }
+                @pix_size = psz
+              else
+                @pix_size = nil
+              end
+            end
+            
+            def to_xml(name=nil)
+              el = element(name)
+
+              name = REXML::Element.new("#{obj_ns.prefix}:Name")
+              name.text = self.name
+
+              el.add_element(name)
+              el.add_element(self.value.to_xml) if self.value
+              self.error.each { |e| el.add_element(e.to_xml) } if self.error
+              self.resolution.each { |r| el.add_element(r.to_xml) } if self.resolution
+              self.size.each { |s| el.add_element(s.to_xml) } if self.size
+              self.pix_size.each { |p| el.add_element(p.to_xml) } if self.pix_size
+              
+              collapse_namespaces(el)
+
+              el
+            end
+          end
+          
+          def ==(sc)
+            super(sc) and
+            self.value == sc.value and
+            self.error == sc.error and
+            self.resolution == sc.resolution and
+            self.size == sc.size and
+            self.pix_size == sc.pix_size
+          end
+        end
+        
+        # Time coordinate type.
+        # Single CError, CResolution, CSize, CPixSize elements indicate definite values; pairs indicate ranges.
+        class TimeCoordinate < CoordinateType
+          include SerializableToXml
+          
+          attr_reader :time_instant, :error, :resolution, :size, :pix_size
+          
+          def initialize(options={})
+            options.each { |key, value| send("#{key}=", value) }
+          end
+          
+          def time_instant=(ti)
+            raise_type_mismatch_error(ti, AstronTime) if ti
+            @time_instant = ti
+          end
+          
+          def error=(err)
+            if err
+              err = [err] if !err.is_a?(Array)
+            
+              if err.size > 0
+                raise ArgumentError, "#{err.size} > maximum length of 2" if err.size > 2
+                err.each { |e| raise_type_mismatch_error(e, CError) if e }
+                @error = err
+              else
+                @error = nil
+              end
+            end
+          end
+          
+          def resolution=(res)
+            if res
+              res = [res] if !res.is_a?(Array)
+            
+              if res.size > 0
+                raise ArgumentError, "#{res.size} > maximum length of 2" if res.size > 2
+                res.each { |r| raise_type_mismatch_error(r, CResolution) if r }
+                @resolution = res
+              else
+                @resolution = nil
+              end
+            end
+          end
+          
+          def size=(sz)
+            if sz
+              sz = [sz] if !sz.is_a?(Array)
+            
+              if sz.size > 0
+                raise ArgumentError, "#{sz.size} > maximum length of 2" if sz.size > 2
+                sz.each { |s| raise_type_mismatch_error(s, CSize) if s }
+                @size = sz
+              else
+                @size = nil
+              end
+            end
+          end
+          
+          def pix_size=(psz)
+            if psz
+              psz = [psz] if !psz.is_a?(Array)
+            
+              if psz.size > 0
+                raise ArgumentError, "#{psz.size} > maximum length of 2" if psz.size > 2
+                psz.each { |p| raise_type_mismatch_error(p, CPixSize) if p }
+                @pix_size = psz
+              else
+                @pix_size = nil
+              end
+            end
+          end
+          
+          def unit=(u)
+            raise_type_mismatch_error(u, TimeUnit) if u
+            @unit = u
+          end
+          
+          def unit
+            @unit || TimeUnit.new('s')
+          end
+          
+          def to_xml(name=nil)
+            el = element(name)
+            el.attributes["#{obj_ns.prefix}:unit"] = self.unit.to_s if self.unit
+            
+            name = REXML::Element.new("#{obj_ns.prefix}:Name")
+            name.text = self.name
+            
+            el.add_element(name)
+            el.add_element(self.time_instant.to_xml('TimeInstant')) if self.time_instant
+            self.error.each { |e| el.add_element(e.to_xml) } if self.error
+            self.resolution.each { |r| el.add_element(r.to_xml) } if self.resolution
+            self.size.each { |s| el.add_element(s.to_xml) } if self.size
+            self.pix_size.each { |p| el.add_element(p.to_xml) } if self.pix_size
+            
+            collapse_namespaces(el)
+            
+            el
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {
+              :name => REXML::XPath.first(root, 'x:Name', {'x' => obj_ns.uri}).text
+            }
+            unit = root.attributes.get_attribute_ns(obj_ns.uri, 'unit')
+            options[:unit] = TimeUnit.new(unit.value) if unit
+            
+            time_instant = REXML::XPath.first(root, 'x:TimeInstant', {'x' => obj_ns.uri})
+            options[:time_instant] = AstronTime.from_xml(time_instant) if time_instant
+            
+            options[:error] = xml_to_obj(root, CError)
+            options[:resolution] = xml_to_obj(root, CResolution)
+            options[:size] = xml_to_obj(root, CSize)
+            options[:pix_size] = xml_to_obj(root, CPixSize)
+            
+            TimeCoordinate.new(options)
+          end
+          
+          def ==(tc)
+            super(tc) and
+            self.time_instant == tc.time_instant and
+            self.error == tc.error and
+            self.resolution == tc.resolution and
+            self.size == tc.size and
+            self.pix_size == tc.pix_size and
+            self.unit == tc.unit
+          end
+        end
+        
+        # 2 doubles with optional position angle
+        class Size2Type < Double2; end
+        
+        # Substitution group for a 2-D coordinate value
+        module CValue2
+          include CoordValue
+        end
+        
+        # double vector
+        class Value2 < Double2
+          include CValue2
+        end
+        
+        # IDREF to a Value2
+        class Value2Ref < IdRef
+          include CValue2
+        end
+        
+        # Substitution group for a 2-D coordinate error
+        module CError2; end
+        
+        # size2Type Error element
+        class Error2 < Size2Type
+          include CError2
+        end
+        
+        # 2x2 matrix Error element
+        class Error2Matrix < Double4
+          include CError2
+        end
+        
+        # IDREF to an Error2
+        class Error2Ref < IdRef
+          include CError2
+        end
+        
+        # Substitution group for a 2-D coordinate resolution
+        module CResolution2; end
+        
+        # size2Type Resolution element
+        class Resolution2 < Size2Type
+          include CResolution2
+        end
+        
+        # 2x2 matrix Resolution element
+        class Resolution2Matrix < Double4
+          include CResolution2
+        end
+        
+        # IDREF to a Resolution2
+        class Resolution2Ref < IdRef
+          include CResolution2
+        end
+        
+        # Substitution group for a 2-D coordinate size
+        module CSize2; end
+        
+        # size2Type Size element
+        class Size2 < Size2Type
+          include CSize2
+        end
+        
+        # 2x2 matrix Size element
+        class Size2Matrix < Double4
+          include CSize2
+        end
+        
+        # IDREF to a Size2
+        class Size2Ref < IdRef
+          include CSize2
+        end
+        
+        # Substitution group for a 2-D coordinate pixel size
+        module CPixSize2; end
+        
+        # size2Type PixSize element
+        class PixSize2 < Size2Type
+          include CPixSize2
+        end
+        
+        # 2x2 matrix PixSize element
+        class PixSize2Matrix < Double4
+          include CPixSize2
+        end
+        
+        # IDREF to a PixSize2<
+        class PixSize2Ref < IdRef
+          include CPixSize2
+        end
+        
+        # Generic 2-D coordinate type.
+        # Single CError2, CResolution2, CSize2, CPixSize2 elements indicate definite values; pairs indicate ranges.
+        class Vector2Coordinate < CoordinateType
+          attr_reader :value, :error, :resolution, :size, :pix_size
+          
+          def initialize(options={})
+            options.each { |key, value| send("#{key}=", value) }
+          end
+          
+          def value=(val)
+            raise_type_mismatch_error(val, CValue2) if val
+            @value = val
+          end
+          
+          def error=(err)
+            err = [err] if err.class != Array
+            
+            if err.size > 0
+              raise ArgumentError, "#{err.size} > maximum length of 2" if err.size > 2
+              err.each { |e| raise_type_mismatch_error(e, CError2) if e }
+              @error = err
+            else
+              @error = nil
+            end
+          end
+          
+          def resolution=(res)
+            res = [res] if res.class != Array
+            
+            if res.size > 0
+              raise ArgumentError, "#{res.size} > maximum length of 2" if res.size > 2
+              res.each { |r| raise_type_mismatch_error(r, CResolution2) if r }
+              @resolution = res
+            else
+              @resolution = nil
+            end
+          end
+          
+          def size=(sz)
+            sz = [sz] if sz.class != Array
+            
+            if sz.size > 0
+              raise ArgumentError, "#{sz.size} > maximum length of 2" if sz.size > 2
+              sz.each { |s| raise_type_mismatch_error(s, CSize2) if s }
+              @size = sz
+            else
+              @size = nil
+            end
+          end
+          
+          def pix_size=(psz)
+            psz = [psz] if psz.class != Array
+            
+            if psz.size > 0
+              raise ArgumentError, "#{psz.size} > maximum length of 2" if psz.size > 2
+              psz.each { |p| raise_type_mismatch_error(p, CPixSize2) if p }
+              @pix_size = psz
+            else
+              @pix_size = nil
+            end
+          end
+          
+          def ==(sc)
+            super(sc) and
+            self.value == sc.value and
+            self.error == sc.error and
+            self.resolution == sc.resolution and
+            self.size == sc.size and
+            self.pix_size == sc.pix_size
+          end
+        end
+      
+        # 3 doubles with optional position angles
+        class Size3Type < Double3; end
+        
+        # Substitution group for a 3-D coordinate value
+        module CValue3
+          include CoordValue
+        end
+        
+        # Vector of 3 doubles
+        class Value3 < Double3
+          include CValue3
+        end
+        
+        # IDREF to a Value3
+        class Value3Ref < IdRef
+          include CValue3
+        end
+        
+        # Substitution group for a 3-D coordinate error
+        module CError3; end
+        
+        # Size3 Error element
+        class Error3 < Size3Type
+          include CError3
+        end
+        
+        # 3x3 matrix Error element
+        class Error3Matrix < Double9
+          include CError3
+        end
+        
+        # IDREF to an Error3
+        class Error3Ref < IdRef
+          include CError3
+        end
+        
+        # Substitution group for a 3-D coordinate resolution
+        module CResolution3; end
+        
+        # size3 Resolution element
+        class Resolution3 < Size3Type
+          include CResolution3
+        end
+        
+        # IDREF to a Resolution3
+        class Resolution3Ref < IdRef
+          include CResolution3
+        end
+        
+        # Substitution group for a 3-D coordinate size
+        module CSize3; end
+        
+        # size3 Size element
+        class Size3 < Size3Type
+          include CSize3
+        end
+        
+        # 3x3 matrix Size element
+        class Size3Matrix < Double9
+          include CSize3
+        end
+        
+        # IDREF to a Size3
+        class Size3Ref < IdRef
+          include CSize3
+        end
+        
+        # Substitution group for a 3-D coordinate pixel size
+        module CPixSize3; end
+        
+        # size3Type PixSize element
+        class PixSize3 < Size3Type
+          include CPixSize3
+        end
+        
+        # 3x3 matrix PixSize element
+        class PixSize3Matrix < Double9
+          include CPixSize3
+        end
+        
+        # IDREF to PixSize3
+        class PixSize3Ref < IdRef
+          include CPixSize3
+        end
+        
+        # Generic 3-D coordinate type.
+        # Single CError3, CResolution3, CSize3, CPixSize3 elements indicate definite values; pairs indicate ranges
+        class Vector3Coordinate < CoordinateType
+          attr_reader :value, :error, :resolution, :size, :pix_size
+          
+          def initialize(options={})
+            options.each { |key, value| send("#{key}=", value) }
+          end
+          
+          def value=(val)
+            raise_type_mismatch_error(val, CValue3) if val
+            @value = val
+          end
+          
+          def error=(err)
+            err = [err] if err.class != Array
+            
+            if err.size > 0
+              raise ArgumentError, "#{err.size} > maximum length of 2" if err.size > 2
+              err.each { |e| raise_type_mismatch_error(e, CError3) if e }
+              @error = err
+            else
+              @error = nil
+            end
+          end
+          
+          def resolution=(res)
+            res = [res] if res.class != Array
+            
+            if res.size > 0
+              raise ArgumentError, "#{res.size} > maximum length of 2" if res.size > 2
+              res.each { |r| raise_type_mismatch_error(r, CResolution3) if r }
+              @resolution = res
+            else
+              @resolution = nil
+            end
+          end
+          
+          def size=(sz)
+            sz = [sz] if sz.class != Array
+            
+            if sz.size > 0
+              raise ArgumentError, "#{sz.size} > maximum length of 2" if sz.size > 2
+              sz.each { |s| raise_type_mismatch_error(s, CSize3) if s }
+              @size = sz
+            else
+              @size = nil
+            end
+          end
+          
+          def pix_size=(psz)
+            psz = [psz] if psz.class != Array
+            
+            if psz.size > 0
+              raise ArgumentError, "#{psz.size} > maximum length of 2" if psz.size > 2
+              psz.each { |p| raise_type_mismatch_error(p, CPixSize3) if p }
+              @pix_size = psz
+            else
+              @pix_size = nil
+            end
+          end
+          
+          def ==(sc)
+            super(sc) and
+            self.value == sc.value and
+            self.error == sc.error and
+            self.resolution == sc.resolution and
+            self.size == sc.size and
+            self.pix_size == sc.pix_size
+          end
+        end
+        
+        # Coordinate substitution group
+        module Coordinate
+          include SerializableToXml
+        end
+        
+        # Generic scalar coordinate element
+        class ScalarCoordinate < ScalarCoordinateType
+          include Coordinate
+          
+          attr_reader :unit
+          
+          def unit=(u)
+            @unit = u.to_s
+          end
+          
+          def ==(c)
+            super(c) and self.unit == c.unit
+          end
+          
+          def to_xml
+            el = super('ScalarCoordinate')
+            el.attributes["#{obj_ns.prefix}:unit"] = self.unit.to_s if self.unit
+            collapse_namespaces(el)
+            el
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {
+             :name => REXML::XPath.first(root, 'x:Name', {'x' => obj_ns.uri}).text
+            }
+            unit = root.attributes.get_attribute_ns(obj_ns.uri, 'unit')
+            options[:unit] = unit.value if unit
+            options[:value] = xml_to_obj(root, CValue, true)
+            options[:error] = xml_to_obj(root, CError)
+            options[:resolution] = xml_to_obj(root, CResolution)
+            options[:size] = xml_to_obj(root, CSize)
+            options[:pix_size] = xml_to_obj(root, CPixSize)
+            
+            ScalarCoordinate.new(options)
+          end
+          
+          def ==(c)
+            super(c) and self.unit == c.unit
+          end
+        end
+        
+        # Generic string coordinate element
+        class StringCoordinate < CoordinateType
+          include Coordinate
+          
+          attr_reader :value, :unit
+          
+          def value=(v)
+            @value = v.to_s
+          end
+          
+          def unit=(u)
+            @unit = u.to_s
+          end
+          
+          def ==(c)
+            super(c) and
+            self.value == c.value and
+            self.unit == c.unit
+          end
+          
+          def to_xml
+            el = element()
+            el.attributes["#{obj_ns.prefix}:unit"] = self.unit.to_s if self.unit
+            
+            name = REXML::Element.new("#{obj_ns.prefix}:Name")
+            name.text = self.name
+            
+            value = REXML::Element.new("#{obj_ns.prefix}:Value")
+            value.text = self.value
+            
+            el.add_element(name)
+            el.add_element(value)
+            
+            collapse_namespaces(el)
+            
+            el
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {
+             :name => REXML::XPath.first(root, 'x:Name', {'x' => obj_ns.uri}).text,
+             :value => REXML::XPath.first(root, 'x:Value', {'x' => obj_ns.uri}).text
+            }
+            unit = root.attributes.get_attribute_ns(obj_ns.uri, 'unit')
+            options['unit'] = unit.value if unit
+            
+            StringCoordinate.new(options)
+          end
+        end
+        
+        # Generic coordinate element for pixels
+        class PixelCoordinate < CoordinateType
+          include Coordinate
+          
+          attr_reader :value
+          
+          def value=(v)
+            @value = Float(v)
+          end
+          
+          def ==(c)
+            super(c) and
+            self.value == c.value
+          end
+          
+          def to_xml
+            el = element()
+            
+            if self.name
+              name = REXML::Element.new("#{obj_ns.prefix}:Name")
+              name.text = self.name
+              el.add_element(name)
+            end
+            
+            value = REXML::Element.new("#{obj_ns.prefix}:Value")
+            value.text = self.value.to_s
+            el.add_element(value)
+            
+            collapse_namespaces(el)
+            
+            el
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {
+             :value => REXML::XPath.first(root, 'x:Value', {'x' => obj_ns.uri}).text
+            }
+            
+            name = REXML::XPath.first(root, 'x:Name', {'x' => obj_ns.uri})
+            options[:name] = name.text if name
+            
+            PixelCoordinate.new(options)
+          end
+        end
+        
+        # Position coordinate substitution group
+        module Position
+          include SerializableToXml
+        end
+        
+        # 1-D Position coordinate
+        class Position1D < ScalarCoordinateType
+          include Position
+          
+          attr_reader :unit
+          
+          def initialize(options={})
+            raise_argument_required_error('unit') if !options.has_key?(:unit)
+            super(options)
+          end
+          
+          def unit=(u)
+            raise_argument_required_error('unit') if !u
+            raise_type_mismatch_error(u, PosUnit)
+            @unit = u
+          end
+          
+          def to_xml
+             el = element()
+             el.attributes["#{obj_ns.prefix}:unit"] = self.unit.to_s if self.unit
+
+             name = REXML::Element.new("#{obj_ns.prefix}:Name")
+             name.text = self.name
+
+             el.add_element(name)
+             el.add_element(self.value.to_xml) if self.value
+             self.error.each { |e| el.add_element(e.to_xml) } if self.error
+             self.resolution.each { |r| el.add_element(r.to_xml) } if self.resolution
+             self.size.each { |s| el.add_element(s.to_xml) } if self.size
+             self.pix_size.each { |p| el.add_element(p.to_xml) } if self.pix_size
+             
+             collapse_namespaces(el)
+
+             el
+           end
+
+           def self.from_xml(xml)
+             root = element_from(xml)
+
+             options = {
+              :name => REXML::XPath.first(root, 'x:Name', {'x' => obj_ns.uri}).text
+             }
+             unit = root.attributes.get_attribute_ns(obj_ns.uri, 'unit')
+             options[:unit] = PosUnit.new(unit.value) if unit
+             options[:value] = xml_to_obj(root, CValue, true)
+             options[:error] = xml_to_obj(root, CError)
+             options[:resolution] = xml_to_obj(root, CResolution)
+             options[:size] = xml_to_obj(root, CSize)
+             options[:pix_size] = xml_to_obj(root, CPixSize)
+
+             Position1D.new(options)
+           end
+          
+          def ==(p)
+            super(p) and
+            self.unit == p.unit
+          end
+        end
+        
+        # 2-D Position coordinate
+        class Position2D < Vector2Coordinate
+          include Position
+          
+          attr_reader :unit
+
+          def initialize(options={})
+            raise_argument_required_error('unit') if !options.has_key?(:unit)
+            super(options)
+          end
+
+          def unit=(u)
+            raise_argument_required_error('unit') if !u
+            raise_type_mismatch_error(u, PosUnit)
+            @unit = u
+          end
+          
+          def to_xml
+            el = element()
+            el.attributes["#{obj_ns.prefix}:unit"] = self.unit.to_s if self.unit
+            
+            name = REXML::Element.new("#{obj_ns.prefix}:Name")
+            name.text = self.name
+
+            el.add_element(name)
+            el.add_element(self.value.to_xml) if self.value
+            self.error.each { |e| el.add_element(e.to_xml) } if self.error
+            self.resolution.each { |r| el.add_element(r.to_xml) } if self.resolution
+            self.size.each { |s| el.add_element(s.to_xml) } if self.size
+            self.pix_size.each { |p| el.add_element(p.to_xml) } if self.pix_size
+            
+            collapse_namespaces(el)
+            
+            el
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+
+            options = {
+             :name => REXML::XPath.first(root, 'x:Name', {'x' => obj_ns.uri}).text
+            }
+            unit = root.attributes.get_attribute_ns(obj_ns.uri, 'unit')
+            options[:unit] = PosUnit.new(unit.value) if unit
+            options[:value] = xml_to_obj(root, CValue2, true)
+            options[:error] = xml_to_obj(root, CError2)
+            options[:resolution] = xml_to_obj(root, CResolution2)
+            options[:size] = xml_to_obj(root, CSize2)
+            options[:pix_size] = xml_to_obj(root, CPixSize2)
+
+            Position2D.new(options)
+          end
+          
+          def ==(p)
+            super(p) and
+            self.unit == p.unit
+          end
+        end
+        
+        class Position3D < Vector3Coordinate
+          include Position
+          
+          attr_reader :unit
+
+          def initialize(options={})
+            raise_argument_required_error('unit') if !options.has_key?(:unit)
+            super(options)
+          end
+
+          def unit=(u)
+            raise_argument_required_error('unit') if !u
+            raise_type_mismatch_error(u, PosUnit)
+            @unit = u
+          end
+          
+          def to_xml
+            el = element()
+            el.attributes["#{obj_ns.prefix}:unit"] = self.unit.to_s if self.unit
+            
+            name = REXML::Element.new("#{obj_ns.prefix}:Name")
+            name.text = self.name
+
+            el.add_element(name)
+            el.add_element(self.value.to_xml) if self.value
+            self.error.each { |e| el.add_element(e.to_xml) } if self.error
+            self.resolution.each { |r| el.add_element(r.to_xml) } if self.resolution
+            self.size.each { |s| el.add_element(s.to_xml) } if self.size
+            self.pix_size.each { |p| el.add_element(p.to_xml) } if self.pix_size
+            
+            collapse_namespaces(el)
+            
+            el
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+
+            options = {
+             :name => REXML::XPath.first(root, 'x:Name', {'x' => obj_ns.uri}).text
+            }
+            unit = root.attributes.get_attribute_ns(obj_ns.uri, 'unit')
+            options[:unit] = PosUnit.new(unit.value) if unit
+            options[:value] = xml_to_obj(root, CValue3, true)
+            options[:error] = xml_to_obj(root, CError3)
+            options[:resolution] = xml_to_obj(root, CResolution3)
+            options[:size] = xml_to_obj(root, CSize3)
+            options[:pix_size] = xml_to_obj(root, CPixSize3)
+
+            Position3D.new(options)
+          end
+          
+          def ==(p)
+            super(p) and
+            self.unit == p.unit
+          end
+        end
+        
+        # Velocity coordinate substitution group
+        module Velocity
+          include SerializableToXml
+          
+          attr_reader :unit, :vel_time_unit
+          
+          def unit=(u)
+            raise_type_mismatch_error(u, PosUnit)
+            @unit = u
+          end
+          
+          def vel_time_unit=(vtu)
+            raise_type_mismatch_error(vtu, VelTimeUnit)
+            @vel_time_unit = vtu
+          end
+          
+          def ==(v)
+            super(v) and
+            self.unit == v.unit and
+            self.vel_time_unit == v.vel_time_unit
+          end
+        end
+
+        # 1-D Velocity coordinate
+        class Velocity1D < ScalarCoordinateType
+          include Velocity
+          
+          def initialize(options={})
+            raise_argument_required_error('unit') if !options.has_key?(:unit)
+            raise_argument_required_error('velocity time unit') if !options.has_key?(:vel_time_unit)
+            super(options)
+          end
+          
+          def to_xml
+            el = element()
+            el.attributes["#{obj_ns.prefix}:unit"] = self.unit.to_s
+            el.attributes["#{obj_ns.prefix}:vel_time_unit"] = self.vel_time_unit.to_s
+            
+            name = REXML::Element.new("#{obj_ns.prefix}:Name")
+            name.text = self.name
+
+            el.add_element(name)
+            el.add_element(self.value.to_xml) if self.value
+            self.error.each { |e| el.add_element(e.to_xml) } if self.error
+            self.resolution.each { |r| el.add_element(r.to_xml) } if self.resolution
+            self.size.each { |s| el.add_element(s.to_xml) } if self.size
+            self.pix_size.each { |p| el.add_element(p.to_xml) } if self.pix_size
+            
+            collapse_namespaces(el)
+
+            el
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+
+            options = {
+             :name => REXML::XPath.first(root, 'x:Name', {'x' => obj_ns.uri}).text
+            }
+            unit = root.attributes.get_attribute_ns(obj_ns.uri, 'unit')
+            options[:unit] = PosUnit.new(unit.value)
+            vel_time_unit = root.attributes.get_attribute_ns(obj_ns.uri, 'vel_time_unit')
+            options[:vel_time_unit] = VelTimeUnit.new(vel_time_unit.value)
+            options[:value] = xml_to_obj(root, CValue, true)
+            options[:error] = xml_to_obj(root, CError)
+            options[:resolution] = xml_to_obj(root, CResolution)
+            options[:size] = xml_to_obj(root, CSize)
+            options[:pix_size] = xml_to_obj(root, CPixSize)
+
+            Velocity1D.new(options)
+          end
+        end
+        
+        # 2-D Velocity coordinate
+        class Velocity2D < Vector2Coordinate
+          include Velocity
+          
+          def initialize(options={})
+            raise_argument_required_error('unit') if !options.has_key?(:unit)
+            raise_argument_required_error('velocity time unit') if !options.has_key?(:vel_time_unit)
+            super(options)
+          end
+          
+          def to_xml
+            el = element()
+            el.attributes["#{obj_ns.prefix}:unit"] = self.unit.to_s
+            el.attributes["#{obj_ns.prefix}:vel_time_unit"] = self.vel_time_unit.to_s
+            
+            name = REXML::Element.new("#{obj_ns.prefix}:Name")
+            name.text = self.name
+
+            el.add_element(name)
+            el.add_element(self.value.to_xml) if self.value
+            self.error.each { |e| el.add_element(e.to_xml) } if self.error
+            self.resolution.each { |r| el.add_element(r.to_xml) } if self.resolution
+            self.size.each { |s| el.add_element(s.to_xml) } if self.size
+            self.pix_size.each { |p| el.add_element(p.to_xml) } if self.pix_size
+            
+            collapse_namespaces(el)
+            
+            el
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+
+            options = {
+             :name => REXML::XPath.first(root, 'x:Name', {'x' => obj_ns.uri}).text
+            }
+            unit = root.attributes.get_attribute_ns(obj_ns.uri, 'unit')
+            options[:unit] = PosUnit.new(unit.value)
+            vel_time_unit = root.attributes.get_attribute_ns(obj_ns.uri, 'vel_time_unit')
+            options[:vel_time_unit] = VelTimeUnit.new(vel_time_unit.value)
+            options[:value] = xml_to_obj(root, CValue2, true)
+            options[:error] = xml_to_obj(root, CError2)
+            options[:resolution] = xml_to_obj(root, CResolution2)
+            options[:size] = xml_to_obj(root, CSize2)
+            options[:pix_size] = xml_to_obj(root, CPixSize2)
+
+            Velocity2D.new(options)
+          end
+        end
+        
+        # 3-D Velocity coordinate
+        class Velocity3D < Vector3Coordinate
+          include Velocity
+
+          def initialize(options={})
+            raise_argument_required_error('unit') if !options.has_key?(:unit)
+            raise_argument_required_error('velocity time unit') if !options.has_key?(:vel_time_unit)
+            super(options)
+          end
+          
+          def to_xml
+            el = element()
+            el.attributes["#{obj_ns.prefix}:unit"] = self.unit.to_s
+            el.attributes["#{obj_ns.prefix}:vel_time_unit"] = self.vel_time_unit.to_s
+            
+            name = REXML::Element.new("#{obj_ns.prefix}:Name")
+            name.text = self.name
+
+            el.add_element(name)
+            el.add_element(self.value.to_xml) if self.value
+            self.error.each { |e| el.add_element(e.to_xml) } if self.error
+            self.resolution.each { |r| el.add_element(r.to_xml) } if self.resolution
+            self.size.each { |s| el.add_element(s.to_xml) } if self.size
+            self.pix_size.each { |p| el.add_element(p.to_xml) } if self.pix_size
+            
+            collapse_namespaces(el)
+            
+            el
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+
+            options = {
+             :name => REXML::XPath.first(root, 'x:Name', {'x' => obj_ns.uri}).text
+            }
+            unit = root.attributes.get_attribute_ns(obj_ns.uri, 'unit')
+            options[:unit] = PosUnit.new(unit.value)
+            vel_time_unit = root.attributes.get_attribute_ns(obj_ns.uri, 'vel_time_unit')
+            options[:vel_time_unit] = VelTimeUnit.new(vel_time_unit.value)
+            options[:value] = xml_to_obj(root, CValue3, true)
+            options[:error] = xml_to_obj(root, CError3)
+            options[:resolution] = xml_to_obj(root, CResolution3)
+            options[:size] = xml_to_obj(root, CSize3)
+            options[:pix_size] = xml_to_obj(root, CPixSize3)
+
+            Velocity3D.new(options)
+          end
+        end
+        
+        # Specifies a FITS file and optionally a specific HDU by HDU number or HDU name
+        class Fits
+          include SerializableToXml
+          
+          attr_reader :uri, :hdu_num, :hdu_name
+          
+          def initialize(options={})
+            raise_argument_required_error('URI') if !options.has_key?(:uri)
+            options.each { |key, value| send("#{key}=", value) }
+          end
+          
+          def uri=(u)
+            @uri = u.is_a?(URI) ? u : URI.parse(u.to_s)
+          end
+          
+          def hdu_num=(i)
+            @hdu_num = Integer(i) if i
+          end
+          
+          def hdu_name=(n)
+            @hdu_name = n.to_s if n
+          end
+          
+          def to_xml(name='FITSFile')
+            el = element(name)
+            
+            el.text = self.uri.to_s
+            el.attributes["#{obj_ns.prefix}:hdu_num"] = self.hdu_num.to_s if self.hdu_num
+            el.attributes["#{obj_ns.prefix}:hdu_name"] = self.hdu_name if self.hdu_name
+            
+            collapse_namespaces(el)
+            
+            el
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+
+            options = {
+             :uri => URI.parse(root.text)
+            }
+            hdu_num = root.attributes.get_attribute_ns(obj_ns.uri, 'hdu_num')
+            options[:hdu_num] = hdu_num.value.to_i if hdu_num
+            hdu_name = root.attributes.get_attribute_ns(obj_ns.uri, 'hdu_name')
+            options[:hdu_name] = hdu_name.value if hdu_name
+            
+            Fits.new(options)
+          end
+          
+          def ==(f)
+            self.uri == f.uri and
+            self.hdu_num == f.hdu_num and
+            self.hdu_name == f.hdu_name
+          end
+        end
+        
+        # Refers coordinate components to specific columns in the FITS file HDU
+        class CoordFitsColumns
+          include SerializableToXml
+          
+          attr_reader :name, :value, :error, :resolution, :size, :pix_size
+          
+          def initialize(options={})
+            raise_argument_required_error('name') if !options.has_key?(:name)
+            options.each { |key, value| send("#{key}=", value) }
+          end
+          
+          def name=(n)
+            raise_argument_required_error('name') if !n
+            @name = n.to_s
+          end
+          
+          # The column name for the coordinate value; comma-separated if multi-dimensional
+          def value=(v)
+            @value = v.to_s if v
+          end
+          
+          # The column name for the coordinate error; comma-separated if multi-dimensional
+          def error=(e)
+            @error = e.to_s if e
+          end
+          
+          # The column name for the coordinate resolution; comma-separated if multi-dimensional
+          def resolution=(r)
+            @resolution = r.to_s if r
+          end
+          
+          # The column name for the coordinate size; comma-separated if multi-dimensional
+          def size=(s)
+            @size = s.to_s if s
+          end
+          
+          # The column name for the coordinate pixel size; comma-separated if multi-dimensional
+          def pix_size=(ps)
+            @pix_size = ps.to_s if ps
+          end
+          
+          def to_xml(name)
+            el = element(name)
+            
+            name = REXML::Element.new("#{obj_ns.prefix}:Name")
+            name.text = self.name
+            el.add_element(name)
+            
+            if self.value
+              value = REXML::Element.new("#{obj_ns.prefix}:Value")
+              value.text = self.value
+              el.add_element(value)
+            end
+            
+            if self.error
+              error = REXML::Element.new("#{obj_ns.prefix}:Error")
+              error.text = self.error
+              el.add_element(error)
+            end
+            
+            if self.resolution
+              res = REXML::Element.new("#{obj_ns.prefix}:Resolution")
+              res.text = self.resolution
+              el.add_element(res)
+            end
+            
+            if self.size
+              size = REXML::Element.new("#{obj_ns.prefix}:Size")
+              size.text = self.size
+              el.add_element(size)
+            end
+            
+            if self.pix_size
+              pix_size = REXML::Element.new("#{obj_ns.prefix}:PixSize")
+              pix_size.text = self.pix_size
+              el.add_element(pix_size)
+            end
+            
+            collapse_namespaces(el)
+            
+            el
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {
+              :name => REXML::XPath.first(root, 'x:Name', {'x' => obj_ns.uri}).text
+            }
+            
+            value = REXML::XPath.first(root, 'x:Value', {'x' => obj_ns.uri})
+            options[:value] = value.text if value
+            
+            error = REXML::XPath.first(root, 'x:Error', {'x' => obj_ns.uri})
+            options[:error] = error.text if error
+            
+            resolution = REXML::XPath.first(root, 'x:Resolution', {'x' => obj_ns.uri})
+            options[:resolution] = resolution.text if resolution
+            
+            size = REXML::XPath.first(root, 'x:Size', {'x' => obj_ns.uri})
+            options[:size] = size.text if size
+            
+            pix_size = REXML::XPath.first(root, 'x:PixSize', {'x' => obj_ns.uri})
+            options[:pix_size] = pix_size.text if pix_size
+            
+            CoordFitsColumns.new(options)
+          end
+          
+          def ==(c)
+            self.name == c.name and
+            self.value == c.value and
+            self.error == c.error and
+            self.resolution == c.resolution and
+            self.size == c.size and
+            self.pix_size == c.pix_size
+          end
+        end
+        
+        # Coordinate references to a specific FITS file
+        class AstroCoordsFile
+          include SerializableToXml
+          
+          attr_reader :file, :time, :position, :velocity, :spectral, :redshift
+          
+          def initialize(options={})
+            raise_argument_required_error('file') if !options.has_key?(:file)
+            options.each { |key, value| send("#{key}=", value) }
+          end
+          
+          def file=(f)
+            raise_argument_required_error('file') if !f
+            raise_type_mismatch_error(f, Fits)
+            @file = f
+          end
+          
+          def time=(t)
+            raise_type_mismatch_error(t, CoordFitsColumns)
+            @time = t
+          end
+          
+          def position=(p)
+            raise_type_mismatch_error(p, CoordFitsColumns)
+            @position = p
+          end
+          
+          def velocity=(v)
+            raise_type_mismatch_error(v, CoordFitsColumns)
+            @velocity = v
+          end
+          
+          def spectral=(s)
+            raise_type_mismatch_error(s, CoordFitsColumns)
+            @spectral = s
+          end
+          
+          def redshift=(r)
+            raise_type_mismatch_error(r, CoordFitsColumns)
+            @redshift = r
+          end
+          
+          def to_xml(name=nil)
+            el = element(name)
+            
+            el.add_element(self.file.to_xml('FITSFile'))
+            el.add_element(self.time.to_xml('FITSTime')) if self.time
+            el.add_element(self.position.to_xml('FITSPosition')) if self.position
+            el.add_element(self.velocity.to_xml('FITSVelocity')) if self.velocity
+            el.add_element(self.spectral.to_xml('FITSSpectral')) if self.spectral
+            el.add_element(self.redshift.to_xml('FITSRedshift')) if self.redshift
+            
+            collapse_namespaces(el)
+            
+            el
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {
+              :file => Fits.from_xml(REXML::XPath.first(root, 'x:FITSFile', {'x' => obj_ns.uri})),
+            }
+            
+            time = REXML::XPath.first(root, 'x:FITSTime', {'x' => obj_ns.uri})
+            options[:time] = CoordFitsColumns.from_xml(time) if time
+            
+            position = REXML::XPath.first(root, 'x:FITSPosition', {'x' => obj_ns.uri})
+            options[:position] = CoordFitsColumns.from_xml(position) if position
+            
+            velocity = REXML::XPath.first(root, 'x:FITSVelocity', {'x' => obj_ns.uri})
+            options[:velocity] = CoordFitsColumns.from_xml(velocity) if velocity
+            
+            spectral = REXML::XPath.first(root, 'x:FITSSpectral', {'x' => obj_ns.uri})
+            options[:spectral] = CoordFitsColumns.from_xml(spectral) if spectral
+            
+            redshift = REXML::XPath.first(root, 'x:FITSRedshift', {'x' => obj_ns.uri})
+            options[:redshift] = CoordFitsColumns.from_xml(redshift) if redshift
+            
+            AstroCoordsFile.new(options)
+          end
+          
+          def ==(c)
+            self.file == c.file and
+            self.time == c.time and
+            self.position == c.position and
+            self.velocity == c.velocity and
+            self.spectral == c.spectral and
+            self.redshift == c.redshift
+          end
+        end
+        
+        class ListOfCoordinates < TypedArray
+          def self.restricted_to; [Coordinate] end
+        end
+        
+        class ListOfPixelCoordinates < TypedArray
+          def self.restricted_to; [PixelCoordinate] end
+          def self.minimum_length; 1 end
+        end
+        
+        # The generic coordsType
+        class CoordsType
+          attr_reader :coordinates, :coord_system_id
+          
+          def initialize(options={})
+            raise_argument_required_error('coord system id') if !options.has_key?(:coord_system_id)
+            options.each { |key, value| send("#{key}=", value) }
+          end
+          
+          def coordinates=(cs)
+            cs = ListOfCoordinates.new(cs) if cs.class == Array
+            raise_type_mismatch_error(cs, ListOfCoordinates) if cs
+            @coordinates = if cs
+              cs.size > 0 ? cs : nil
+            else
+              nil
+            end
+          end
+          
+          def coord_system_id=(sys)
+            raise_argument_required_error('coord system id') if !sys
+            if sys
+              @coord_system_id = sys.is_a?(IdRef) ? sys : IdRef.new(sys.to_s)
+            end
+          end
+          
+          def ==(c)
+            self.coord_system_id == c.coord_system_id and
+            self.coordinates == c.coordinates
+          end
+        end
+        
+        class Spectral < ScalarCoordinateType
+          include SerializableToXml
+          
+          attr_reader :unit
+          
+          def unit=(u)
+            raise_type_mismatch_error(u, SpectralUnit) if u
+            @unit = u
+          end
+          
+          def to_xml
+             el = element()
+             el.attributes["#{obj_ns.prefix}:unit"] = self.unit.to_s if self.unit
+
+             name = REXML::Element.new("#{obj_ns.prefix}:Name")
+             name.text = self.name
+
+             el.add_element(name)
+             el.add_element(self.value.to_xml) if self.value
+             self.error.each { |e| el.add_element(e.to_xml) } if self.error
+             self.resolution.each { |r| el.add_element(r.to_xml) } if self.resolution
+             self.size.each { |s| el.add_element(s.to_xml) } if self.size
+             self.pix_size.each { |p| el.add_element(p.to_xml) } if self.pix_size
+             
+             collapse_namespaces(el)
+
+             el
+           end
+
+           def self.from_xml(xml)
+             root = element_from(xml)
+
+             options = {
+              :name => REXML::XPath.first(root, 'x:Name', {'x' => obj_ns.uri}).text
+             }
+             unit = root.attributes.get_attribute_ns(obj_ns.uri, 'unit')
+             options[:unit] = SpectralUnit.new(unit.value) if unit
+             options[:value] = xml_to_obj(root, CValue, true)
+             options[:error] = xml_to_obj(root, CError)
+             options[:resolution] = xml_to_obj(root, CResolution)
+             options[:size] = xml_to_obj(root, CSize)
+             options[:pix_size] = xml_to_obj(root, CPixSize)
+
+             Spectral.new(options)
+           end
+          
+          def ==(c)
+            super(c) and self.unit == c.unit
+          end
+        end
+        
+        class Redshift < ScalarCoordinateType
+          include SerializableToXml
+          
+          attr_reader :unit, :vel_time_unit
+          
+          def unit=(u)
+            raise_type_mismatch_error(u, PosUnit) if u
+            @unit = u
+          end
+          
+          def vel_time_unit=(vtu)
+            raise_type_mismatch_error(vtu, VelTimeUnit) if vtu
+            @vel_time_unit = vtu
+          end
+          
+          def to_xml
+              el = element()
+              el.attributes["#{obj_ns.prefix}:unit"] = self.unit.to_s if self.unit
+              el.attributes["#{obj_ns.prefix}:vel_time_unit"] = self.vel_time_unit.to_s if self.vel_time_unit
+
+              name = REXML::Element.new("#{obj_ns.prefix}:Name")
+              name.text = self.name
+
+              el.add_element(name)
+              el.add_element(self.value.to_xml) if self.value
+              self.error.each { |e| el.add_element(e.to_xml) } if self.error
+              self.resolution.each { |r| el.add_element(r.to_xml) } if self.resolution
+              self.size.each { |s| el.add_element(s.to_xml) } if self.size
+              self.pix_size.each { |p| el.add_element(p.to_xml) } if self.pix_size
+              
+              collapse_namespaces(el)
+
+              el
+            end
+
+            def self.from_xml(xml)
+              root = element_from(xml)
+
+              options = {
+               :name => REXML::XPath.first(root, 'x:Name', {'x' => obj_ns.uri}).text
+              }
+              unit = root.attributes.get_attribute_ns(obj_ns.uri, 'unit')
+              options[:unit] = PosUnit.new(unit.value) if unit
+              vel_time_unit = root.attributes.get_attribute_ns(obj_ns.uri, 'vel_time_unit')
+              options[:vel_time_unit] = VelTimeUnit.new(vel_time_unit.value) if vel_time_unit
+              options[:value] = xml_to_obj(root, CValue, true)
+              options[:error] = xml_to_obj(root, CError)
+              options[:resolution] = xml_to_obj(root, CResolution)
+              options[:size] = xml_to_obj(root, CSize)
+              options[:pix_size] = xml_to_obj(root, CPixSize)
+
+              Redshift.new(options)
+            end
+
+          def ==(c)
+            super(c) and
+            self.unit == c.unit and
+            self.vel_time_unit == c.vel_time_unit
+          end
+        end
+        
+        # The astronomical (STC) coordsType
+        class AstroCoordsType < CoordsType
+          attr_reader :time, :position, :velocity, :spectral, :redshift, :coord_file
+          
+          def time=(t)
+            raise_type_mismatch_error(t, TimeCoordinate) if t
+            @time = t
+          end
+          
+          def position=(p)
+            raise_type_mismatch_error(p, Position) if p
+            @position = p
+          end
+          
+          def velocity=(v)
+            raise_type_mismatch_error(v, Velocity) if v
+            @velocity = v
+          end
+          
+          def spectral=(s)
+            raise_type_mismatch_error(s, Spectral) if s
+            @spectral = s
+          end
+          
+          def redshift=(r)
+            raise_type_mismatch_error(r, Redshift) if r
+            @redshift = r
+          end
+          
+          # Some or all coordinate values may be given in file
+          def coord_file=(c)
+            raise_type_mismatch_error(c, AstroCoordsFile) if c
+            @coord_file = c
+          end
+          
+          def ==(c)
+            super(c) and
+            self.time == c.time and
+            self.position == c.position and
+            self.velocity == c.velocity and
+            self.spectral == c.spectral and
+            self.redshift == c.redshift and
+            self.coord_file == c.coord_file
+          end
+        end
+        
+        # The pixel coordinates type
+        class PixelCoordsType < CoordsType
+          attr_reader :coordinates
+          
+          def coordinates=(cs)
+            cs = ListOfPixelCoordinates.new(cs) if cs.class == Array
+            raise_type_mismatch_error(cs, ListOfPixelCoordinates) if cs
+            @coordinates = cs
+          end
+        end
+        
+        # Head element of Coords group (not abstract)
+        module Coords
+          include SerializableToXml
+        end
+        
+        # The coordinate element consists either of a coordinate file or a sequence of time element, spatial coordinate element,
+        # velocity element, and redshift element; the spatial and velocity elements may be scalar or vector; it needs to refer
+        # to a coordinate system
+        class AstroCoords < AstroCoordsType
+          include Coords
+          
+          def to_xml(name=nil, ns=nil)
+            el = element(name, ns)
+            el.attributes["#{obj_ns.prefix}:coord_system_id"] = self.coord_system_id.to_s
+             
+            self.coordinates.each { |c| el.add_element(c.to_xml) } if self.coordinates
+            el.add_element(self.time.to_xml('Time')) if self.time
+            el.add_element(self.position.to_xml) if self.position
+            el.add_element(self.velocity.to_xml) if self.velocity
+            el.add_element(self.spectral.to_xml) if self.spectral
+            el.add_element(self.redshift.to_xml) if self.redshift
+            el.add_element(self.coord_file.to_xml('CoordFile')) if self.coord_file
+            
+            collapse_namespaces(el)
+             
+            el
+          end
+           
+          def self.from_xml(xml)
+             root = element_from(xml)
+             
+             options = {
+               :coord_system_id => IdRef.new(root.attributes.get_attribute_ns(obj_ns.uri, 'coord_system_id').value),
+             }
+             options[:coordinates] = xml_to_obj(root, Coordinate)
+             time = REXML::XPath.first(root, 'x:Time', {'x' => obj_ns.uri})
+             options[:time] = TimeCoordinate.from_xml(time) if time
+             options[:position] = xml_to_obj(root, Position, true)
+             options[:velocity] = xml_to_obj(root, Velocity, true)
+             options[:spectral] = xml_to_obj(root, Spectral, true)
+             options[:redshift] = xml_to_obj(root, Redshift, true)
+             coord_file = REXML::XPath.first(root, 'x:CoordFile', {'x' => obj_ns.uri})
+             options[:coord_file] = AstroCoordsFile.from_xml(coord_file) if coord_file
+             
+             AstroCoords.new(options)
+          end
+        end
+        
+        # Contains pixel coordinates
+        class PixelCoords < PixelCoordsType
+          include Coords
+          
+          def to_xml
+            el = element()
+            el.attributes["#{obj_ns.prefix}:coord_system_id"] = self.coord_system_id.to_s
+             
+            self.coordinates.each { |c| el.add_element(c.to_xml) } if self.coordinates
+            
+            collapse_namespaces(el)
+            
+            el
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {
+              :coord_system_id => IdRef.new(root.attributes.get_attribute_ns(obj_ns.uri, 'coord_system_id').value)
+             }
+             options[:coordinates] = xml_to_obj(root, PixelCoordinate)
+             
+             PixelCoords.new(options)
+          end
+        end
+        
+      end
+    end
+  end
+end