voruby 1.1.1 → 2.0.0

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

@@ -0,0 +1,3271 @@
+require 'voruby/stc/support'
+require 'voruby/stc/1.10/region'
+include VORuby::STC::V1_10::Region
+
+module VORuby
+  module STC
+    module V1_10
+      module STC
+        include XMLUtilities
+        
+        # A CoordFrame has to have at least a name
+        class CoordFrameType
+          include SerializableToXml
+          
+          attr_reader :name
+          
+          def initialize(options={})
+            options.each { |key, value| send("#{key}=", value) }
+          end
+          
+          def name=(n)
+            @name = n ? n.to_s : nil
+          end
+          
+          def to_xml(name=nil)
+            el = element(name)
+
+            if self.name
+              name = REXML::Element.new("#{obj_ns.prefix}:Name")
+              name.text = self.name
+              el.add_element(name)
+            end
+            
+            el
+          end
+          
+          def ==(f)
+            self.name == f.name
+          end
+        end
+        
+        # CoordFrame substitution group head element
+        module CoordFrame
+          include SerializableToXml
+        end
+        
+        class CoordFrameList < TypedArray
+          def self.restricted_to; [CoordFrame] end
+          def self.minimum_length; 1 end
+        end
+        
+        # Head element (not abstract) of the CoordSys group
+        module CoordSys; end
+        
+        # Coordinate equinox: B{year} or J{year} with at least one decimal; do not use in conjunction with ICRS
+        class CoordEquinox
+          attr_reader :value
+          
+          def initialize(equinox)
+            self.value = equinox
+          end
+          
+          def value=(e)
+            raise ArgumentError, "equinox '#{e}' in wrong format" if !e.match(/^[BJ]\-?\d?\d?\d?\d\d\d\d\.\d\d?\d?$/)
+            @value = e
+          end
+          
+          def to_s
+            self.value.to_s
+          end
+          
+          def ==(c)
+            self.value == c.value
+          end
+        end
+        
+        # Abstract space reference frame type
+        class SpaceRefFrameType
+          def ==(f)
+            self.class == f.class
+          end
+        end
+        
+        # Head element for the Coordinate reference frame substitution group: optional equinox
+        # with either a standard reference system (ICRS, FK5, FK4) and optional standard pole
+        # (equatorial, ecliptic, galactic, etc.), or a custom frame with pole (positive Z-axis)
+        # and positive X-axis direction 
+        module SpaceRefFrame; end
+        
+        # ICRS type
+        class IcrsType < SpaceRefFrameType
+          include SerializableToXml
+          
+          def to_xml(name=nil)
+            element(name)
+          end
+          
+          def self.from_xml(xml)
+            self.new
+          end
+        end
+        
+        # FK[45] type
+        class FkType < SpaceRefFrameType
+          include SerializableToXml
+          
+          attr_reader :equinox
+          
+          def initialize(equinox)
+            self.equinox = equinox
+          end
+          
+          def equinox=(e)
+            e = CoordEquinox.new(e.to_s) if !e.is_a?(CoordEquinox)
+            @equinox = e
+          end
+          
+          def to_xml(name=nil)
+            el = element(name)
+            
+            equinox = REXML::Element.new("#{obj_ns.prefix}:Equinox")
+            equinox.text = self.equinox.to_s
+            el.add_element(equinox)
+            
+            el
+          end
+    
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            self.new(
+              CoordEquinox.new(
+                REXML::XPath.first(root, 'x:Equinox', {'x' => obj_ns.uri}).text
+              )
+            )
+          end
+          
+          def ==(f)
+            super(f) and
+            self.equinox == f.equinox
+          end
+        end
+        
+        # A custome space reference frame type
+        # Define coordinate reference frame from scratch; pole and X-axis need to be defined in a known coordinate system
+        class CustomSpaceRefFrameType < SpaceRefFrameType
+          include SerializableToXml
+          
+          attr_reader :frame, :pole_zaxis, :xaxis
+          
+          def initialize(options={})
+            raise_argument_required_error('frame') if !options.has_key?(:frame)
+            raise_argument_required_error('pole z axis') if !options.has_key?(:pole_zaxis)
+            raise_argument_required_error('x axis') if !options.has_key?(:xaxis)
+            options.each { |key, value| send("#{key}=", value) }
+          end
+          
+          def frame=(f)
+            raise_argument_required_error('frame') if !f
+            @frame = f.to_s
+          end
+          
+          def pole_zaxis=(p)
+            raise_argument_required_error('pole z axis') if !p
+            raise_type_mismatch_error(p, AstroCoordsType)
+            @pole_zaxis = p
+          end
+          
+          def xaxis=(x)
+            raise_argument_required_error('x axis') if !x
+            raise_type_mismatch_error(x, AstroCoordsType)
+            @xaxis = x
+          end
+          
+          def ==(f)
+            super(f) and
+            self.frame == f.frame and
+            self.pole_zaxis == f.pole_zaxis and
+            self.xaxis == f.xaxis
+          end
+          
+          def to_xml(name=nil)
+            el = element(name)
+            
+            coords_ns = NAMESPACES['VORuby::STC::V1_10::Coords']
+            el.add_namespace(coords_ns.prefix, coords_ns.uri)
+            
+            frame = REXML::Element.new("#{obj_ns.prefix}:Frame")
+            frame.text = self.frame
+            el.add_element(frame)
+            
+            el.add_element(self.pole_zaxis.to_xml('Pole_Zaxis', obj_ns))
+            el.add_element(self.xaxis.to_xml('Xaxis', obj_ns))
+            
+            collapse_namespaces(el)
+            
+            el
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {
+              :frame => REXML::XPath.first(root, 'x:Frame', {'x' => obj_ns.uri}).text,
+              :pole_zaxis => AstroCoords.from_xml(REXML::XPath.first(root, 'x:Pole_Zaxis', {'x' => obj_ns.uri})),
+              :xaxis => AstroCoords.from_xml(REXML::XPath.first(root, 'x:Xaxis', {'x' => obj_ns.uri}))
+            }
+            
+            CustomSpaceRefFrameType.new(options)
+          end
+        end
+        
+        # The ICRS reference frame
+        class Icrs < IcrsType
+          include SpaceRefFrame
+          
+          def self.element_name; 'ICRS' end
+          
+          def to_xml
+            super('ICRS')
+          end
+        end
+        
+        # FK4; needs a Besselian epoch
+        class Fk4 < FkType
+          include SpaceRefFrame
+          
+          def self.element_name; 'FK4' end
+          
+          def to_xml
+            super('FK4')
+          end
+        end
+        
+        # FK5; needs a Julian epoch
+        class Fk5 < FkType
+          include SpaceRefFrame
+          
+          def self.element_name; 'FK5' end
+          
+          def to_xml
+            super('FK5')
+          end
+        end
+        
+        # Ecliptic coorindates; needs an epoch
+        class Ecliptic < FkType
+          include SpaceRefFrame
+          
+          def self.element_name; 'ECLIPTIC' end
+          
+          def to_xml
+            super('ECLIPTIC')
+          end
+        end
+        
+        # Galactic coordinates; first system
+        class GalacticI < IcrsType
+          include SpaceRefFrame
+          
+          def self.element_name; 'GALACTIC_I' end
+          
+          def to_xml
+            super('GALACTIC_I')
+          end
+        end
+        
+        # Galactic coordinates; second system
+        class GalacticII < IcrsType
+          include SpaceRefFrame
+          
+          def self.element_name; 'GALACTIC_II' end
+          
+          def to_xml
+            super('GALACTIC_II')
+          end
+        end
+        
+        # SuperGalactic coordinates
+        class SuperGalactic < IcrsType
+          include SpaceRefFrame
+          
+          def self.element_name; 'SUPER_GALACTIC' end
+          
+          def to_xml
+            super('SUPER_GALACTIC')
+          end
+        end
+        
+        # Local Azimuth and Elevation coordinates
+        class AzEl < IcrsType
+          include SpaceRefFrame
+          
+          def self.element_name; 'AZ_EL' end
+          
+          def to_xml
+            super('AZ_EL')
+          end
+        end
+        
+        # Generic Body coordinates
+        class Body < IcrsType
+          include SpaceRefFrame
+          
+          def self.element_name; 'BODY' end
+          
+          def to_xml
+            super('BODY')
+          end
+        end
+        
+        # The geographic reference frame
+        class Geo < IcrsType
+          include SpaceRefFrame
+          
+          def self.element_name; 'GEO' end
+          
+          def to_xml
+            super('GEO')
+          end
+        end
+        
+        # The geodetic reference frame
+        class Geod < IcrsType
+          include SpaceRefFrame
+          
+          def self.element_name; 'GEOD' end
+          
+          def to_xml
+            super('GEOD')
+          end
+        end
+        
+        # The geomagnetic reference frame
+        class Mag < IcrsType
+          include SpaceRefFrame
+          
+          def self.element_name; 'MAG' end
+          
+          def to_xml
+            super('MAG')
+          end
+        end
+        
+        # the geocentric solar ecliptic reference frame
+        class Gse < IcrsType
+          include SpaceRefFrame
+          
+          def self.element_name; 'GSE' end
+          
+          def to_xml
+            super('GSE')
+          end
+        end
+        
+        # The geocentric solar magnetic reference frame
+        class Gsm < IcrsType
+          include SpaceRefFrame
+          
+          def self.element_name; 'GSM' end
+          
+          def to_xml
+            super('GSM')
+          end
+        end
+        
+        # The solar magnetic reference frame
+        class Sm < IcrsType
+          include SpaceRefFrame
+          
+          def self.element_name; 'SM' end
+          
+          def to_xml
+            super('SM')
+          end
+        end
+        
+        # The heliographic reference frame
+        class Hgc < IcrsType
+          include SpaceRefFrame
+          
+          def self.element_name; 'HGC' end
+          
+          def to_xml
+            super('HGC')
+          end
+        end
+        
+        # The heliocentric earth ecliptic reference frame
+        class Hee < IcrsType
+          include SpaceRefFrame
+          
+          def self.element_name; 'HEE' end
+          
+          def to_xml
+            super('HEE')
+          end
+        end
+        
+        # The heliocentric earth equatorial reference frame
+        class Heeq < IcrsType
+          include SpaceRefFrame
+          
+          def self.element_name; 'HEEQ' end
+          
+          def to_xml
+            super('HEEQ')
+          end
+        end
+        
+        # The heliocentric intertial reference frame
+        class Hci < IcrsType
+          include SpaceRefFrame
+          
+          def self.element_name; 'HCI' end
+          
+          def to_xml
+            super('HCI')
+          end
+        end
+        
+        # The heliocentric of date reference frame
+        class Hcd < IcrsType
+          include SpaceRefFrame
+          
+          def self.element_name; 'HCD' end
+          
+          def to_xml
+            super('HCD')
+          end
+        end
+        
+        # The planetocentric reference frame anchored on Mercury
+        class MercuryC < IcrsType
+          include SpaceRefFrame
+          
+          def self.element_name; 'MERCURY_C' end
+          
+          def to_xml
+            super('MERCURY_C')
+          end
+        end
+        
+        # The planetocentric reference frame anchored on Venus
+        class VenusC < IcrsType
+          include SpaceRefFrame
+          
+          def self.element_name; 'VENUS_C' end
+          
+          def to_xml
+            super('VENUS_C')
+          end
+        end
+        
+        # The lunacentric reference frame anchored on the moon
+        class LunaC < IcrsType
+          include SpaceRefFrame
+          
+          def self.element_name; 'LUNA_C' end
+          
+          def to_xml
+            super('LUNA_C')
+          end
+        end
+        
+        # The planetocentric reference frame anchored on Mars
+        class MarsC < IcrsType
+          include SpaceRefFrame
+          
+          def self.element_name; 'MARS_C' end
+          
+          def to_xml
+            super('MARS_C')
+          end
+        end
+        
+        # The planetocentric reference frame anchored on Jupiter
+        class JupiterCIII < IcrsType
+          include SpaceRefFrame
+          
+          def self.element_name; 'JUPITER_C_III' end
+          
+          def to_xml
+            super('JUPITER_C_III')
+          end
+        end
+        
+        # The planetocentric reference frame anchored on Saturn
+        class SaturnCIII < IcrsType
+          include SpaceRefFrame
+          
+          def self.element_name; 'SATURN_C_III' end
+          
+          def to_xml
+            super('SATURN_C_III')
+          end
+        end
+        
+        # The planetocentric reference frame anchored on Uranus
+        class UranusCIII < IcrsType
+          include SpaceRefFrame
+          
+          def self.element_name; 'URANUS_C_III' end
+          
+          def to_xml
+            super('URANUS_C_III')
+          end
+        end
+        
+        # The planetocentric reference frame anchored on Neptune
+        class NeptuneCIII < IcrsType
+          include SpaceRefFrame
+          
+          def self.element_name; 'NEPTUNE_C_III' end
+          
+          def to_xml
+            super('NEPTUNE_C_III')
+          end
+        end
+        
+        # The planetocentric reference frame anchored on Pluto
+        class PlutoC < IcrsType
+          include SpaceRefFrame
+          
+          def self.element_name; 'PLUTO_C' end
+          
+          def to_xml
+            super('PLUTO_C')
+          end
+        end
+        
+        # The planetographic reference frame anchored on Mercury
+        class MercuryG < IcrsType
+          include SpaceRefFrame
+          
+          def self.element_name; 'MERCURY_G' end
+          
+          def to_xml
+            super('MERCURY_G')
+          end
+        end
+        
+        # The planetographic reference frame anchored on Venus
+        class VenusG < IcrsType
+          include SpaceRefFrame
+          
+          def self.element_name; 'VENUS_G' end
+          
+          def to_xml
+            super('VENUS_G')
+          end
+        end
+        
+        # The planetographic reference frame anchored on the moon
+        class LunaG < IcrsType
+          include SpaceRefFrame
+          
+          def self.element_name; 'LUNA_G' end
+          
+          def to_xml
+            super('LUNA_G')
+          end
+        end
+        
+        # The planetographic reference frame anchored on Mars
+        class MarsG < IcrsType
+          include SpaceRefFrame
+          
+          def self.element_name; 'MARS_G' end
+          
+          def to_xml
+            super('MARS_G')
+          end
+        end
+        
+        # The planetographic reference frame anchored on Jupiter
+        class JupiterGIII < IcrsType
+          include SpaceRefFrame
+          
+          def self.element_name; 'JUPITER_G_III' end
+          
+          def to_xml
+            super('JUPITER_G_III')
+          end
+        end
+        
+        # The planetographic reference frame anchored on Saturn
+        class SaturnGIII < IcrsType
+          include SpaceRefFrame
+          
+          def self.element_name; 'SATURN_G_III' end
+          
+          def to_xml
+            super('SATURN_G_III')
+          end
+        end
+        
+        # The planetographic reference frame anchored on Uranus
+        class UranusGIII < IcrsType
+          include SpaceRefFrame
+          
+          def self.element_name; 'URANUS_G_III' end
+          
+          def to_xml
+            super('URANUS_G_III')
+          end
+        end
+        
+        # The planetographic reference frame anchored on Neptune
+        class NeptuneGIII < IcrsType
+          include SpaceRefFrame
+          
+          def self.element_name; 'NEPTUNE_G_III' end
+          
+          def to_xml
+            super('NEPTUNE_G_III')
+          end
+        end
+        
+        # The planetographic reference frame anchored on Pluton
+        class PlutoG < IcrsType
+          include SpaceRefFrame
+          
+          def self.element_name; 'PLUTO_G' end
+          
+          def to_xml
+            super('PLUTO_G')
+          end
+        end
+        
+        # Unknown space reference frame; the client is responsible for assigning a default
+        class UnknownFrame < IcrsType
+          include SpaceRefFrame
+          
+          def self.element_name; 'UNKNOWNFRame' end
+          
+          def to_xml
+            super('UNKNOWNFrame')
+          end
+        end
+        
+        # Coordinate reference frame: a custom pole (positive Z-axis) and positive X-axis direction
+        class CustomSpaceRefFrame < CustomSpaceRefFrameType
+          include SpaceRefFrame
+          
+          def self.element_name; 'CustomSpaceRefFrame' end
+          
+          def to_xml
+            super('CustomSpaceRefFrame')
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {
+              :frame => REXML::XPath.first(root, 'x:Frame', {'x' => obj_ns.uri}).text,
+              :pole_zaxis => AstroCoords.from_xml(REXML::XPath.first(root, 'x:Pole_Zaxis', {'x' => obj_ns.uri})),
+              :xaxis => AstroCoords.from_xml(REXML::XPath.first(root, 'x:Xaxis', {'x' => obj_ns.uri}))
+            }
+            
+            CustomSpaceRefFrame.new(options)
+          end
+        end
+        
+        # If solar system positions are implied anywhere, the planetary ephemeris to
+        # be used needs to be provided - usually JPL-DE405 with ICRS and JPL-DE200
+        # with FK5
+        class PlanetaryEphem < Enumeration
+          def self.choices; ['JPL-DE200', 'JPL-DE405'] end
+        end
+        
+        # Abstract type for reference positions
+        class ReferencePositionType
+          include SerializableToXml
+        end
+        
+        # Type for standard reference positions
+        class StdRefPos < ReferencePositionType
+          attr_reader :planetary_ephem
+          
+          def initialize(ephem=nil)
+            self.planetary_ephem = ephem
+          end
+          
+          def planetary_ephem=(e)
+            if e
+              e = PlanetaryEphem.new(e) if e.is_a?(String)
+              raise_type_mismatch_error(e, PlanetaryEphem)
+            end
+            
+            @planetary_ephem = e
+          end
+          
+          def to_xml(name=nil)
+            el = element(name)
+            
+            if self.planetary_ephem
+              ephem = REXML::Element.new("#{obj_ns.prefix}:PlanetaryEphem")
+              ephem.text = self.planetary_ephem.to_s
+              el.add_element(ephem)
+            end
+            
+            collapse_namespaces(el)
+            el
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            ephem_node = REXML::XPath.first(root, 'x:PlanetaryEphem', {'x' => obj_ns.uri})
+            ephem = ephem_node ? PlanetaryEphem.new(ephem_node.text) : nil
+            
+            self.new(ephem)
+          end
+          
+          def ==(p)
+            self.planetary_ephem == p.planetary_ephem
+          end
+        end
+        
+        # Type for custom positions: specifies reference origin<
+        class CustomRefPosType < ReferencePositionType
+          attr_reader :coord_origin
+          
+          def initialize(origin)
+            self.coord_origin = origin
+          end
+          
+          def coord_origin=(c)
+            raise_argument_required_error('coordinate origin required') if !c
+            raise_type_mismatch_error(c, AstroCoordsType)
+            @coord_origin = c
+          end
+          
+          def to_xml(name=nil)
+            el = element(name)
+            
+            coords_ns = NAMESPACES['VORuby::STC::V1_10::Coords']
+            el.add_namespace(coords_ns.prefix, coords_ns.uri)
+            
+            el.add_element(self.coord_origin.to_xml('CoordOrigin', obj_ns))
+            
+            collapse_namespaces(el)
+            el
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            self.new(
+              AstroCoords.from_xml(REXML::XPath.first(root, 'x:CoordOrigin', {'x' => obj_ns.uri}))
+            )
+          end
+          
+          def ==(p)
+            self.coord_origin == p.coord_origin
+          end
+        end
+        
+        # Head element from the ReferencePosition substitution group: either a "known place"
+        # such as geocenter or barycenter (RefPos), or a position defined in a known coordinate
+        # system (CoordOrigin)
+        module ReferencePosition; end
+        
+        # Location of the observer/telescope
+        class Topocenter < StdRefPos
+          include ReferencePosition
+          
+          def self.element_name; 'TOPOCENTER' end
+          
+          def to_xml
+            super('TOPOCENTER')
+          end
+        end
+        
+        # Barycenter of the solar system
+        class Barycenter < StdRefPos
+          include ReferencePosition
+          
+          def self.element_name; 'BARYCENTER' end
+          
+          def to_xml
+            super('BARYCENTER')
+          end
+        end
+        
+        # Center of the sun
+        class Heliocenter < StdRefPos
+          include ReferencePosition
+          
+          def self.element_name; 'HELIOCENTER' end
+          
+          def to_xml
+            super('HELIOCENTER')
+          end
+        end
+        
+        # Center of the earth
+        class Geocenter < StdRefPos
+          include ReferencePosition
+          
+          def self.element_name; 'GEOCENTER' end
+          
+          def to_xml
+            super('GEOCENTER')
+          end
+        end
+        
+        # Local standard of rest (only used form Doppler velocities)
+        class Lsr < StdRefPos
+          include ReferencePosition
+          
+          def self.element_name; 'LSR' end
+          
+          def to_xml
+            super('LSR')
+          end
+        end
+        
+        # Center of the galaxy
+        class GalacticCenter < StdRefPos
+          include ReferencePosition
+          
+          def self.element_name; 'GALACTIC_CENTER' end
+          
+          def to_xml
+            super('GALACTIC_CENTER')
+          end
+        end
+        
+        # Center of the local super cluster
+        class SuperGalacticCenter < StdRefPos
+          include ReferencePosition
+          
+          def self.element_name; 'SUPER_GALACTIC_CENTER' end
+          
+          def to_xml
+            super('SUPER_GALACTIC_CENTER')
+          end
+        end
+        
+        # Center of the moon
+        class Moon < StdRefPos
+          include ReferencePosition
+          
+          def self.element_name; 'MOON' end
+          
+          def to_xml
+            super('MOON')
+          end
+        end
+        
+        # Barycenter of the Earth-Moon system
+        class Embarycenter < StdRefPos
+          include ReferencePosition
+          
+          def self.element_name; 'EMBARYCENTER' end
+          
+          def to_xml
+            super('EMBARYCENTER')
+          end
+        end
+        
+        # Center of Mercury
+        class Mercury < StdRefPos
+          include ReferencePosition
+          
+          def self.element_name; 'MERCURY' end
+          
+          def to_xml
+            super('MERCURY')
+          end
+        end
+        
+        # Center of Venus
+        class Venus < StdRefPos
+          include ReferencePosition
+          
+          def self.element_name; 'VENUS' end
+          
+          def to_xml
+            super('VENUS')
+          end
+        end
+        
+        # Center of Mars
+        class Mars < StdRefPos
+          include ReferencePosition
+          
+          def self.element_name; 'MARS' end
+          
+          def to_xml
+            super('MARS')
+          end
+        end
+        
+        # Center of Jupiter
+        class Jupiter < StdRefPos
+          include ReferencePosition
+          
+          def self.element_name; 'JUPITER' end
+          
+          def to_xml
+            super('JUPITER')
+          end
+        end
+        
+        # Center of Saturn
+        class Saturn < StdRefPos
+          include ReferencePosition
+          
+          def self.element_name; 'SATURN' end
+          
+          def to_xml
+            super('SATURN')
+          end
+        end
+        
+        # Center of Uranus
+        class Uranus < StdRefPos
+          include ReferencePosition
+          
+          def self.element_name; 'URANUS' end
+          
+          def to_xml
+            super('URANUS')
+          end
+        end
+        
+        # Center of Neptune
+        class Neptune < StdRefPos
+          include ReferencePosition
+          
+          def self.element_name; 'NEPTUNE' end
+          
+          def to_xml
+            super('NEPTUNE')
+          end
+        end
+        
+        # Center of Pluto
+        class Pluto < StdRefPos
+          include ReferencePosition
+          
+          def self.element_name; 'PLUTO' end
+          
+          def to_xml
+            super('PLUTO')
+          end
+        end
+        
+        # A relocatable origin, especially useful for simulations
+        class Relocatable < StdRefPos
+          include ReferencePosition
+          
+          def self.element_name; 'RELOCATABLE' end
+          
+          def to_xml
+            super('RELOCATABLE')
+          end
+        end
+        
+        # Unknown origin; the client is responsible for assigning a default
+        class UnknownRefPos < StdRefPos
+          include ReferencePosition
+          
+          def self.element_name; 'UNKNOWNRefPos' end
+          
+          def to_xml
+            super('UNKNOWNRefPos')
+          end
+        end
+        
+        # Origin of the coordinate system, given as a position in another, known, coordinate system
+        class CustomRefPos < CustomRefPosType
+          include ReferencePosition
+          
+          def to_xml
+            super('CustomRefPos')
+          end
+        end
+        
+        # Provides the coordinate definitions: number of axes, SPHERICAL, CARTESIAN, or UNITSPHERE,
+        # presence of velocities
+        class CoordFlavorType
+          include SerializableToXml
+          
+          attr_reader :coord_vel
+          
+          def initialize(naxes=2, vel=false)
+            self.coord_naxes = naxes
+            self.coord_vel = vel
+          end
+          
+          def coord_naxes=(n)
+            n = Integer(n)
+            raise ArgumentError, 'number of axes must be between 1 and 3' if n and (n < 1 or n > 3)
+            @coord_naxes = n
+          end
+          
+          def coord_naxes
+            @coord_naxes || 2
+          end
+          
+          def coord_vel=(v)
+            @coord_vel = v ? true : false
+          end
+          
+          def coord_vel
+            @coord_vel == nil ? false : @coord_vel
+          end
+          
+          def to_xml(name=nil)
+            el = element(name)
+            el.attributes["#{obj_ns.prefix}:coord_naxes"] = self.coord_naxes.to_s
+            el.attributes["#{obj_ns.prefix}:coord_vel"] = self.coord_vel.to_s
+            el
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            coord_naxes = root.attributes.get_attribute_ns(obj_ns.uri, 'coord_naxes')
+            coord_vel = root.attributes.get_attribute_ns(obj_ns.uri, 'coord_vel')
+            
+            self.new(
+              coord_naxes ? Integer(coord_naxes.value) : nil,
+              coord_vel ? (coord_vel.value == 'true' ? true : false) : nil
+            )
+          end
+          
+          def ==(f)
+            self.coord_naxes == f.coord_naxes and
+            self.coord_vel == f.coord_vel
+          end
+        end
+        
+        # Abstract head element for the CoordFlavor substitution group
+        module CoordFlavor; end
+        
+        # Spherical (2-D) coordinates
+        class Spherical < CoordFlavorType
+          include CoordFlavor
+          
+          def self.element_name; 'SPHERICAL' end
+          
+          def to_xml
+            super('SPHERICAL')
+          end
+        end
+        
+        # Cartesian 1-, 2-, or 3-D coordinates
+        class Cartesian < CoordFlavorType
+          include CoordFlavor
+          
+          def self.element_name; 'CARTESIAN' end
+          
+          def to_xml
+            super('CARTESIAN')
+          end
+        end
+        
+        # 3-D Unit sphere coordinates (direction cosines)
+        class UnitSphere < CoordFlavorType
+          include CoordFlavor
+          
+          def self.element_name; 'UNITSPHERE' end
+          
+          def to_xml
+            super('UNITSPHERE')
+          end
+        end
+        
+        # 3-D geographic-like spherical coordinates (longitude, latitude, altitude)
+        class Geographic < CoordFlavorType
+          include CoordFlavor
+          
+          def self.element_name; 'GEOGRAPHIC' end
+          
+          def to_xml
+            super('GEOGRAPHIC')
+          end
+        end
+        
+        # A spatial coordinate frame consists of a coordinate frame and a reference position
+        class SpaceFrameType < CoordFrameType
+          attr_reader :space_ref_frame, :reference_position, :offset_center, :coord_flavor
+          
+          def initialize(options={})
+            raise_argument_required_error('space reference frame') if !options.has_key?(:space_ref_frame)
+            raise_argument_required_error('reference position') if !options.has_key?(:reference_position)
+            raise_argument_required_error('coordinate flavor') if !options.has_key?(:coord_flavor)
+            super(options)
+          end
+          
+          # Coordinate reference frame: optional equinox with either a standard reference system
+          # (ICRS, FK5, FK4) and optional standard pole (equatorial, ecliptic, galactic, etc.),
+          # or pole (positive Z-axis) and positive X-axis direction
+          def space_ref_frame=(f)
+            raise_argument_required_error('space reference frame') if !f
+            raise_type_mismatch_error(f, SpaceRefFrame)
+            @space_ref_frame = f
+          end
+          
+          # Origin of the coordinate reference frame: either a "known place" such as geocenter or barycenter,
+          # or a position defined in a known coordinate system
+          def reference_position=(p)
+            raise_argument_required_error('reference position') if !p
+            raise_type_mismatch_error(p, ReferencePosition)
+            @reference_position = p
+          end
+          
+          def offset_center=(o)
+            raise_type_mismatch_error(o, CoordValue)
+            @offset_center = o
+          end
+          
+          # Provides the coordinate definitions: number of axes, SPHERICAL or CARTESIAN, presence of velocities,
+          # and the Doppler definitions (if needed)
+          def coord_flavor=(f)
+            raise_argument_required_error('coordinate flavor') if !f
+            raise_type_mismatch_error(f, CoordFlavor)
+            @coord_flavor = f
+          end
+          
+          def ==(f)
+            super(f) and
+            self.space_ref_frame == f.space_ref_frame and
+            self.reference_position == f.reference_position and
+            self.offset_center == f.offset_center and
+            self.coord_flavor == f.coord_flavor
+          end
+          
+          def to_xml(name=nil)
+            el = super(name)
+            
+            if self.offset_center
+              coords_ns = NAMESPACES['VORuby::STC::V1_10::Coords']
+              el.add_namespace(coords_ns.prefix, coords_ns.uri)
+            end
+            
+            el.add_element(self.space_ref_frame.to_xml)
+            el.add_element(self.reference_position.to_xml)
+            
+            if self.offset_center
+              offset_center = REXML::Element.new("#{obj_ns.prefix}:OffsetCenter")
+              offset_center.add_element(self.offset_center.to_xml)
+              el.add_element(offset_center)
+            end
+            
+            el.add_element(self.coord_flavor.to_xml)
+            
+            collapse_namespaces(el)
+            el
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {
+              :space_ref_frame => xml_to_obj(root, SpaceRefFrame, true),
+              :reference_position => xml_to_obj(root, ReferencePosition, true),
+              :coord_flavor => xml_to_obj(root, CoordFlavor, true)
+            }
+            
+            name = REXML::XPath.first(root, 'x:Name', {'x' => obj_ns.uri})
+            options[:name] = name.text if name
+            
+            offset_center = REXML::XPath.first(root, 'x:OffsetCenter', {'x' => obj_ns.uri})
+            options[:offset_center] = xml_to_obj(offset_center, CoordValue, true, Coords) if offset_center
+            
+            self.new(options)
+          end
+        end
+        
+        # The spatial coordinate reference frame
+        class SpaceFrame < SpaceFrameType
+           include CoordFrame
+         end
+        
+        # The time reference frame consists of a timescale, a reference position, and optionally a reference
+        # direction (needed when transformations have been applied)
+        class TimeFrameType < CoordFrameType
+          attr_reader :reference_position, :time_ref_direction
+          
+          def initialize(options={})
+            raise_argument_error('reference position') if !options.has_key?(:reference_position)
+            super(options)
+          end
+          
+          # The time reference frame consists of a time scale, a time format, and a reference time, if needed
+          def time_scale=(s)
+            if s
+              s = TimeScale.new(s) if s.is_a?(String)
+              raise_type_mismatch_error(s, TimeScale)
+            end
+            @time_scale = s
+          end
+          
+          def time_scale
+            @time_scale || TimeScale.new('TT')
+          end
+          
+          # Origin of the coordinate reference frame: either a "known place" such as geocenter or barycenter,
+          # or a position defined in a known coordinate system
+          def reference_position=(p)
+            raise_argument_error('reference position') if !p
+            raise_type_mismatch_error(p, ReferencePosition)
+            @reference_position = p
+          end
+          
+          # Some time transformations (e.g., change of RefPos) depend on an assumed directonal position of the source
+          def time_ref_direction=(d)
+            raise_type_mismatch_error(d, AstroCoords) if d
+            @time_ref_direction = d
+          end
+          
+          def ==(f)
+            super(f) and
+            self.time_scale == f.time_scale and
+            self.reference_position == f.reference_position and
+            self.time_ref_direction == f.time_ref_direction
+          end
+          
+          def to_xml(name=nil)
+            el = super(name)
+            
+            coords_ns = NAMESPACES['VORuby::STC::V1_10::Coords']
+            el.add_namespace(coords_ns.prefix, coords_ns.uri)
+            
+            time_scale = REXML::Element.new("#{obj_ns.prefix}:TimeScale")
+            time_scale.text = self.time_scale.to_s
+            el.add_element(time_scale)
+            
+            el.add_element(self.reference_position.to_xml)
+            el.add_element(self.time_ref_direction.to_xml('TimeRefDirection', obj_ns)) if self.time_ref_direction
+            
+            collapse_namespaces(el)
+            el
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {
+              :reference_position => xml_to_obj(root, ReferencePosition, true),
+              :time_scale => TimeScale.new(REXML::XPath.first(root, 'x:TimeScale', {'x' => obj_ns.uri}).text)
+            }
+            
+            name = REXML::XPath.first(root, 'x:Name', {'x' => obj_ns.uri})
+            options[:name] = name.text if name
+            
+            time_ref_dir = REXML::XPath.first(root, 'x:TimeRefDirection', {'x' => obj_ns.uri})
+            options[:time_ref_direction] = AstroCoords.from_xml(time_ref_dir) if time_ref_dir
+            
+            self.new(options)
+          end
+        end
+        
+        # The time coordinate reference frame
+        class TimeFrame < TimeFrameType
+          include CoordFrame
+        end
+        
+        # ontains the spectral frame reference position
+        class SpectralFrameType < CoordFrameType
+          attr_reader :reference_position
+          
+          def initialize(options={})
+            raise_argument_required_error('reference position') if !options.has_key?(:reference_position)
+            super(options)
+          end
+          
+          # The reference frame for the Doppler velocities; note presence of LSR
+          def reference_position=(p)
+            raise_argument_required_error('reference position') if !p
+            raise_type_mismatch_error(p, ReferencePosition)
+            @reference_position = p
+          end
+          
+          def ==(p)
+            super(p) and self.reference_position == p.reference_position
+          end
+          
+          def to_xml(name=nil)
+            el = super(name)
+            el.add_element(self.reference_position.to_xml)
+            collapse_namespaces(el)
+            el
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {
+              :reference_position => xml_to_obj(root, ReferencePosition, true)
+            }
+            
+            name = REXML::XPath.first(root, 'x:Name', {'x' => obj_ns.uri})
+            options[:name] = name.text if name
+            
+            self.new(options)
+          end
+        end
+        
+        # The reference frame for the spectral coordinate; note presence of LSR
+        class SpectralFrame < SpectralFrameType
+          include CoordFrame
+        end
+        
+        # The Doppler definition used: optical, radio, or pseudo-relativistic (i.e., how is a redshift
+        # converted to a velocity); the most common is optical, except when the reference is LSR (usually
+        # radio)
+        class DopplerDefinition < Enumeration
+          def self.choices; ['OPTICAL', 'RADIO', 'RELATIVISTIC'] end
+        end
+          
+        # Contains the Doppler definitions, including whether the values are velocity or redshift (value_type)
+        class RedshiftFrameType < CoordFrameType
+          attr_reader :doppler_definition, :reference_position
+          
+          def initialize(options={})
+            raise_argument_required_error('reference position') if !options.has_key?(:reference_position)
+            super(options)
+          end
+          
+          # The Doppler definition used: optical, radio, or pseudo-relativistic (i.e., how is a redshift
+          # converted to a velocity); the most common is optical, except when the reference is LSR (usually
+          # radio)
+          def doppler_definition=(d)
+            d = DopplerDefinition.new(d) if d and d.is_a?(String)
+            raise_type_mismatch_error(d, DopplerDefinition) if d
+            @doppler_definition = d
+          end
+          
+          # The reference frame for the Doppler velocities; note presence of LSR
+          def reference_position=(p)
+            raise_argument_required_error('reference position') if !p
+            raise_type_mismatch_error(p, ReferencePosition)
+            @reference_position = p
+          end
+          
+          def value_type=(v)
+            @value_type = v ? v.to_s : nil
+          end
+          
+          def value_type
+            @value_type || 'VELOCITY'
+          end
+          
+          def ==(f)
+            super(f) and
+            self.doppler_definition == f.doppler_definition and
+            self.reference_position == f.reference_position and
+            self.value_type == f.value_type
+          end
+          
+          def to_xml(name=nil)
+            el = super(name)
+            
+            el.attributes["#{obj_ns.prefix}:value_type"] = self.value_type
+            
+            if self.doppler_definition
+              doppler = REXML::Element.new("#{obj_ns.prefix}:DopplerDefinition")
+              doppler.text = doppler_definition.value
+              el.add_element(doppler)
+            end
+            
+            el.add_element(self.reference_position.to_xml)
+            
+            collapse_namespaces(el)
+            el
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {
+              :reference_position => xml_to_obj(root, ReferencePosition, true),
+            }
+            
+            name = REXML::XPath.first(root, 'x:Name', {'x' => obj_ns.uri})
+            options[:name] = name.text if name
+            
+            value_type = root.attributes.get_attribute_ns(obj_ns.uri, 'value_type')
+            options[:value_type] = value_type.value if value_type
+            
+            doppler_def = REXML::XPath.first(root, 'x:DopplerDefinition', {'x' => obj_ns.uri})
+            options[:doppler_definition] = DopplerDefinition.new(doppler_def.text) if doppler_def
+            
+            self.new(options)
+          end
+        end
+        
+        # Contains the Doppler definitions, including whether the values are velocity or redshift (value_type)
+        class RedshiftFrame < RedshiftFrameType
+          include CoordFrame
+        end
+        
+        # Element for pixel Coordinate Frames
+        class PixelCoordFrame < CoordFrameType
+          include CoordFrame
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {}
+            name = REXML::XPath.first(root, 'x:Name', {'x' => obj_ns.uri})
+            options[:name] = name.text if name
+            
+            PixelCoordFrame.new(options)
+          end
+        end
+        
+        # Element for generic Coordinate Frames
+        class GenericCoordFrame < CoordFrameType
+          include CoordFrame
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {}
+            
+            name = REXML::XPath.first(root, 'x:Name', {'x' => obj_ns.uri})
+            options[:name] = name.text if name
+            
+            GenericCoordFrame.new(options)
+          end
+        end
+        
+        # A CoordSys consists of at least one coordinate frame
+        class CoordSysType
+          include SerializableToXml
+          
+          attr_reader :coord_frames, :id
+          
+          def initialize(options={})
+            raise_argument_required_error('id') if !options.has_key?(:id)
+            raise_argument_required_error('coordinate frames') if !options.has_key?(:coord_frames)
+            options.each { |key, value| send("#{key}=", value) }
+          end
+          
+          def id=(i)
+            raise_argument_required_error('id') if !i
+            i = Id.new(i) if i.is_a?(String)
+            raise_type_mismatch_error(i, Id)
+            @id = i
+          end
+          
+          def coord_frames=(fs)
+            raise_argument_required_error('coordinate frames') if !fs
+            fs = CoordFrameList.new(fs) if fs.class == Array
+            raise_type_mismatch_error(fs, CoordFrameList)
+            @coord_frames = fs
+          end
+          
+          def ==(c)
+            self.id == c.id and
+            self.coord_frames == c.coord_frames
+          end
+          
+          def to_xml(name=nil)
+            el = element(name)
+            
+            el.attributes["#{obj_ns.prefix}:ID"] = self.id.to_s
+            self.coord_frames.each { |f| el.add_element(f.to_xml) }
+            
+            collapse_namespaces(el)
+            el
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {
+              :id => Id.new(root.attributes.get_attribute_ns(obj_ns.uri, 'ID').value),
+              :coord_frames => xml_to_obj(root, CoordFrame)
+            }
+            
+            self.new(options)
+          end
+        end
+        
+        class GenericCoordFrameList < TypedArray
+          def self.restricted_to; [GenericCoordFrame] end
+        end
+        
+        # The astronomical coordinate system definition: spatial coordinate frame and reference position;
+        # time frame and reference position; the coordinate flavor; spectral frame and (optionally) Doppler
+        # frame; and the planetary ephemeris; an ID is required, since this is how coordinate elements are
+        # associated with their coordinate systems
+        class AstroCoordSystemType < CoordSysType
+          attr_reader :time_frame, :space_frame, :spectral_frame, :redshift_frame, :generic_coord_frames
+          
+          def initialize(options={})
+            raise_argument_required_error('time frame') if !options.has_key?(:time_frame)
+            raise_argument_required_error('space frame') if !options.has_key?(:space_frame)
+            
+            frames = []
+            frames << options[:time_frame] << options[:space_frame]
+            frames << options[:spectral_frame] if options.has_key?(:spectral_frame)
+            frames << options[:redshift_frame] if options.has_key?(:redshift_frame)
+            options[:generic_coord_frames].each { |f| frames << f } if options.has_key?(:generic_coord_frames) and options[:generic_coord_frames]
+            options[:coord_frames] = frames
+            
+            super(options)
+          end
+          
+          def time_frame=(f)
+            raise_argument_required_error('time frame') if !f
+            raise_type_mismatch_error(f, TimeFrame)
+            @time_frame = f
+          end
+          
+          def space_frame=(f)
+            se_argument_required_error('space frame') if !f
+            raise_type_mismatch_error(f, SpaceFrame)
+            @space_frame = f
+          end
+          
+          def spectral_frame=(f)
+            raise_type_mismatch_error(f, SpectralFrame) if f
+            @spectral_frame = f
+          end
+          
+          def redshift_frame=(f)
+            raise_type_mismatch_error(f, RedshiftFrame) if f
+            @redshift_frame = f
+          end
+          
+          def generic_coord_frames=(fs)
+            if fs
+              fs = GenericCoordFrameList.new(fs) if fs.class == Array
+              raise_type_mismatch_error(fs, GenericCoordFrameList)
+            end
+            
+            @generic_coord_frames = fs
+          end
+          
+          def ==(s)
+            self.id == s.id and
+            self.time_frame == s.time_frame and
+            self.space_frame == s.space_frame and
+            self.spectral_frame == s.spectral_frame and
+            self.redshift_frame == s.redshift_frame and
+            self.generic_coord_frames == s.generic_coord_frames
+          end
+          
+          def coord_frames
+            frames = CoordFrameList.new([self.time_frame, self.space_frame])
+            
+            frames << self.spectral_frame if self.spectral_frame
+            frames << self.redshift_frame if self.redshift_frame
+            self.generic_coord_frames.each { |f| frames << f } if self.generic_coord_frames
+            
+            frames
+          end
+          
+          def coord_frames=(fs)
+            raise_argument_required_error('at least TimeFrame and SpaceFrame') if fs.size < 2
+            self.spectral_frame = self.redshift_frame = self.generic_coord_frames = nil
+            
+            raise_type_mismatch_error(fs[0], TimeFrame)
+            self.time_frame = fs[0]
+          
+            raise_type_mismatch_error(fs[1], SpaceFrame)
+            self.space_frame = fs[1]
+            
+            if fs.size >= 3 
+              raise_type_mismatch_error(fs[2], SpectralFrame)
+              self.spectral_frame = fs[2]
+            end
+            
+            if fs.size >= 4
+              raise_type_mismatch_error(fs[3], RedshiftFrame)
+              self.redshift_frame = fs[3]
+            end
+              
+            if fs.size >= 5
+              fs[4..-1].each do |f|
+                raise_type_mismatch_error(f, GenericCoordFrame)
+              end
+              self.generic_coord_frames = GenericCoordFrameList.new(fs[4..-1])
+            end
+            
+            super(fs)
+          end
+          
+          def to_xml(name=nil)
+            el = element(name)
+            el.attributes["#{obj_ns.prefix}:ID"] = self.id.to_s
+            
+            el.add_element(self.time_frame.to_xml)
+            el.add_element(self.space_frame.to_xml)
+            el.add_element(self.spectral_frame.to_xml) if self.spectral_frame
+            el.add_element(self.redshift_frame.to_xml) if self.redshift_frame
+            self.generic_coord_frames.each{ |f| el.add_element(f.to_xml) } if self.generic_coord_frames
+            
+            collapse_namespaces(el)
+            el
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {
+              :id => Id.new(root.attributes.get_attribute_ns(obj_ns.uri, 'ID').value),
+              :time_frame => TimeFrame.from_xml(REXML::XPath.first(root, 'x:TimeFrame', {'x' => obj_ns.uri})),
+              :space_frame => SpaceFrame.from_xml(REXML::XPath.first(root, 'x:SpaceFrame', {'x' => obj_ns.uri}))
+            }
+            
+            spectral_frame = REXML::XPath.first(root, 'x:SpectralFrame', {'x' => obj_ns.uri})
+            options[:spectral_frame] = SpectralFrame.from_xml(spectral_frame) if spectral_frame
+            
+            redshift_frame = REXML::XPath.first(root, 'x:RedshiftFrame', {'x' => obj_ns.uri})
+            options[:redshift_frame] = RedshiftFrame.from_xml(redshift_frame) if redshift_frame
+            
+            generic_coord_frames = REXML::XPath.match(root, 'x:GenericCoordFrame', {'x' => obj_ns.uri})
+            if generic_coord_frames
+              options[:generic_coord_frames] = GenericCoordFrameList.new(
+                generic_coord_frames.collect{ |f| GenericCoordFrame.from_xml(f) }
+              )
+              options[:generic_coord_frames] = nil if options[:generic_coord_frames].size == 0
+            end
+            
+            self.new(options)
+          end
+        end
+        
+        # The coordinate system definition: spatial coordinate frame and reference position; time frame and reference
+        # position; the coordinate flavor; and the planetary ephemeris; an ID is required, since this is how coordinate
+        # elements are associated with their coordinate systems
+        class AstroCoordSystem < AstroCoordSystemType
+          include CoordSys
+        end
+        
+        class PixelCoordFrameList < TypedArray
+          def self.restricted_to; [PixelCoordFrame] end
+        end
+        
+        # The pixel coordinate system definition
+        class PixelCoordSystemType < CoordSysType
+          attr_reader :pixel_coord_frames
+          
+          def initialize(options={})
+            raise_argument_required_error('list of pixel coordinate systems') if !options.has_key?(:pixel_coord_frames)
+            options[:coord_frames] = options[:pixel_coord_frames]
+            super(options)
+          end
+          
+          def pixel_coord_frames=(fs)
+            raise_argument_required_error('list of pixel coordinate systems') if !fs
+            
+            fs = PixelCoordFrameList.new(fs) if fs.class == Array
+            raise_type_mismatch_error(fs, PixelCoordFrameList)
+            
+            @pixel_coord_frames = fs
+          end
+          
+          def coord_frames
+            self.pixel_coord_frames
+          end
+          
+          def coord_frames=(cs)
+            self.pixel_coord_frames = cs
+          end
+          
+          def ==(f)
+            self.id == f.id and
+            self.pixel_coord_frames == f.pixel_coord_frames
+          end
+          
+          def to_xml(name=nil)
+            el = element(name)
+            el.attributes["#{obj_ns.prefix}:ID"] = self.id.to_s
+            
+            self.pixel_coord_frames.each { |f| el.add_element(f.to_xml) }
+            
+            collapse_namespaces(el)
+            el
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {
+              :id => Id.new(root.attributes.get_attribute_ns(obj_ns.uri, 'ID').value),
+              :pixel_coord_frames => PixelCoordFrameList.new(
+                REXML::XPath.match(root, 'x:PixelCoordFrame', {'x' => obj_ns.uri}).collect { |p| PixelCoordFrame.from_xml(p) }
+              )
+            }
+
+            self.new(options)
+          end
+        end
+        
+        # Pixel form of CoordSys
+        class PixelCoordSystem < PixelCoordSystemType
+          include CoordSys
+        end
+        
+        # Abstact coordinate interval type
+        class CoordIntervalType
+          include SerializableToXml
+          
+          attr_writer :lo_include, :hi_include
+          
+          def initialize(options={})
+            options.each { |key, value| send("#{key}=", value) }
+          end
+          
+          def lo_include
+            @lo_include == nil ? true : @lo_include
+          end
+          
+          def hi_include
+            @hi_include == nil ? true : @hi_include
+          end
+          
+          def fill_factor=(f)
+            f = Float(f) if f and !f.is_a?(Float)
+            @fill_factor = f
+          end
+          
+          def fill_factor
+            @fill_factor || 1.0
+          end
+          
+          def ==(i)
+            self.lo_include == i.lo_include and
+            self.hi_include == i.hi_include and
+            self.fill_factor == i.fill_factor
+          end
+          
+          def to_xml(name=nil)
+            el = element(name)
+            
+            el.attributes["#{obj_ns.prefix}:lo_include"] = self.lo_include.to_s
+            el.attributes["#{obj_ns.prefix}:hi_include"] = self.hi_include.to_s
+            el.attributes["#{obj_ns.prefix}:fill_factor"] = self.fill_factor.to_s
+            
+            el
+          end
+        end
+        
+        # The time interval needs to contain a start time or a stop time or both;
+        # it needs to refer to a coordinate system; boundaries may or may not be
+        # inclusive
+        class TimeIntervalType < CoordIntervalType
+          attr_reader :start_time, :stop_time
+          
+          # AstronTime may be expressed in ISO8601 or as a double relative to a reference time
+          def start_time=(t)
+            raise_type_mismatch_error(t, AstronTime) if t
+            @start_time = t
+          end
+          
+          # AstronTime may be expressed in ISO8601 or as a double relative to a reference time
+          def stop_time=(t)
+            raise_type_mismatch_error(t, AstronTime) if t
+            @stop_time = t
+          end
+          
+          def to_xml(name=nil)
+            el = super(name)
+            
+            coords_ns = NAMESPACES['VORuby::STC::V1_10::Coords']
+            el.add_namespace(coords_ns.prefix, coords_ns.uri)
+            
+            el.add_element(self.start_time.to_xml('StartTime', obj_ns('VORuby::STC::V1_10::STC'))) if self.start_time
+            el.add_element(self.stop_time.to_xml('StopTime', obj_ns('VORuby::STC::V1_10::STC'))) if self.stop_time
+            
+            collapse_namespaces(el)
+            el
+          end
+          
+          def ==(i)
+            super(i) and
+            self.start_time == i.start_time and
+            self.stop_time == i.stop_time
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {}
+            
+            lo_include = root.attributes.get_attribute_ns(obj_ns.uri, 'lo_include')
+            options[:lo_include] = (lo_include.value == 'true' ? true : false) if lo_include
+            
+            hi_include = root.attributes.get_attribute_ns(obj_ns.uri, 'hi_include')
+            options[:hi_include] = (hi_include.value == 'true' ? true : false) if hi_include
+            
+            fill_factor = root.attributes.get_attribute_ns(obj_ns.uri, 'fill_factor')
+            options[:fill_factor] = Float(fill_factor.value) if fill_factor
+            
+            start_time = REXML::XPath.first(root, 'x:StartTime', {'x' => obj_ns.uri})
+            options[:start_time] = AstronTime.from_xml(start_time) if start_time
+            
+            stop_time = REXML::XPath.first(root, 'x:StopTime', {'x' => obj_ns.uri})
+            options[:stop_time] = AstronTime.from_xml(stop_time) if stop_time
+            
+            self.new(options)
+          end
+        end
+        
+        # Scalar coordinate interval type
+        class CoordScalarIntervalType < CoordIntervalType
+          attr_reader :lo_limit, :hi_limit
+          
+          # Lower bound of interval
+          def lo_limit=(l)
+            l = Float(l) if l and !l.is_a?(Float)
+            @lo_limit = l
+          end
+          
+          # Upper bound of interval
+          def hi_limit=(l)
+            l = Float(l) if l and !l.is_a?(Float)
+            @hi_limit = l
+          end
+          
+          def ==(i)
+            super(i) and
+            self.lo_limit == i.lo_limit and
+            self.hi_limit == i.hi_limit
+          end
+          
+          def to_xml(name=nil)
+            el = super(name)
+            
+            if self.lo_limit
+              lo_limit = REXML::Element.new("#{obj_ns.prefix}:LoLimit")
+              lo_limit.text = self.lo_limit.to_s
+              el.add_element(lo_limit)
+            end
+            
+            if self.hi_limit
+              hi_limit = REXML::Element.new("#{obj_ns.prefix}:HiLimit")
+              hi_limit.text = self.hi_limit.to_s
+              el.add_element(hi_limit)
+            end
+            
+            collapse_namespaces(el)
+            el
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {}
+            
+            lo_include = root.attributes.get_attribute_ns(obj_ns.uri, 'lo_include')
+            options[:lo_include] = (lo_include.value == 'true' ? true : false) if lo_include
+            
+            hi_include = root.attributes.get_attribute_ns(obj_ns.uri, 'hi_include')
+            options[:hi_include] = (hi_include.value == 'true' ? true : false) if hi_include
+            
+            fill_factor = root.attributes.get_attribute_ns(obj_ns.uri, 'fill_factor')
+            options[:fill_factor] = Float(fill_factor.value) if fill_factor
+            
+            lo_limit = REXML::XPath.first(root, 'x:LoLimit', {'x' => obj_ns.uri})
+            options[:lo_limit] = Float(lo_limit.text) if lo_limit
+            
+            hi_limit = REXML::XPath.first(root, 'x:HiLimit', {'x' => obj_ns.uri})
+            options[:hi_limit] = Float(hi_limit.text) if hi_limit
+            
+            self.new(options)
+          end
+        end
+        
+        # 2-D coordinate interval type
+        class Coord2VecIntervalType < CoordIntervalType
+          attr_reader :lo_limit, :hi_limit
+          
+          def lo_limit=(l)
+            l = Double2.new(l) if l and l.class == Array
+            raise_type_mismatch_error(l, Double2) if l
+            
+            @lo_limit = l
+          end
+          
+          def hi_limit=(l)
+            l = Double2.new(l) if l and l.class == Array
+            raise_type_mismatch_error(l, Double2) if l
+            
+            @hi_limit = l
+          end
+          
+          def ==(i)
+            super(i) and
+            self.lo_limit == i.lo_limit and
+            self.hi_limit == i.hi_limit
+          end
+          
+          def to_xml(name=nil)
+            el = super(name)
+            
+            if self.lo_limit
+              lo_limit = REXML::Element.new("#{obj_ns.prefix}:LoLimit2Vec")
+              lo_limit.text = self.lo_limit.to_s
+              el.add_element(lo_limit)
+            end
+            
+            if self.hi_limit
+              hi_limit = REXML::Element.new("#{obj_ns.prefix}:HiLimit2Vec")
+              hi_limit.text = self.hi_limit.to_s
+              el.add_element(hi_limit)
+            end
+            
+            collapse_namespaces(el)
+            el
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {}
+            
+            lo_include = root.attributes.get_attribute_ns(obj_ns.uri, 'lo_include')
+            options[:lo_include] = (lo_include.value == 'true' ? true : false) if lo_include
+            
+            hi_include = root.attributes.get_attribute_ns(obj_ns.uri, 'hi_include')
+            options[:hi_include] = (hi_include.value == 'true' ? true : false) if hi_include
+            
+            fill_factor = root.attributes.get_attribute_ns(obj_ns.uri, 'fill_factor')
+            options[:fill_factor] = Float(fill_factor.value) if fill_factor
+            
+            lo_limit = REXML::XPath.first(root, 'x:LoLimit2Vec', {'x' => obj_ns.uri})
+            options[:lo_limit] = Double2.from_xml(lo_limit) if lo_limit
+            
+            hi_limit = REXML::XPath.first(root, 'x:HiLimit2Vec', {'x' => obj_ns.uri})
+            options[:hi_limit] = Double2.from_xml(hi_limit) if hi_limit
+            
+            self.new(options)
+          end
+        end
+        
+        # 2-D coordinate interval type
+        class Coord3VecIntervalType < CoordIntervalType
+          attr_reader :lo_limit, :hi_limit
+          
+          def lo_limit=(l)
+            l = Double3.new(l) if l and l.class == Array
+            raise_type_mismatch_error(l, Double3) if l
+            
+            @lo_limit = l
+          end
+          
+          def hi_limit=(l)
+            l = Double3.new(l) if l and l.class == Array
+            raise_type_mismatch_error(l, Double3) if l
+            
+            @hi_limit = l
+          end
+          
+          def ==(i)
+            super(i) and
+            self.lo_limit == i.lo_limit and
+            self.hi_limit == i.hi_limit
+          end
+          
+          def to_xml(name=nil)
+            el = super(name)
+            
+            if self.lo_limit
+              lo_limit = REXML::Element.new("#{obj_ns.prefix}:LoLimit3Vec")
+              lo_limit.text = self.lo_limit.to_s
+              el.add_element(lo_limit)
+            end
+            
+            if self.hi_limit
+              hi_limit = REXML::Element.new("#{obj_ns.prefix}:HiLimit3Vec")
+              hi_limit.text = self.hi_limit.to_s
+              el.add_element(hi_limit)
+            end
+            
+            collapse_namespaces(el)
+            el
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {}
+            
+            lo_include = root.attributes.get_attribute_ns(obj_ns.uri, 'lo_include')
+            options[:lo_include] = (lo_include.value == 'true' ? true : false) if lo_include
+            
+            hi_include = root.attributes.get_attribute_ns(obj_ns.uri, 'hi_include')
+            options[:hi_include] = (hi_include.value == 'true' ? true : false) if hi_include
+            
+            fill_factor = root.attributes.get_attribute_ns(obj_ns.uri, 'fill_factor')
+            options[:fill_factor] = Float(fill_factor.value) if fill_factor
+            
+            lo_limit = REXML::XPath.first(root, 'x:LoLimit3Vec', {'x' => obj_ns.uri})
+            options[:lo_limit] = Double3.from_xml(lo_limit) if lo_limit
+            
+            hi_limit = REXML::XPath.first(root, 'x:HiLimit3Vec', {'x' => obj_ns.uri})
+            options[:hi_limit] = Double3.from_xml(hi_limit) if hi_limit
+            
+            self.new(options)
+          end
+        end
+        
+        # The spatial coordinate interval substitution group head element; such an
+        # element needs to contain a minimum or maximum scalar or vector value, or
+        # both; it needs to refer to a coordinate system; boundaries may or may not
+        # be inclusive; and it can have a fill factor
+        module CoordInterval; end
+        
+        # An interval in a scalar coordinate
+        class CoordScalarInterval < CoordScalarIntervalType
+          include CoordInterval
+        end
+        
+        # An interval ("box") in a 2-D coordinate pair
+        class Coord2VecInterval < Coord2VecIntervalType
+          include CoordInterval
+        end
+        
+        # An interval ("cube") in a 3-D coordinate triplet
+        class Coord3VecInterval < Coord3VecIntervalType
+          include CoordInterval
+        end
+        
+        # Parent type for spatial intervals
+        class SpatialIntervalType
+          include SerializableToXml
+          
+          def initialize(options={})
+            options.each { |key, value| send("#{key}=", value) }
+          end
+        end
+        
+        # Defines a sphere
+        class SphereType < SpatialIntervalType
+          attr_reader :radius, :center, :unit
+          
+          def initialize(options={})
+            raise_argument_required_error('radius') if !options.has_key?(:radius)
+            raise_argument_required_error('center') if !options.has_key?(:center)
+            raise_argument_required_error('unit') if !options.has_key?(:unit)
+            super(options)
+          end
+          
+          def radius=(r)
+            raise_argument_required_error('radius') if !r
+            r = Float(r) if !r.is_a?(Float)
+            @radius = r
+          end
+          
+          def center=(c)
+            raise_argument_required_error('center') if !c
+            c = Double3.new(c) if c.class == Array
+            raise_type_mismatch_error(c, Double3)
+            @center = c
+          end
+          
+          def unit=(u)
+            raise_argument_required_error('unit') if !u
+            u = PosUnit.new(u.to_s) if !u.is_a?(PosUnit)
+            raise_type_mismatch_error(u, PosUnit)
+            @unit = u
+          end
+          
+          def radius_unit=(u)
+            u = PosUnit.new(u.to_s) if u and !u.is_a?(PosUnit)
+            raise_type_mismatch_error(u, PosUnit) if u
+            @radius_unit = u
+          end
+          
+          def radius_unit
+            @radius_unit || PosUnit.new('deg')
+          end
+          
+          def fill_factor=(f)
+            f = Float(f) if !f.is_a?(Float)
+            @fill_factor = f
+          end
+          
+          def fill_factor
+            @fill_factor || 1.0
+          end
+          
+          def ==(s)
+            self.radius == s.radius and
+            self.center == s.center and
+            self.unit == s.unit and
+            self.radius_unit == s.radius_unit and
+            self.fill_factor == s.fill_factor
+          end
+          
+          def to_xml(name=nil)
+            el = element(name)
+            
+            el.attributes["#{obj_ns.prefix}:unit"] = self.unit.to_s
+            el.attributes["#{obj_ns.prefix}:radius_unit"] = self.radius_unit.to_s if self.radius_unit
+            el.attributes["#{obj_ns.prefix}:fill_factor"] = self.fill_factor.to_s if self.fill_factor
+            
+            radius = REXML::Element.new("#{obj_ns.prefix}:Radius")
+            radius.text = self.radius.to_s
+            el.add_element(radius)
+            
+            center = REXML::Element.new("#{obj_ns.prefix}:Center")
+            center.text = self.center.to_s
+            el.add_element(center)
+            
+            collapse_namespaces(el)
+            el
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {
+              :radius => Float(REXML::XPath.first(root, 'x:Radius', {'x' => obj_ns.uri}).text),
+              :center => Double3.from_xml(REXML::XPath.first(root, 'x:Center', {'x' => obj_ns.uri})),
+              :unit => PosUnit.new(root.attributes.get_attribute_ns(obj_ns.uri, 'unit').value)
+            }
+            
+            radius_unit = root.attributes.get_attribute_ns(obj_ns.uri, 'radius_unit')
+            options[:radius_unit] = PosUnit.new(radius_unit.value) if radius_unit
+            
+            fill_factor = root.attributes.get_attribute_ns(obj_ns.uri, 'fill_factor')
+            options[:fill_factor] = Float(fill_factor.value) if fill_factor
+            
+            self.new(options)
+          end
+        end
+        
+        # Defines a velocity sphere.
+        # A special kind of area is a circle or sphere (in two or three dimensions),
+        # defined by a center position and a radius; the radius requires a unit
+        class VelocitySphereType < SphereType
+          attr_reader :vel_time_unit
+          
+          def initialize(options={})
+            raise_argument_required_error('velocity time unit') if !options.has_key?(:vel_time_unit)
+            super(options)
+          end
+          
+          def vel_time_unit=(u)
+            raise_argument_required_error('velocity time unit') if !u
+            
+            u = VelTimeUnit.new(u) if u.is_a?(String)
+            raise_type_mismatch_error(u, VelTimeUnit)
+            
+            @vel_time_unit = u
+          end
+          
+          def ==(s)
+            super(s) and self.vel_time_unit == s.vel_time_unit
+          end
+          
+          def to_xml(name=nil)
+            el = super(name)
+            el.attributes["#{obj_ns.prefix}:vel_time_unit"] = self.vel_time_unit.to_s
+            el
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {
+              :radius => Float(REXML::XPath.first(root, 'x:Radius', {'x' => obj_ns.uri}).text),
+              :center => Double3.from_xml(REXML::XPath.first(root, 'x:Center', {'x' => obj_ns.uri})),
+              :unit => PosUnit.new(root.attributes.get_attribute_ns(obj_ns.uri, 'unit').value),
+              :vel_time_unit => VelTimeUnit.new(root.attributes.get_attribute_ns(obj_ns.uri, 'vel_time_unit').value)
+            }
+            
+            radius_unit = root.attributes.get_attribute_ns(obj_ns.uri, 'radius_unit')
+            options[:radius_unit] = PosUnit.new(radius_unit.value) if radius_unit
+            
+            fill_factor = root.attributes.get_attribute_ns(obj_ns.uri, 'fill_factor')
+            options[:fill_factor] = Float(fill_factor.value) if fill_factor
+            
+            self.new(options)
+          end
+        end
+        
+        # Contains a spatial position CoordInterval
+        class PositionIntervalType < SpatialIntervalType
+          attr_reader :coord_interval, :unit
+          
+          def initialize(options={})
+            raise_argument_required_error('coordinate interval') if !options.has_key?(:coord_interval)
+            raise_argument_required_error('unit') if !options.has_key?(:unit)
+            super(options)
+          end
+          
+          def coord_interval=(i)
+            raise_argument_required_error('coordinate interval') if !i
+            raise_type_mismatch_error(i, CoordInterval)
+            @coord_interval = i
+          end
+          
+          def unit=(u)
+            raise_argument_required_error('unit') if !u
+            raise_type_mismatch_error(u, PosUnit)
+            @unit =  u
+          end
+          
+          def ==(i)
+            self.coord_interval == i.coord_interval and
+            self.unit == i.unit
+          end
+          
+          def to_xml(name=nil)
+            el = element(name)
+            el.attributes["#{obj_ns.prefix}:unit"] = self.unit.to_s
+            el.add_element(self.coord_interval.to_xml)
+            el
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {
+              :unit => PosUnit.new(root.attributes.get_attribute_ns(obj_ns.uri, 'unit').value),
+              :coord_interval => xml_to_obj(root, CoordInterval, true)
+            }
+            
+            self.new(options)
+          end
+        end
+        
+        # Contains a spatial velocity CoordInterval.
+        # A special kind of area is a circle or sphere (in two or three dimensions),
+        # defined by a center position and a radius; the radius requires a unit
+        class VelocityIntervalType < PositionIntervalType
+          attr_reader :vel_time_unit
+          
+          def initialize(options={})
+            raise_argument_required_error('velocity time unit') if !options.has_key?(:vel_time_unit)
+            super(options)
+          end
+          
+          def vel_time_unit=(u)
+            raise_argument_required_error('velocity time unit') if !u
+            
+            u = VelTimeUnit.new(u) if u.is_a?(String)
+            raise_type_mismatch_error(u, VelTimeUnit)
+            
+            @vel_time_unit = u
+          end
+          
+          def ==(s)
+            super(s) and self.vel_time_unit == s.vel_time_unit
+          end
+          
+          def to_xml(name=nil)
+            el = super(name)
+            el.attributes["#{obj_ns.prefix}:vel_time_unit"] = self.vel_time_unit.to_s
+            el
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {
+              :unit => PosUnit.new(root.attributes.get_attribute_ns(obj_ns.uri, 'unit').value),
+              :vel_time_unit => VelTimeUnit.new(root.attributes.get_attribute_ns(obj_ns.uri, 'vel_time_unit').value),
+              :coord_interval => xml_to_obj(root, CoordInterval, true)
+            }
+            
+            self.new(options)
+          end
+        end
+        
+        # Points to a Region file
+        class RegionFileType < SpatialIntervalType
+          attr_reader :file
+          
+          def initialize(options={})
+            raise_argument_required_error('file') if !options.has_key?(:file)
+            super(options)
+          end
+          
+          def file=(f)
+            raise_argument_required_error('file') if !f
+            @file = URI.parse(f.to_s)
+          end
+          
+          def ==(f)
+            self.file == f.file
+          end
+          
+          def to_xml(name=nil)
+            el = element(name)
+            
+            file = REXML::Element.new("#{obj_ns.prefix}:File")
+            file.text = self.file.to_s
+            el.add_element(file)
+            
+            el
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {
+              :file => URI.parse(REXML::XPath.first(root, 'x:File', {'x' => obj_ns.uri}).text)
+            }
+            
+            self.new(options)
+          end
+        end
+        
+        # Contains an abstract Region
+        class RegionType < SpatialIntervalType
+          attr_reader :region
+          
+          def initialize(options={})
+            raise_argument_required_error('region') if !options.has_key?(:region)
+            super(options)
+          end
+          
+          def region=(r)
+            raise_argument_required_error('region') if !r
+            raise_type_mismatch_error(r, V1_10::Region::Region)
+            @region = r
+          end
+          
+          def ==(r)
+            self.region == r.region
+          end
+          
+          def to_xml(name=nil)
+            el = element(name)
+            
+            coords_ns = NAMESPACES['VORuby::STC::V1_10::Coords']
+            el.add_namespace(coords_ns.prefix, coords_ns.uri)
+            
+            region_ns = NAMESPACES['VORuby::STC::V1_10::Region']
+            el.add_namespace(region_ns.prefix, region_ns.uri)
+            
+            el.add_element(self.region.to_xml)
+            
+            collapse_namespaces(el)
+            el
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {
+              :region => xml_to_obj(root, V1_10::Region::Region, true, V1_10::Region)
+            }
+            
+            self.new(options)
+          end
+        end
+        
+        # The spatial interval substitution group head element;
+        # a spatial coordinate interval (volume) is specified as
+        # a circle (cone) or sphere; a 1-D, 2-D, or 3-D interval;
+        # a Region; or a RegionFile
+        module SpatialInterval; end
+        
+        # Defines a sphere (3-D) region for spatial coordinates;
+        # contains a center position and a radius
+        class Sphere < SphereType
+          include SpatialInterval
+        end
+        
+        # Contains a CoordInterval element: a 1-D range, 2-D box, or 3-D cube
+        class PositionInterval < PositionIntervalType
+          include SpatialInterval
+        end
+        
+        # A region as defined in a FITS region file
+        class RegionFile < RegionFileType
+          include SpatialInterval
+        end
+        
+        # Contains a region as defined in the Region schema
+        class Region < RegionType
+          include SpatialInterval
+        end
+        
+        # Contains a Velocity CoordInterval element: a 1-D range, 2-D box, or 3-D cube;
+        # plus a time unit for velocity values
+        module VelInterval; end
+        
+        # Defines a sphere (3-D) region for velocity coordinates; contains a center position and a radius
+        class VelocitySphere < VelocitySphereType
+          include VelInterval
+        end
+        
+        # Contains a CoordInterval element: a 1-D range, 2-D box, or 3-D cube
+        class VelocityInterval < VelocityIntervalType
+          include VelInterval
+        end
+        
+        # Contains a 1-D spectral interval
+        class SpectralInterval < CoordScalarIntervalType
+          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
+            
+            u = SpectralUnit.new(u) if u.is_a?(String)
+            raise_type_mismatch_error(u, SpectralUnit)
+            
+            @unit = u
+          end
+          
+          def ==(i)
+            super(i) and self.unit = i.unit
+          end
+          
+          def to_xml(name=nil)
+            el = super(name)
+            el.attributes["#{obj_ns.prefix}:unit"] = self.unit.to_s
+            el
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {}
+            
+            lo_include = root.attributes.get_attribute_ns(obj_ns.uri, 'lo_include')
+            options[:lo_include] = (lo_include.value == 'true' ? true : false) if lo_include
+            
+            hi_include = root.attributes.get_attribute_ns(obj_ns.uri, 'hi_include')
+            options[:hi_include] = (hi_include.value == 'true' ? true : false) if hi_include
+            
+            fill_factor = root.attributes.get_attribute_ns(obj_ns.uri, 'fill_factor')
+            options[:fill_factor] = Float(fill_factor.value) if fill_factor
+            
+            lo_limit = REXML::XPath.first(root, 'x:LoLimit', {'x' => obj_ns.uri})
+            options[:lo_limit] = Float(lo_limit.text) if lo_limit
+            
+            hi_limit = REXML::XPath.first(root, 'x:HiLimit', {'x' => obj_ns.uri})
+            options[:hi_limit] = Float(hi_limit.text) if hi_limit
+            
+            options[:unit] = SpectralUnit.new(root.attributes.get_attribute_ns(obj_ns.uri, 'unit').value)
+            
+            self.new(options)
+          end
+        end
+        
+        # Contains a 1-D redshift interval; position and time units are required if redshifts
+        # are expressed as Doppler velocities
+        class RedshiftInterval < CoordScalarIntervalType
+          attr_reader :unit, :vel_time_unit
+          
+          def unit=(u)
+            u = PosUnit.new(u) if u.is_a?(String)
+            raise_type_mismatch_error(u, PosUnit) if u
+            @unit = u
+          end
+          
+          def vel_time_unit=(u)
+            u = VelTimeUnit.new(u) if u.is_a?(String)
+            raise_type_mismatch_error(u, VelTimeUnit) if u
+            @vel_time_unit = u
+          end
+          
+          def ==(i)
+            super(i) and
+            self.unit == i.unit and
+            self.vel_time_unit == i.vel_time_unit
+          end
+          
+          def to_xml(name=nil)
+            el = super(name)
+            
+            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
+            
+            el
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {}
+            
+            lo_include = root.attributes.get_attribute_ns(obj_ns.uri, 'lo_include')
+            options[:lo_include] = (lo_include.value == 'true' ? true : false) if lo_include
+            
+            hi_include = root.attributes.get_attribute_ns(obj_ns.uri, 'hi_include')
+            options[:hi_include] = (hi_include.value == 'true' ? true : false) if hi_include
+            
+            fill_factor = root.attributes.get_attribute_ns(obj_ns.uri, 'fill_factor')
+            options[:fill_factor] = Float(fill_factor.value) if fill_factor
+            
+            lo_limit = REXML::XPath.first(root, 'x:LoLimit', {'x' => obj_ns.uri})
+            options[:lo_limit] = Float(lo_limit.text) if lo_limit
+            
+            hi_limit = REXML::XPath.first(root, 'x:HiLimit', {'x' => obj_ns.uri})
+            options[:hi_limit] = Float(hi_limit.text) if hi_limit
+            
+            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
+            
+            self.new(options)
+          end
+        end
+        
+        class TimeIntervalList < TypedArray
+          def self.restricted_to; [TimeIntervalType] end
+        end
+        
+        class VelIntervalList < TypedArray
+          def self.restricted_to; [VelInterval] end
+        end
+        
+        class SpectralIntervalList < TypedArray
+          def self.restricted_to; [SpectralInterval] end
+        end
+        
+        class RedshiftIntervalList < TypedArray
+          def self.restricted_to; [RedshiftInterval] end
+        end
+        
+        class CoordIntervalList < TypedArray
+          def self.restricted_to; [CoordInterval] end
+        end
+        
+        class CoordScalarIntervalList < TypedArray
+          def self.restricted_to; [CoordScalarInterval] end
+        end
+        
+        # Generalized coordinate area type
+        class CoordAreaType
+          include SerializableToXml
+          
+          attr_reader :time_intervals, :spatial_interval, :vel_intervals,
+            :spectral_intervals, :redshift_intervals, :coord_intervals,
+            :id, :coord_system_id
+            
+          def initialize(options={})
+            raise_argument_required_error('id') if !options.has_key?(:id)
+            raise_argument_required_error('coord system id') if !options.has_key?(:coord_system_id)
+            options.each { |key, value| send("#{key}=", value) }
+          end
+          
+          def time_intervals=(is)
+            if is
+              is = TimeIntervalList.new(is) if is.class == Array
+              raise_type_mismatch_error(is, TimeIntervalList)
+            end
+            @time_intervals = is
+          end
+          
+          def spatial_interval=(i)
+            raise_type_mismatch_error(i, SpatialInterval) if i
+            @spatial_interval = i
+          end
+          
+          def vel_intervals=(is)
+            if is
+              is = VelIntervalList.new(is) if is.class == Array
+              raise_type_mismatch_error(is, VelIntervalList)
+            end
+            @vel_intervals = is
+          end
+          
+          def spectral_intervals=(is)
+            if is
+              is = SpectralIntervalList.new(is) if is.class == Array
+              raise_type_mismatch_error(is, SpectralIntervalList)
+            end
+            @spectral_intervals = is
+          end
+          
+          def redshift_intervals=(is)
+            if is
+              is = RedshiftIntervalList.new(is) if is.class == Array
+              raise_type_mismatch_error(is, RedshiftIntervalList)
+            end
+            @redshift_intervals = is
+          end
+          
+          def coord_intervals=(is)
+            if is
+              is = CoordIntervalList.new(is) if is.class == Array
+              raise_type_mismatch_error(is, CoordIntervalList)
+            end
+            @coord_intervals = is
+          end
+          
+          def id=(i)
+            raise_argument_required_error('id') if !i
+            
+            i = Id.new(i) if i.is_a?(String)
+            raise_type_mismatch_error(i, Id)
+            
+            @id = i
+          end
+          
+          def coord_system_id=(ref)
+            raise_argument_required_error('coord system id') if !ref
+            
+            ref = IdRef.new(ref) if ref.is_a?(String)
+            raise_type_mismatch_error(ref, IdRef)
+            
+            @coord_system_id = ref
+          end
+          
+          def ==(a)
+            self.time_intervals == a.time_intervals and
+            self.spatial_interval == a.spatial_interval and
+            self.vel_intervals == a.vel_intervals and
+            self.spectral_intervals == a.spectral_intervals and
+            self.redshift_intervals == a.redshift_intervals and
+            self.coord_intervals == a.coord_intervals and
+            self.id == a.id and
+            self.coord_system_id == a.coord_system_id
+          end
+          
+          def to_xml(name=nil)
+            el = element(name)
+            
+            el.attributes["#{obj_ns.prefix}:ID"] = self.id.to_s
+            el.attributes["#{obj_ns.prefix}:coord_system_id"] = self.coord_system_id.to_s
+            
+            self.time_intervals.each { |i| el.add_element(i.to_xml('TimeInterval')) } if self.time_intervals
+            el.add_element(self.spatial_interval.to_xml) if self.spatial_interval
+            self.vel_intervals.each { |i| el.add_element(i.to_xml) } if self.vel_intervals
+            self.spectral_intervals.each { |i| el.add_element(i.to_xml('SpectralInterval')) } if self.spectral_intervals
+            self.redshift_intervals.each { |i| el.add_element(i.to_xml('RedshiftInterval')) } if self.redshift_intervals
+            self.coord_intervals.each { |i| el.add_element(i.to_xml) } if self.coord_intervals
+            
+            collapse_namespaces(el)
+            el
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {
+              :id => Id.new(root.attributes.get_attribute_ns(obj_ns.uri, 'ID').value),
+              :coord_system_id => IdRef.new(root.attributes.get_attribute_ns(obj_ns.uri, 'coord_system_id').value)
+            }
+            
+            time_intervals = REXML::XPath.match(root, 'x:TimeInterval', {'x' => obj_ns.uri})
+            options[:time_intervals] = TimeIntervalList.new(time_intervals.collect{ |i| TimeIntervalType.from_xml(i) }) if time_intervals
+            
+            options[:spatial_interval] = xml_to_obj(root, SpatialInterval, true)
+            
+            options[:vel_intervals] = xml_to_obj(root, VelInterval)
+            options[:vel_intervals] = nil if options[:vel_intervals].size == 0
+            
+            spectral_intervals = REXML::XPath.match(root, 'x:SpectralInterval', {'x' => obj_ns.uri})
+            options[:spectral_intervals] = SpectralIntervalList.new(spectral_intervals.collect{ |i| SpectralInterval.from_xml(i) }) if spectral_intervals
+            options[:spectral_intervals] = nil if spectral_intervals and options[:spectral_intervals].size == 0
+            
+            redshift_intervals = REXML::XPath.match(root, 'x:RedshiftInterval', {'x' => obj_ns.uri})
+            options[:redshift_intervals] = RedshiftIntervalList.new(redshift_intervals.collect{ |i| RedshiftInterval.from_xml(i) }) if redshift_intervals
+            options[:redshift_intervals] = nil if redshift_intervals and options[:redshift_intervals].size == 0
+            
+            options[:coord_intervals] = xml_to_obj(root, CoordInterval)
+            options[:coord_intervals] = nil if options[:coord_intervals].size == 0
+            
+            self.new(options)
+          end
+        end
+        
+        class AstroCoordAreaType < CoordAreaType
+          def coord_intervals=(is)
+            if is
+              is = CoordScalarIntervalList.new(is) if is.class == Array
+              raise_type_mismatch_error(is, CoordScalarIntervalList)
+            end
+            @coord_intervals = is
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {
+              :id => Id.new(root.attributes.get_attribute_ns(obj_ns.uri, 'ID').value),
+              :coord_system_id => IdRef.new(root.attributes.get_attribute_ns(obj_ns.uri, 'coord_system_id').value)
+            }
+            
+            time_intervals = REXML::XPath.match(root, 'x:TimeInterval', {'x' => obj_ns.uri})
+            options[:time_intervals] = TimeIntervalList.new(time_intervals.collect{ |i| TimeIntervalType.from_xml(i) }) if time_intervals
+            
+            options[:spatial_interval] = xml_to_obj(root, SpatialInterval, true)
+            
+            options[:vel_intervals] = xml_to_obj(root, VelInterval)
+            options[:vel_intervals] = nil if options[:vel_intervals].size == 0
+            
+            spectral_intervals = REXML::XPath.match(root, 'x:SpectralInterval', {'x' => obj_ns.uri})
+            options[:spectral_intervals] = SpectralIntervalList.new(spectral_intervals.collect{ |i| SpectralInterval.from_xml(i) }) if spectral_intervals
+            options[:spectral_intervals] = nil if options[:spectral_intervals].size == 0
+            
+            redshift_intervals = REXML::XPath.match(root, 'x:RedshiftInterval', {'x' => obj_ns.uri})
+            options[:redshift_intervals] = RedshiftIntervalList.new(redshift_intervals.collect{ |i| RedshiftInterval.from_xml(i) }) if redshift_intervals
+            options[:redshift_intervals] = nil if options[:redshift_intervals].size == 0
+            
+            options[:coord_intervals] = xml_to_obj(root, CoordScalarInterval)
+            options[:coord_intervals] = nil if options[:coord_intervals].size == 0
+            
+            self.new(options)
+          end
+        end
+        
+        class PixelCoordAreaType < CoordAreaType
+          attr_reader :coord_intervals
+          
+          class CoordScalarIntervalList < CoordScalarIntervalList
+            def self.minimum_length; 1 end
+          end
+          
+          def initialize(options={})
+            raise_argument_required_error('list of coordinate scalar intervals') if !options.has_key?(:coord_intervals)
+            super(options)
+          end
+          
+          def coord_intervals=(is)
+            raise_argument_required_error('list of coordinate scalar intervals') if !is
+              
+            is = PixelCoordAreaType::CoordScalarIntervalList.new(is) if is.class == Array
+            raise_type_mismatch_error(is, PixelCoordAreaType::CoordScalarIntervalList)
+
+            @coord_intervals = is
+          end
+        
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {
+              :id => Id.new(root.attributes.get_attribute_ns(obj_ns.uri, 'ID').value),
+              :coord_system_id => IdRef.new(root.attributes.get_attribute_ns(obj_ns.uri, 'coord_system_id').value)
+            }
+            
+            time_intervals = REXML::XPath.match(root, 'x:TimeInterval', {'x' => obj_ns.uri})
+            options[:time_intervals] = TimeIntervalList.new(time_intervals.collect{ |i| TimeIntervalType.from_xml(i) }) if time_intervals
+            options[:time_intervals] = nil if time_intervals and options[:time_intervals].size == 0
+            
+            options[:spatial_interval] = xml_to_obj(root, SpatialInterval, true)
+            
+            options[:vel_intervals] = xml_to_obj(root, VelInterval)
+            options[:vel_intervals] = nil if options[:vel_intervals].size == 0
+            
+            spectral_intervals = REXML::XPath.match(root, 'x:SpectralInterval', {'x' => obj_ns.uri})
+            options[:spectral_intervals] = SpectralIntervalList.new(spectral_intervals.collect{ |i| SpectralInterval.from_xml(i) }) if spectral_intervals
+            options[:spectral_intervals] = nil if spectral_intervals and options[:spectral_intervals].size == 0
+            
+            redshift_intervals = REXML::XPath.match(root, 'x:RedshiftInterval', {'x' => obj_ns.uri})
+            options[:redshift_intervals] = RedshiftIntervalList.new(redshift_intervals.collect{ |i| RedshiftInterval.from_xml(i) }) if redshift_intervals
+            options[:redshift_intervals] = nil if redshift_intervals and options[:redshift_intervals].size == 0
+            
+            options[:coord_intervals] = xml_to_obj(root, CoordScalarInterval)
+            options[:coord_intervals] = nil if options[:coord_intervals].size == 0
+
+            self.new(options)
+          end
+        end
+        
+        # General coordinate area description; head element but not abstract
+        module CoordArea; end
+       
+        # Astronomical coordinate volume
+        class AstroCoordArea < AstroCoordAreaType
+          include CoordArea
+        end
+        
+        # Pixel space bounds
+        class PixelCoordArea < PixelCoordAreaType
+          include CoordArea
+        end
+    
+        # Abstract stcMetadata type
+        class StcMetadataType
+          include SerializableToXml
+          
+          attr_reader :id
+          
+          def initialize(options={})
+            options.each { |key, value| send("#{key}=", value) }
+          end
+          
+          def id=(i)
+            i = Id.new(i) if i and i.is_a?(String)
+            raise_type_mismatch_error(i, Id) if i
+            @id = i
+          end
+          
+          def ==(m)
+            self.id == m.id
+          end
+          
+          def to_xml(name=nil)
+            el = element(name)
+            el.attributes["#{obj_ns.prefix}:ID"] = self.id.to_s if self.id
+            el
+          end
+        end
+        
+        class CoordsList < TypedArray
+          def self.restricted_to; [Coords] end
+        end
+        
+        class CoordAreaList < TypedArray
+          def self.restricted_to; [CoordArea] end
+        end
+        
+        # Generalized single stcMetadata type
+        class StcDescription < StcMetadataType
+          attr_reader :coord_sys, :coords, :coord_areas
+          
+          class CoordSysList < TypedArray
+            def self.restricted_to; [CoordSys] end
+            def self.minimum_length; 1 end
+          end
+          
+          def initialize(options={})
+            raise_argument_required_error('list of coordinate systems') if !options.has_key?(:coord_sys)
+            super(options)
+          end
+          
+          def coord_sys=(ss)
+            raise_argument_required_error('list of coordinate systems') if !ss
+            
+            ss = StcDescription::CoordSysList.new(ss) if ss.class == Array
+            raise_type_mismatch_error(ss, StcDescription::CoordSysList)
+            
+            @coord_sys = ss
+          end
+          
+          def coords=(cs)
+            cs = CoordsList.new(cs) if cs and cs.class == Array
+            raise_type_mismatch_error(cs, CoordsList) if cs
+            @coords = cs
+          end
+          
+          def coord_areas=(cs)
+            cs = CoordAreaList.new(cs) if cs and cs.class == Array
+            raise_type_mismatch_error(cs, CoordAreaList) if cs
+            @coord_areas = cs
+          end
+          
+          def ==(d)
+            super(d) and
+            self.coord_sys == d.coord_sys and
+            self.coords == d.coords and
+            self.coord_areas == d.coord_areas
+          end
+          
+          def to_xml(name=nil)
+            el = super(name)
+            
+            if self.coord_sys
+              self.coord_sys.is_a?(Array) ? self.coord_sys.each { |s| el.add_element(s.to_xml) } : el.add_element(self.coord_sys.to_xml)
+            end
+            
+            if self.coords
+              self.coords.is_a?(Array) ? self.coords.each { |c| el.add_element(c.to_xml) } : el.add_element(self.coords.to_xml)
+            end
+            
+            if self.coord_areas
+              self.coord_areas.is_a?(Array) ? self.coord_areas.each { |a| el.add_element(a.to_xml) } : el.add_element(self.coord_areas.to_xml)
+            end
+            
+            collapse_namespaces(el)
+            el
+          end
+        end
+        
+        class AstroCoordSystemList < TypedArray
+          def self.restricted_to; [AstroCoordSystem] end
+          def self.minimum_length; 1 end
+        end
+        
+        # Type for STC Resource Profile
+        class StcResourceProfileType < StcDescription
+          def initialize(options={})
+            raise_argument_required_error('astro coordinate systems') if !options.has_key?(:coord_sys)
+            raise_argument_required_error('astro coordinate') if !options.has_key?(:coords)
+            raise_argument_required_error('astro coordinate area') if !options.has_key?(:coord_areas)
+            super(options)
+          end
+          
+          # The coordinate system definition: spatial coordinate frame and reference position;
+          # time frame and reference position; the coordinate flavor; and the planetary ephemeris;
+          # an ID is required, since this is how coordinate elements are associated with their
+          # coordinate systems
+          def coord_sys=(ss)
+            raise_argument_required_error('astro coordinate systems') if !ss
+            
+            ss = AstroCoordSystemList.new(ss) if ss.class == Array
+            raise_type_mismatch_error(ss, AstroCoordSystemList)
+            
+            @coord_sys = ss
+          end
+          
+          # Contains information on time and spatial resolution, errors, and pixelsizes (if fixed);
+          # typical best numbers are expected
+          def coords=(c)
+            raise_argument_required_error('astro coordinate') if !c
+            raise_type_mismatch_error(c, AstroCoords)
+            @coords = c
+          end
+          
+          # The coverage area of the resource; the fill factor does not need to be 1.0
+          def coord_areas=(a)
+            raise_argument_required_error('astro coordinate area') if !a
+            raise_type_mismatch_error(a, AstroCoordArea)
+            @coord_areas = a
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {
+              :coord_sys => xml_to_obj(root, AstroCoordSystem),
+              :coords => xml_to_obj(root, AstroCoords, true, Coords),
+              :coord_areas => xml_to_obj(root, AstroCoordArea, true)
+            }
+            
+            id = root.attributes.get_attribute_ns(obj_ns.uri, 'ID')
+            options[:id] = Id.new(id.value) if id
+            
+            self.new(options)
+          end
+        end
+        
+        # Type for STC search location
+        class SearchLocationType < StcDescription
+          def initialize(options={})
+            raise_argument_required_error('astro coordinate systems') if !options.has_key?(:coord_sys)
+            raise_argument_required_error('astro coordinate area') if !options.has_key?(:coord_areas)
+            super(options)
+          end
+          
+          def coord_sys=(ss)
+            aise_argument_required_error('astro coordinate systems') if !ss
+            
+            ss = AstroCoordSystemList.new(ss) if ss.class == Array
+            raise_type_mismatch_error(ss, AstroCoordSystemList)
+            
+            @coord_sys = ss
+          end
+
+          def coords=(c)
+            raise_type_mismatch_error(c, AstroCoords) if c
+            @coords = c
+          end
+          
+          def coord_areas=(a)
+            raise_argument_required_error('astro coordinate area') if !a
+            raise_type_mismatch_error(a, AstroCoordArea)
+            @coord_areas = a
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {
+              :coord_sys => xml_to_obj(root, AstroCoordSystem),
+              :coords => xml_to_obj(root, AstroCoords, true, Coords),
+              :coord_areas => xml_to_obj(root, AstroCoordArea, true)
+            }
+            
+            id = root.attributes.get_attribute_ns(obj_ns.uri, 'ID')
+            options[:id] = Id.new(id.value) if id
+            
+            self.new(options)
+          end
+        end
+        
+        # Type for STC catalog entry description
+        class CatalogEntryLocationType < StcDescription
+          class AstroCoordsList < TypedArray
+            def self.restricted_to; [AstroCoords] end
+            def self.minimum_length; 1 end
+          end
+          
+          class AstroCoordAreaList < TypedArray
+            def self.restricted_to; [AstroCoordArea] end
+          end
+          
+          def initialize(options={})
+            raise_argument_required_error('astro coordinate systems') if !options.has_key?(:coord_sys)
+            raise_argument_required_error('astro coordinates') if !options.has_key?(:coords)
+            super(options)
+          end
+          
+          def coord_sys=(ss)
+            raise_argument_required_error('astro coordinate systems') if !ss
+            
+            ss = AstroCoordSystemList.new(ss) if ss.class == Array
+            raise_type_mismatch_error(ss, AstroCoordSystemList)
+            
+            @coord_sys = ss
+          end
+          
+          def coords=(cs)
+            raise_argument_required_error('astro coordinates') if !cs
+            
+            cs = CatalogEntryLocationType::AstroCoordsList.new(cs) if cs.class == Array
+            raise_type_mismatch_error(cs, CatalogEntryLocationType::AstroCoordsList)
+            
+            @coords = cs
+          end
+          
+          def coord_areas=(as)
+            if as
+              as = CatalogEntryLocationType::AstroCoordAreaList.new(as) if as.class == Array
+              raise_type_mismatch_error(as, CatalogEntryLocationType::AstroCoordAreaList)
+            end
+            
+            @coord_areas = as
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {
+              :coord_sys => xml_to_obj(root, AstroCoordSystem),
+              :coords => xml_to_obj(root, AstroCoords, false, Coords),
+              :coord_areas => xml_to_obj(root, AstroCoordArea)
+            }
+            
+            id = root.attributes.get_attribute_ns(obj_ns.uri, 'ID')
+            options[:id] = Id.new(id.value) if id
+            
+            self.new(options)
+          end
+        end
+        
+        # Type for an observatory location
+        class ObservatoryLocation < StcDescription
+          def initialize(options={})
+            raise_argument_required_error('astro coordinate systems') if !options.has_key?(:coord_sys)
+            raise_argument_required_error('astro coordinate') if !options.has_key?(:coords)
+            super(options)
+          end
+          
+          def coord_sys=(ss)
+            raise_argument_required_error('astro coordinate systems') if !ss
+            
+            ss = AstroCoordSystemList.new(ss) if ss.class == Array
+            raise_type_mismatch_error(ss, AstroCoordSystemList)
+            
+            @coord_sys = ss
+          end
+          
+          def coords=(c)
+            raise_argument_required_error('astro coordinate') if !c
+            raise_type_mismatch_error(c, AstroCoords)
+            @coords = c
+          end
+          
+          def coord_areas=(cs)
+            raise ArgumentError, 'astro coordinate areas not applicable'
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {
+              :coord_sys => xml_to_obj(root, AstroCoordSystem),
+              :coords => xml_to_obj(root, AstroCoords, true, Coords)
+            }
+            
+            id = root.attributes.get_attribute_ns(obj_ns.uri, 'ID')
+            options[:id] = Id.new(id.value) if id
+            
+            self.new(options)
+          end
+        end
+        
+        # Type for describing the coordinate volume occupied by observational data, as seen from the observatory location
+        class ObservationLocation < StcDescription
+          def initialize(options={})
+            raise_argument_required_error('astro coordinate systems') if !options.has_key?(:coord_sys)
+            raise_argument_required_error('astro coordinate') if !options.has_key?(:coords)
+            raise_argument_required_error('astro coordinate area') if !options.has_key?(:coord_areas)
+            super(options)
+          end
+          
+          def coord_sys=(ss)
+            raise_argument_required_error('astro coordinate systems') if !ss
+            
+            ss = AstroCoordSystemList.new(ss) if ss.class == Array
+            raise_type_mismatch_error(ss, AstroCoordSystemList)
+            
+            @coord_sys = ss
+          end
+          
+          def coords=(c)
+            raise_argument_required_error('astro coordinate') if !c
+            raise_type_mismatch_error(c, AstroCoords)
+            @coords = c
+          end
+          
+          def coord_areas=(a)
+            raise_argument_required_error('astro coordinate area') if !a
+            raise_type_mismatch_error(a, AstroCoordArea)
+            @coord_areas = a
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {
+              :coord_sys => xml_to_obj(root, AstroCoordSystem),
+              :coords => xml_to_obj(root, AstroCoords, true, Coords),
+              :coord_areas => xml_to_obj(root, AstroCoordArea, true)
+            }
+            
+            id = root.attributes.get_attribute_ns(obj_ns.uri, 'ID')
+            options[:id] = Id.new(id.value) if id
+            
+            self.new(options)
+          end
+        end
+        
+        class PixelCoordSystemList < TypedArray
+          def self.restricted_to; [PixelCoordSystem] end
+        end
+        
+        class PixelCoordsList < TypedArray
+          def self.restricted_to; [PixelCoords] end
+        end
+        
+        # Type to specify a pixel space
+        class PixelSpace < StcDescription
+          def initialize(options={})
+            raise_argument_required_error('pixel coordinate system') if !options.has_key?(:coord_sys)
+            raise_argument_required_error('pixel coordinate area') if !options.has_key?(:coord_areas)
+            super(options)
+          end
+          
+          def coord_sys=(s)
+            raise_argument_required_error('pixel coordinate system') if !s
+            raise_type_mismatch_error(s, PixelCoordSystem)
+            @coord_sys = s
+          end
+          
+          def coords=(cs)
+            if cs
+              cs = PixelCoordsList.new(cs) if cs.class == Array
+              raise_type_mismatch_error(cs, PixelCoordsList)
+            end
+            
+            @coords = cs
+          end
+          
+          def coord_areas=(a)
+            raise_argument_required_error('pixel coordinate area') if !a
+            raise_type_mismatch_error(a, PixelCoordArea)
+            @coord_areas = a
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {
+              :coord_sys => xml_to_obj(root, PixelCoordSystem, true),
+              :coords => xml_to_obj(root, PixelCoords, false, Coords),
+              :coord_areas => xml_to_obj(root, PixelCoordArea, true)
+            }
+            
+            id = root.attributes.get_attribute_ns(obj_ns.uri, 'ID')
+            options[:id] = Id.new(id.value) if id
+            
+            self.new(options)
+          end
+        end
+        
+        # Type for observational STC metadata.
+        # Describes the spatial and temporal volume covered by an observation.
+        class ObsDataLocationType < StcMetadataType
+          attr_reader :observatory_location, :observation_location, :pixel_space
+          
+          def initialize(options={})
+            raise_argument_required_error('observatory location') if !options.has_key?(:observatory_location)
+            raise_argument_required_error('observation location') if !options.has_key?(:observation_location)
+            super(options)
+          end
+          
+          # Specifies the location of the observatory during the observation
+          def observatory_location=(l)
+            raise_argument_required_error('observatory location') if !l
+            raise_type_mismatch_error(l, ObservatoryLocation)
+            @observatory_location = l
+          end
+          
+          # Describes the spatial and temporal coverage of the observation
+          def observation_location=(l)
+            raise_argument_required_error('observation location') if !l
+            raise_type_mismatch_error(l, ObservationLocation)
+            @observation_location = l
+          end
+          
+          # Defines the pixel coordinate system for pixelated data
+          def pixel_space=(s)
+            raise_type_mismatch_error(s, PixelSpace) if s
+            @pixel_space = s
+          end
+          
+          def to_xml(name=nil)
+            el = super(name)
+            
+            el.add_element(self.observatory_location.to_xml('ObservatoryLocation'))
+            el.add_element(self.observation_location.to_xml('ObservationLocation'))
+            el.add_element(self.pixel_space.to_xml('PixelSpace')) if self.pixel_space
+            
+            collapse_namespaces(el)
+            el
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {
+              :observatory_location => ObservatoryLocation.from_xml(
+                REXML::XPath.first(root, 'x:ObservatoryLocation', {'x' => obj_ns.uri})
+              ),
+              :observation_location => ObservationLocation.from_xml(
+                REXML::XPath.first(root, 'x:ObservationLocation', {'x' => obj_ns.uri})
+              )
+            }
+            
+            id = root.attributes.get_attribute_ns(obj_ns.uri, 'ID')
+            options[:id] = id.value if id
+            
+            pixel_space = REXML::XPath.first(root, 'x:PixelSpace', {'x' => obj_ns.uri})
+            options[:pixel_space] = PixelSpace.from_xml(pixel_space) if pixel_space
+            
+            self.new(options)
+          end
+        end
+        
+        # Toplevel: Abstract STCmetadata contains a choice of: ResourceProfile, SearchLocation,
+        # CatalogEntryLocation, or ObservationLocation plus ObservatoryLocation elements
+        module StcMetadata; end
+        
+        # Describes the spatial and temporal coverage of a resource
+        class StcResourceProfile < StcResourceProfileType
+          include StcMetadata
+        end
+        
+        # Defines the spatial and temporal coordinate space specified by a query
+        class SearchLocation < SearchLocationType
+          include StcMetadata
+        end
+        
+        # Describes the spatial and temporal coverage of a catalog (fragment) and contains the
+        # coordinates of the catalog entries; multiple coordinate systems are allowed
+        class CatalogEntryLocation < CatalogEntryLocationType
+          include StcMetadata
+        end
+        
+        # Describes the coordinate system used in and coordinate space occupied by a particular
+        # observational dataset; it contains an observation location, an observatory location,
+        # and optionally a pixel coordinate system
+        class ObsDataLocation < ObsDataLocationType
+          include StcMetadata
+        end
+    
+      end
+    end
+  end
+end