voruby 1.1.1 → 2.0.0

data/lib/voruby/votable/votable.rb

@@ -0,0 +1,305 @@
+require 'open-uri'
+require 'mathn'
+require 'date'
+require 'tempfile'
+
+begin
+  require 'rubygems'
+rescue LoadError; end
+require 'xml/libxml'
+require 'builder'
+
+require 'voruby'
+require 'voruby/misc/libxml_ext'
+
+module VORuby
+  # A set of classes designed to read and manipulate the IVOA[http://www.ivoa.net/]
+  # standard for representing astronomical tabular data called
+  # VOTable[http://www.ivoa.net/Documents/latest/VOT.html].
+  #
+  # As a quick start, you might do something like this:
+  #
+  #  require 'voruby/votable/votable'
+  #  include VORuby
+  #
+  #  votable = VOTable.from_xml(File.new('votable.basic.xml'))  # this happens to be a 1.1 votable
+  #  table = votable.resources.first.tables.first               # get the first resource and table
+  #
+  #  # See the name of each column
+  #  puts table.fields.collect{ |field| field.name }.join('|')
+  #
+  #  # Iterate through each row.
+  #  table.data.format.trs.each do |row|
+  #    row_as_string = row.tds.collect{ |td| td.value }.join('|')
+  #    puts row_as_string
+  #  end
+  #
+  # Methods that are pluralized (i.e. table.fields and format.trs above) normally return an
+  # array-like object called a HomogeneousNodeList.  You can do most of the common array
+  # operations on it, including array assignment ([]=) and retrieval ([]), appending (<<)
+  # and iteration (each). So:
+  #
+  #  table.fields << Field.new(...)       # append a new field
+  #  table.fields.prepend(Field.new(...)) # prepend a new field
+  #  table.fields.each { |field| ... }    # iterate through each field
+  #  table.fields[2] = Field.new(...)     # assign a new field to the third position
+  #  table.fields[2]                      # retrieve the third field
+  #  table.fields.delete_at(2)            # delete the third field
+  #  table.fields.clear                   # delete all fields
+  #  table.fields.first                   # retrieve the first field
+  #  table.fields.last                    # retrieve the last field
+  #  table.fields.size                    # the number of fields present
+  #
+  # It also mixes in Enumerable so all the other standard methods are available.
+  #
+  # To build a simple VOTable from scratch all in one go one might do this:
+  #
+  #   votable = VOTable.new(
+  #     :version => '1.1',
+  #     :coordinate_systems => [
+  #       Coosys.new(:id => 'J2000', :equinox => 'J2000.', :epoch => 'J2000.', :system => 'eq_FK5')
+  #     ],
+  #     :resources => [
+  #       Resource.new(
+  #         :name => 'myFavouriteGalaxies',
+  #         :tables => [
+  #           Table.new(
+  #             :name => 'results',
+  #             :description => Description.new(:text => 'Velocities and Distance estimations'),
+  #             :params => [
+  #               Param.new(
+  #                 :name => 'Telescope',
+  #                 :datatype => 'float',
+  #                 :ucd => 'phys.size;instr.tel',
+  #                 :unit => 'm',
+  #                 :value => '3.6'
+  #               )
+  #             ],
+  #             :fields => [
+  #               Field.new(:name => 'RA', :id => 'col1', :ucd => 'pos.eq.ra;meta.main',
+  #                         :ref => 'J2000', :datatype => 'float', :width => 6, :precision => '2', :unit => 'deg'),
+  #               Field.new(:name => 'Dec', :id => 'col2', :ucd => 'pos.eq.dec;meta.main',
+  #                         :ref => 'J2000', :datatype => 'float', :width => 6, :precision => '2', :unit => 'deg'),
+  #               Field.new(:name => 'Name', :id => 'col3', :ucd => 'meta.id;meta.main',
+  #                         :datatype => 'char', :arraysize => '8*'),
+  #               Field.new(:name => 'RVel', :id => 'col4', :ucd => 'src.veloc.hc', :datatype => 'int',
+  #                         :width => 5, :unit => 'km/s'),
+  #               Field.new(:name => 'e_RVel', :id => 'col5', :ucd => 'stat.error;src.veloc.hc',
+  #                         :datatype => 'int', :width => 3, :unit => 'km/s'),
+  #               Field.new(:name => 'R', :id => 'col6', :ucd => 'phys.distance', :datatype => 'float',
+  #                         :width => 4, :precision => '1', :unit => 'Mpc',
+  #                         :description => Description.new(:text => 'Distance of Galaxy, assuming H=75km/s/Mpc'))
+  #             ],
+  #             :data => Data.new(
+  #               :format => TableData.new(
+  #                 :trs => [
+  #                   Tr.new(:tds => [
+  #                       Td.new(:text => '010.68'), Td.new(:text => '+41.27'), Td.new(:text => 'N 224'),
+  #                       Td.new(:text => '-297'), Td.new(:text => '5'), Td.new(:text => '0.7')
+  #                   ]),
+  #                   Tr.new(:tds => [
+  #                     Td.new(:text => '287.43'), Td.new(:text => '-63.85'), Td.new(:text => 'N 6744'),
+  #                     Td.new(:text => '839'), Td.new(:text => '6'), Td.new(:text => '10.4')
+  #                   ]),
+  #                   Tr.new(:tds => [
+  #                     Td.new(:text => '023.48'), Td.new(:text => '+30.66'), Td.new(:text => 'N 598'),
+  #                     Td.new(:text => '-182'), Td.new(:text => '3'), Td.new(:text => '0.7')
+  #                   ])
+  #                 ]
+  #               )
+  #             )
+  #           )
+  #         ]
+  #       )
+  #     ]
+  #   )
+  #
+  # Of course, it's more likely you would have read the votable in directly from a file.
+  # To convert this votable to a (very) simple CSV-like file you could then:
+  #
+  #   puts votable.resources.first.tables.first.fields.collect{ |field| field.name }.join(',')
+  #   votable.resources.first.tables.first.data.format.trs.each do |tr|
+  #     puts tr.tds.collect{ |td| td.text }.join(',')
+  #   end
+  #
+  # Which would print out something like:
+  #
+  #   RA,Dec,RVel,e_RVel,R
+  #   010.68,+41.27,N 224,-297,5,0.7
+  #   287.43,-63.85,N 6744,839,6,10.4
+  #   023.48,+30.66,N 598,-182,3,0.7
+  #
+  # You can also convert the votable to an HTML fragment by doing:
+  #
+  #   votable.to_html
+  module VOTable
+    # Automatically determines the votable version in question and
+    # returns the appropriate domain object.
+    # _defn_:: a String, XML::Document, XML::Node or IO object representing the XML.
+    #
+    #  votable = VOTable.from_xml(File.new('votable.basic.xml'))  # assuming this is 1.1 document
+    #  puts votable.class   #=> VOTable::V1_1::VOTable
+    def self.from_xml(defn)
+      generic_vot = Base.new(defn).node
+      
+      namespaces = (generic_vot.namespace || []).collect{ |ns| ns.href }
+      namespaces << generic_vot['noNamespaceSchemaLocation']
+      
+      if namespaces.include?('http://www.ivoa.net/xml/VOTable/VOTable/v1.1') or generic_vot['version'] =~ /1\.1$/
+        return VOTable::V1_1::VOTable.new(generic_vot)
+      elsif namespaces.include?('http://www.ivoa.net/xml/VOTable/v1.0') or generic_vot['version'] =~ /1\.0$/
+        return VOTable::V1_0::VOTable.new(generic_vot)
+      else
+        return VOTable::V1_1::VOTable.new(generic_vot) # go with the most recent if namespace indeterminate
+      end
+    end
+    
+    # Some helper methods for converting string values that have an associated
+    # data type (like TDs do through their associated FIELD).
+    module Castable
+      # Convert a string value into its corresponding basic object representation,
+      # if appropriate.  This does *not* work on array values, only on scalars.
+      # Native ruby types map to votable datatypes in the following way:
+      #
+      # * 'boolean' => boolean (i.e TrueClass or FalseClass)
+      # * 'bit' => Integer (1 or 0)
+      # * 'unsignedByte' => Integer representation of the byte
+      # * 'short, 'int', 'long' => Integer
+      # * 'char', 'unicodeChar' => String
+      # * 'float', 'double' => Float or Bignum
+      # * 'floatComplex', 'doubleComplex' => Complex
+      def cast(txt, to='char')
+        case to
+        when 'boolean'
+          txt == '1' || txt.downcase == 'true' || txt.downcase == 't'
+        when 'bit'          then txt.to_i
+        when 'unsignedByte' then txt[0]
+        when 'short'        then txt.to_i
+        when 'int'          then txt.to_i
+        when 'long'         then txt.to_i
+        when 'double'       then txt.to_f
+        when 'float'        then txt.to_f
+        else
+          txt
+        end
+      end
+    
+      # Serialize a ruby object to the format that is correct
+      # for a votable.
+      def convert_to_s(val, from='char')
+        case from
+        when 'boolean'
+          (val.is_a?(TrueClass) or val.to_s.downcase =~ /^t/ or val.to_s == '1') ?
+            'true' : 'false'
+        when 'bit'            then val.to_i.to_s
+        when 'short'          then val.to_i.to_s
+        when 'int'            then val.to_i.to_s
+        when 'long'           then val.to_i.to_s
+        when 'float'          then val.to_f.to_s
+        when 'double'         then val.to_f.to_s
+        when 'floatComplex'   then "#{val.real} #{val.image}"
+        when 'doubleComplex'  then "#{val.real} #{val.image}"
+        else
+          val.to_s
+        end
+      end
+      
+      # Much like #cast but understands arrays.
+      def as_obj(txt, datatype, arraysize=nil)
+        raise "Unable to determine datatype" if !datatype
+        
+        txt_list = arraysize ? txt.split(/\s+/) : [txt]
+        values_list = []
+        
+        # character string, do nothing
+        return txt if datatype == 'char' or datatype == 'unicodeChar'
+        
+        # complex values are a bit different
+        if datatype == 'floatComplex' || datatype == 'doubleComplex'
+          txt_list = txt.split(/\s+/)
+          complex_numbers = []
+          i = 0
+          (0...txt_list.size/2).each do |n|
+            complex_numbers << Complex.new(txt_list[i].to_f, txt_list[i+1].to_f)
+            i += 2
+          end
+          return arraysize ? complex_numbers : complex_numbers.first
+        end
+        
+        txt_list.each do |component|
+          values_list << cast(component, datatype)
+        end
+        
+        arraysize ? values_list : values_list.first
+      end
+      
+      # Much like #convert_to_s but understands arrays.
+      def as_string(obj, datatype, arraysize=nil)
+        raise "Unable to determine datatype" if !datatype
+        raise "Supposed to contain an array of size '#{arraysize}'" if arraysize and !obj.is_a?(Array)
+        raise "Supposed to contain a single value" if !arraysize and obj.is_a?(Array)
+        
+        obj = [obj] if !obj.is_a?(Array)
+        
+        values = []
+        obj.each do |val|
+          values << convert_to_s(val, datatype)
+        end
+        
+        values.join(' ')
+      end
+    end
+    
+    # The base class that all VOTable domain objects derive from.
+    # You'll never instantiate this directly.
+    class Base < XML::Object::Base
+      # Get the name of the element when serialized
+      # to XML that the object in question will take on.
+      def self.element_name
+        const_get('ELEMENT_NAME')
+      end
+      
+      # Determine the xpath corresponding to the specified class.
+      #   obj.xpath_for(Field)  # => "*[local-name()='FIELD']"
+      def xpath_for(klass)
+        "*[local-name()='#{klass.element_name}']"
+      end
+      
+      # Retrieve the domain object that corresponds to
+      # the specified class.
+      def get_element(klass)
+        subnode = self.node.find_first("*[local-name()='#{klass.element_name}']")
+        subnode ? klass.new(subnode) : nil
+      end
+      
+      # Equality among domain objects.
+      # Two objects are considered equal if they're
+      # of the same class and their accessor methods
+      # themselves return objects which are equal.
+      def ==(obj)
+        return false if self.class != obj.class
+        
+        self.methods_to_test_for_equality.each do |method|
+          return false if self.send(method) != obj.send(method)
+        end
+       
+        true
+      end
+      
+      private
+      
+      def initialize_members(args)
+        if self.class.respond_to?(:serialization_order)
+          self.class.serialization_order.each do |name|
+            send("#{name}=", args[name]) if args.has_key?(name)
+          end
+        else
+          args.each do |name, value|
+            send("#{name}=", value)
+          end
+        end
+      end
+    end
+    
+  end
+end

data/lib/voruby/wesix/wesix.rb

@@ -0,0 +1,491 @@
+require 'base64'
+require 'open-uri'
+
+begin
+  require 'rubygems'
+rescue LoadError; end
+
+gem 'soap4r'
+require 'soap/wsdlDriver'
+
+require 'voruby/votable/1.1/votable'
+
+module VORuby
+  module Wesix    
+    class SextractorParams
+      WESIX_NS = 'http://wesixtest.phyast.pitt.edu'
+      
+      def initialize(params={})
+        params.each{ |key, value| self.send("#{key}=", value) }
+      end
+    end
+
+    # Object containing the parameters to be used by WESIX (e.g. SExtractor) to create the source catalog.
+    # You can preset values by passing a hash to the constructor:
+    #
+    #   params = Params.new(:analysis_thresh => 2.0)
+    #   params.detect_thresh = 2.0
+    #   puts params.analysis_thresh # => 2.0
+    #
+    # Available methods are:
+    #  #analysis_thresh, #backphoto_type, #back_filtersize, #back_size, #catalog_name, #catalog_type,
+    #  #checkimage_name, #checkimage_type, #clean, #clean_param, #deblend_mincont, #deblend_nthresh,
+    #  #detect_minarea, #detect_thresh, #detect_type, #filter, #filter_name, #flag_image, #gain,
+    #  #mag_gamma, #mag_zeropoint, #mask_type, #memory_bufsize, #memory_objstack, #memory_pixstack,
+    #  #parameters_name, #phot_apertures, #phot_autoparams1, #phot_autoparams2, #pixel_scale, #satur_level,
+    #  #seeing_fwhm, #starnnw_name, #verbose_type, #query1, #query2, #string
+    class Params < SextractorParams
+      # Returns the schema required to convert this object into a
+      # fully-fledged SOAP object.  Used by Service.
+      def self.soap_registration
+        {
+          :class => self,
+          :schema_type => XSD::QName.new(WESIX_NS, "SexParams"),
+          :schema_element => [
+            ["analysis_thresh", ["SOAP::SOAPDouble", XSD::QName.new(nil, "ANALYSIS_THRESH")]],
+            ["backphoto_type", ["SOAP::SOAPString", XSD::QName.new(nil, "BACKPHOTO_TYPE")]],
+            ["back_filtersize", ["SOAP::SOAPInt", XSD::QName.new(nil, "BACK_FILTERSIZE")]],
+            ["back_size", ["SOAP::SOAPInt", XSD::QName.new(nil, "BACK_SIZE")]],
+            ["catalog_name", ["SOAP::SOAPString", XSD::QName.new(nil, "CATALOG_NAME")]],
+            ["catalog_type", ["SOAP::SOAPString", XSD::QName.new(nil, "CATALOG_TYPE")]],
+            ["checkimage_name", ["SOAP::SOAPString", XSD::QName.new(nil, "CHECKIMAGE_NAME")]],
+            ["checkimage_type", ["SOAP::SOAPString", XSD::QName.new(nil, "CHECKIMAGE_TYPE")]],
+            ["clean", ["SOAP::SOAPString", XSD::QName.new(nil, "CLEAN")]],
+            ["clean_param", ["SOAP::SOAPDouble", XSD::QName.new(nil, "CLEAN_PARAM")]],
+            ["deblend_mincont", ["SOAP::SOAPDouble", XSD::QName.new(nil, "DEBLEND_MINCONT")]],
+            ["deblend_nthresh", ["SOAP::SOAPInt", XSD::QName.new(nil, "DEBLEND_NTHRESH")]],
+            ["detect_minarea", ["SOAP::SOAPInt", XSD::QName.new(nil, "DETECT_MINAREA")]],
+            ["detect_thresh", ["SOAP::SOAPDouble", XSD::QName.new(nil, "DETECT_THRESH")]],
+            ["detect_type", ["SOAP::SOAPString", XSD::QName.new(nil, "DETECT_TYPE")]],
+            ["filter", ["SOAP::SOAPString", XSD::QName.new(nil, "FILTER")]],
+            ["filter_name", ["SOAP::SOAPString", XSD::QName.new(nil, "FILTER_NAME")]],
+            ["flag_image", ["SOAP::SOAPString", XSD::QName.new(nil, "FLAG_IMAGE")]],
+            ["gain", ["SOAP::SOAPDouble", XSD::QName.new(nil, "GAIN")]],
+            ["mag_gamma", ["SOAP::SOAPDouble", XSD::QName.new(nil, "MAG_GAMMA")]],
+            ["mag_zeropoint", ["SOAP::SOAPDouble", XSD::QName.new(nil, "MAG_ZEROPOINT")]],
+            ["mask_type", ["SOAP::SOAPString", XSD::QName.new(nil, "MASK_TYPE")]],
+            ["memory_bufsize", ["SOAP::SOAPInt", XSD::QName.new(nil, "MEMORY_BUFSIZE")]],
+            ["memory_objstack", ["SOAP::SOAPInt", XSD::QName.new(nil, "MEMORY_OBJSTACK")]],
+            ["memory_pixstack", ["SOAP::SOAPInt", XSD::QName.new(nil, "MEMORY_PIXSTACK")]],
+            ["parameters_name", ["SOAP::SOAPString", XSD::QName.new(nil, "PARAMETERS_NAME")]],
+            ["phot_apertures", ["SOAP::SOAPInt", XSD::QName.new(nil, "PHOT_APERTURES")]],
+            ["phot_autoparams1", ["SOAP::SOAPDouble", XSD::QName.new(nil, "PHOT_AUTOPARAMS1")]],
+            ["phot_autoparams2", ["SOAP::SOAPDouble", XSD::QName.new(nil, "PHOT_AUTOPARAMS2")]],
+            ["pixel_scale", ["SOAP::SOAPDouble", XSD::QName.new(nil, "PIXEL_SCALE")]],
+            ["satur_level", ["SOAP::SOAPDouble", XSD::QName.new(nil, "SATUR_LEVEL")]],
+            ["seeing_fwhm", ["SOAP::SOAPDouble", XSD::QName.new(nil, "SEEING_FWHM")]],
+            ["starnnw_name", ["SOAP::SOAPString", XSD::QName.new(nil, "STARNNW_NAME")]],
+            ["verbose_type", ["SOAP::SOAPString", XSD::QName.new(nil, "VERBOSE_TYPE")]],
+            ["query1", ["SOAP::SOAPString", XSD::QName.new(nil, "query1")]],
+            ["query2", ["SOAP::SOAPString", XSD::QName.new(nil, "query2")]],
+            ["string", ["SOAP::SOAPString", XSD::QName.new(nil, "string")]]
+          ]
+        }
+      end
+      
+      attr_accessor *soap_registration[:schema_element].collect{ |defn| defn.first }
+    end
+
+    # Object containing the measured parameters (all booleans) to be included in the output catalog
+    # generated by WESIX. You can preset values by passing a hash to the constructor:
+    #
+    #   params = OutputParams.new(:flux_best => true)
+    #   params.fluxerr_best = true
+    #   puts params.flux_best # => true
+    #
+    # Available methods are:
+    #  #alpha_b1950, #alpha_j2000, #alpha_sky, #background, #class_star, #cxx_image, #cxx_world,
+    #  #cxy_image, #cxy_world, #cyy_image, #cyy_world, #delta_b1950, #delta_j2000, #delta_sky,
+    #  #ellipticity, #elongation, #erra_image, #erra_world, #errb_image, #errb_world, #errcxx_image,
+    #  #errcxx_world, #errcxy_image, #errcxy_world, #errcyy_image, #errcyy_world, #errtheta_b1950,
+    #  #errtheta_image, #errtheta_j2000, #errtheta_sky, #errtheta_world, #errx2_image, #errx2_world,
+    #  #errxy_image, #errxy_world, #erry2_image, #erry2_world, #flags, #fluxerr_aper, #fluxerr_auto,
+    #  #fluxerr_best, #fluxerr_iso, #fluxerr_isocor, #flux_aper, #flux_auto, #flux_best, #flux_iso,
+    #  #flux_isocor, #flux_max, #fwhm_image, #fwhm_world, #imaflags_iso, #iso0, #iso1, #iso2, #iso3,
+    #  #iso4, #iso5, #iso6, #iso7, #isoarea_image, #isoarea_world, #kron_radius, #magerr_aper, #magerr_auto,
+    #  #magerr_best, #magerr_iso, #magerr_isocor, #mag_aper, #mag_auto, #mag_best, #mag_iso, #mag_isocor, #mu_max,
+    #  #mu_threshold, #nimaflags_iso, #number, #theta_b1950, #theta_image, #theta_j2000, #theta_sky, #theta_world,
+    #  #threshold, #vignet, #xmax_image, #xmin_image, #xy_image, #xy_world, #ymax_image, #ymin_image, #a_image, #a_world,
+    #  #b_image, #b_world, #params, #x2_image, #x2_world, #x_image, #x_world, #y2_image, #y2_world, #y_image, #y_world
+    class OutputParams < SextractorParams
+      # Returns the schema required to convert this object into a
+      # fully-fledged SOAP object.  Used by Service.
+      def self.soap_registration
+        {
+          :class => self,
+          :schema_type => XSD::QName.new(WESIX_NS, "SexOutputParams"),
+          :schema_element => [
+            ["alpha_b1950", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "ALPHA_B1950")]],
+            ["alpha_j2000", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "ALPHA_J2000")]],
+            ["alpha_sky", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "ALPHA_SKY")]],
+            ["background", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "BACKGROUND")]],
+            ["class_star", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "CLASS_STAR")]],
+            ["cxx_image", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "CXX_IMAGE")]],
+            ["cxx_world", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "CXX_WORLD")]],
+            ["cxy_image", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "CXY_IMAGE")]],
+            ["cxy_world", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "CXY_WORLD")]],
+            ["cyy_image", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "CYY_IMAGE")]],
+            ["cyy_world", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "CYY_WORLD")]],
+            ["delta_b1950", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "DELTA_B1950")]],
+            ["delta_j2000", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "DELTA_J2000")]],
+            ["delta_sky", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "DELTA_SKY")]],
+            ["ellipticity", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "ELLIPTICITY")]],
+            ["elongation", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "ELONGATION")]],
+            ["erra_image", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "ERRA_IMAGE")]],
+            ["erra_world", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "ERRA_WORLD")]],
+            ["errb_image", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "ERRB_IMAGE")]],
+            ["errb_world", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "ERRB_WORLD")]],
+            ["errcxx_image", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "ERRCXX_IMAGE")]],
+            ["errcxx_world", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "ERRCXX_WORLD")]],
+            ["errcxy_image", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "ERRCXY_IMAGE")]],
+            ["errcxy_world", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "ERRCXY_WORLD")]],
+            ["errcyy_image", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "ERRCYY_IMAGE")]],
+            ["errcyy_world", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "ERRCYY_WORLD")]],
+            ["errtheta_b1950", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "ERRTHETA_B1950")]],
+            ["errtheta_image", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "ERRTHETA_IMAGE")]],
+            ["errtheta_j2000", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "ERRTHETA_J2000")]],
+            ["errtheta_sky", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "ERRTHETA_SKY")]],
+            ["errtheta_world", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "ERRTHETA_WORLD")]],
+            ["errx2_image", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "ERRX2_IMAGE")]],
+            ["errx2_world", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "ERRX2_WORLD")]],
+            ["errxy_image", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "ERRXY_IMAGE")]],
+            ["errxy_world", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "ERRXY_WORLD")]],
+            ["erry2_image", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "ERRY2_IMAGE")]],
+            ["erry2_world", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "ERRY2_WORLD")]],
+            ["flags", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "FLAGS")]],
+            ["fluxerr_aper", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "FLUXERR_APER")]],
+            ["fluxerr_auto", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "FLUXERR_AUTO")]],
+            ["fluxerr_best", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "FLUXERR_BEST")]],
+            ["fluxerr_iso", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "FLUXERR_ISO")]],
+            ["fluxerr_isocor", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "FLUXERR_ISOCOR")]],
+            ["flux_aper", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "FLUX_APER")]],
+            ["flux_auto", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "FLUX_AUTO")]],
+            ["flux_best", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "FLUX_BEST")]],
+            ["flux_iso", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "FLUX_ISO")]],
+            ["flux_isocor", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "FLUX_ISOCOR")]],
+            ["flux_max", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "FLUX_MAX")]],
+            ["fwhm_image", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "FWHM_IMAGE")]],
+            ["fwhm_world", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "FWHM_WORLD")]],
+            ["imaflags_iso", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "IMAFLAGS_ISO")]],
+            ["iso0", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "ISO0")]],
+            ["iso1", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "ISO1")]],
+            ["iso2", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "ISO2")]],
+            ["iso3", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "ISO3")]],
+            ["iso4", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "ISO4")]],
+            ["iso5", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "ISO5")]],
+            ["iso6", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "ISO6")]],
+            ["iso7", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "ISO7")]],
+            ["isoarea_image", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "ISOAREA_IMAGE")]],
+            ["isoarea_world", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "ISOAREA_WORLD")]],
+            ["kron_radius", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "KRON_RADIUS")]],
+            ["magerr_aper", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "MAGERR_APER")]],
+            ["magerr_auto", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "MAGERR_AUTO")]],
+            ["magerr_best", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "MAGERR_BEST")]],
+            ["magerr_iso", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "MAGERR_ISO")]],
+            ["magerr_isocor", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "MAGERR_ISOCOR")]],
+            ["mag_aper", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "MAG_APER")]],
+            ["mag_auto", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "MAG_AUTO")]],
+            ["mag_best", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "MAG_BEST")]],
+            ["mag_iso", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "MAG_ISO")]],
+            ["mag_isocor", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "MAG_ISOCOR")]],
+            ["mu_max", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "MU_MAX")]],
+            ["mu_threshold", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "MU_THRESHOLD")]],
+            ["nimaflags_iso", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "NIMAFLAGS_ISO")]],
+            ["number", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "NUMBER")]],
+            ["theta_b1950", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "THETA_B1950")]],
+            ["theta_image", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "THETA_IMAGE")]],
+            ["theta_j2000", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "THETA_J2000")]],
+            ["theta_sky", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "THETA_SKY")]],
+            ["theta_world", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "THETA_WORLD")]],
+            ["threshold", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "THRESHOLD")]],
+            ["vignet", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "VIGNET")]],
+            ["xmax_image", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "XMAX_IMAGE")]],
+            ["xmin_image", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "XMIN_IMAGE")]],
+            ["xy_image", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "XY_IMAGE")]],
+            ["xy_world", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "XY_WORLD")]],
+            ["ymax_image", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "YMAX_IMAGE")]],
+            ["ymin_image", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "YMIN_IMAGE")]],
+            ["a_image", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "a_IMAGE")]],
+            ["a_world", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "a_WORLD")]],
+            ["b_image", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "b_IMAGE")]],
+            ["b_world", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "b_WORLD")]],
+            ["params", ["SOAP::SOAPString", XSD::QName.new(nil, "params")]],
+            ["x2_image", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "x2_IMAGE")]],
+            ["x2_world", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "x2_WORLD")]],
+            ["x_image", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "x_IMAGE")]],
+            ["x_world", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "x_WORLD")]],
+            ["y2_image", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "y2_IMAGE")]],
+            ["y2_world", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "y2_WORLD")]],
+            ["y_image", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "y_IMAGE")]],
+            ["y_world", ["SOAP::SOAPBoolean", XSD::QName.new(nil, "y_WORLD")]]
+          ]
+        }
+      end
+
+      attr_accessor *soap_registration[:schema_element].collect{ |defn| defn.first }
+    end
+    
+    # Allows access to WESIX[http://nvogre.phyast.pitt.edu:8080/wesix/],
+    # a webservice interface to the standard astronomical image analysis package SExtractor
+    # together with a cross matching service using OpenSkyQuery[http://openskyquery.net/].
+    #
+    # Supposing the FITS file you're interested in is available via a URL, to run a
+    # source extraction with sensible defaults:
+    #
+    #  wesix = Service.new
+    #  votable = wesix.extract('http://nvogre.phyast.pitt.edu:8080/wesix/testr.fits')
+    #
+    # If it happens to be on disk, you can:
+    #
+    #   votable = wesix.extract(File.new('myfits.fits'))
+    #
+    # The returned object is a standard VOTable::V1_1::VOTable from which your sources can
+    # be extracted.
+    #
+    # Likewise, an extraction and crossmatch against the SDSS could be done in the following way:
+    #
+    #   votable = wesix.xmatch('http://nvogre.phyast.pitt.edu:8080/wesix/testr.fits')
+    #
+    # or if it's on disk:
+    #
+    #  votable = wesix.xmatch(File.new('myfits.fits'))
+    class Service
+      attr_reader :end_point
+      
+      # Convenience method for Service#extract.
+      #  votable = Service.extract('http://nvogre.phyast.pitt.edu:8080/wesix/testr.fits')
+      def self.extract(resource, transpose=false, *args)
+        wesix = Service.new
+        wesix.extract(resource, transpose, *args)
+      end
+      
+      # Convenience method for Service#xmatch.
+      #  votable = Service.xmatch('http://nvogre.phyast.pitt.edu:8080/wesix/testr.fits')
+      def self.xmatch(resource, transpose=false, *args)
+        wesix = Service.new
+        wesix.xmatch(resource, transpose, *args)
+      end
+      
+      # Create a new wesix service instance.
+      # Currently the only valid key in the <tt>options</tt> hash is <tt>:end_point</tt>
+      # representing the location of the WESIX soap service, and defaults to
+      # http://nvogre.phyast.pitt.edu:8080/axis/services/WesixTest.  Since at the moment this is
+      # the only existing instance of WESIX, you'll never need to specify it.
+      #
+      #   wesix = Wesix.new
+      def initialize(options={})
+        self.end_point = options[:end_point] || 'http://nvogre.phyast.pitt.edu:8080/axis/services/WesixTest'
+      end
+
+      # Set the locaton of the WESIX webservice.
+      # In practice, you'll never need to use this.
+      def end_point=(end_point)
+        @end_point = end_point
+
+        # Create the driver.
+        # We don't use the WSDL since we won't expose all possible methods.
+        @extractor = SOAP::RPC::Driver.new(self.end_point)
+        #@extractor.wiredump_dev = STDOUT
+        @extractor.return_response_as_xml = true  # in prep for dumping the result into a VORuby::VOTable
+        
+        # Map the appropriate objects.
+        map = SOAP::Mapping::Registry.new
+        map.register(Params.soap_registration)
+        map.register(OutputParams.soap_registration)
+        @extractor.mapping_registry = map
+        
+        # Define methods.
+        @extractor.add_method('wsextractor1VO', 'in0', 'in1')
+        @extractor.add_method('wsextractor1VOXmatch', 'in0', 'in1')
+        @extractor.add_method('wsextractorURL1VO', 'in0', 'in1')
+        @extractor.add_method('wsextractorURL1VOXmatch', 'in0', 'in1')
+        
+        @extractor.add_method('wsextractor2VO', 'in0', 'in1', 'in2')
+        @extractor.add_method('wsextractor2VOXmatch', 'in0', 'in1', 'in2')
+        @extractor.add_method('wsextractorURL2VO', 'in0', 'in1', 'in2')
+        @extractor.add_method('wsextractorURL2VOXmatch', 'in0', 'in1', 'in2')
+        
+        @extractor.add_method('wsextractor3VO', 'in0', 'in1', 'in2', 'in3')
+        @extractor.add_method('wsextractor3VOXmatch', 'in0', 'in1', 'in2', 'in3')
+        @extractor.add_method('wsextractorURL3VO', 'in0', 'in1', 'in2', 'in3')
+        @extractor.add_method('wsextractorURL3VOXmatch', 'in0', 'in1', 'in2', 'in3')
+      end
+      
+      # Perform a source extraction on the specified FITS file.
+      #
+      # <tt>resource</tt> is the FITS file in question.  It may be string representing a URL,
+      # a URI object or an object that responds to #read (such as a File).
+      #
+      # <tt>transpose</tt> is a boolean value indicating whether to transpose the image before SExtraction
+      # (sometimes necessary for SDSS images).
+      #
+      # The next two optional arguments are the parameters
+      # to be used by SExtractor to create the source catalog (as a Params object) and
+      # the measured parameters to be included in the output catalog (as an OutputParams object).
+      #
+      # A VOTable::V1_1::VOTable is returned.
+      #
+      # ===== Source extraction with defaults
+      #
+      #   wesix.extract('http://nvogre.phyast.pitt.edu:8080/wesix/testr.fits')  # from a URL
+      #   wesix.extract(URL.parse('http://nvogre.phyast.pitt.edu:8080/wesix/testr.fits'))  # this is the same as above
+      #   wesix.extract(File.new('../fits/my_file.fits'))  # from a local file
+      #
+      # ===== Source extraction with sextractor parameters defined
+      #
+      #   wesix.extract(
+      #     File.new('../fits/my_file.fits'),  # local file, pass a string or URI object if the FITS file is remote
+      #     false,  # no transposition
+      #     Params.new(:detect_thresh => 2.0, :analysis_thresh => 2.0)
+      #   )
+      #
+      # ===== Source extraction with sextractor parameters and measured parameters defined
+      #
+      #  wesix.extract(
+      #    File.new('../fits/my_file.fits'),  # local file, pass a string or URI object if the FITS file is remote
+      #    false,  # no transposition
+      #    Params.new(:detect_thresh => 2.0, :analysis_thresh => 2.0),
+      #    OutputParams.new(:flux_best => true, :fluxerr_best => true)
+      #  )
+      def extract(resource, transpose=false, *args)
+        if resource.is_a?(URI) or resource.is_a?(String)    # FITS file is on a remote machine
+          self.extract_from_url(resource.to_s, transpose, *args)
+        elsif resource.respond_to?(:read)  # FITS file is on a local machine, stored as a diskfile
+          self.extract_from_file(resource, transpose, *args)
+        else
+          raise ArgumentError, 'resource must be a URI, String or respond to a method called #read'
+        end
+      end
+      
+      # Alias for #extract_and_xmatch
+      def xmatch(resource, transpose=false, *args)
+        self.extract_and_xmatch(resource, transpose, *args)
+      end
+      
+      # Perform a source extraction followed by a crossmatch on the specified FITS file.
+      #
+      # <tt>resource</tt> is the FITS file in question.  It may be string representing a URL,
+      # a URI object or an object that responds to #read (such as a File).
+      #
+      # <tt>transpose</tt> is a boolean value indicating whether to transpose the image before SExtraction
+      # (sometimes necessary for SDSS images).
+      #
+      # The next two optional arguments are the parameters
+      # to be used by SExtractor to create the source catalog (as a Params object) and
+      # the measured parameters to be included in the output catalog (as an OutputParams object).
+      #
+      # A VOTable::V1_1::VOTable is returned.
+      #
+      # ===== Source extraction and crossmatch with defaults
+      #
+      #   wesix.extract_and_xmatch('http://nvogre.phyast.pitt.edu:8080/wesix/testr.fits')  # from a URL
+      #   wesix.extract_and_xmatch(URL.parse('http://nvogre.phyast.pitt.edu:8080/wesix/testr.fits'))  # this is the same as above
+      #   wesix.extract_and_xmatch(File.new('../fits/my_file.fits'))  # from a local file
+      #
+      # ===== Source extraction and crossmatch with sextractor parameters defined
+      #
+      #   wesix.extract_and_xmatch(
+      #     File.new('../fits/my_file.fits'),  # local file, pass a string or URI object if the FITS file is remote
+      #     false,  # no transposition
+      #     Params.new(:detect_thresh => 2.0, :analysis_thresh => 2.0)
+      #   )
+      #
+      # ===== Source extraction and crossmatch with sextractor parameters and measured parameters defined
+      #
+      #  wesix.extract_and_xmatch(
+      #    File.new('../fits/my_file.fits'),  # local file, pass a string or URI object if the FITS file is remote
+      #    false,  # no transposition
+      #    Params.new(:detect_thresh => 2.0, :analysis_thresh => 2.0),
+      #    OutputParams.new(:flux_best => true, :fluxerr_best => true)
+      #  )
+      def extract_and_xmatch(resource, transpose=false, *args)
+        if resource.is_a?(URI) or resource.is_a?(String)  # FITS file is on a remote machine
+          self.extract_and_xmatch_from_url(resource.to_s, transpose, *args)
+        elsif resource.respond_to?(:read)  # FITS file is on a local machine, stored as a diskfile
+          self.extract_and_xmatch_from_file(resource, transpose, *args)
+        else
+          raise ArgumentError, 'resource must be a URI, String or respond to a method called #read'
+        end
+      end
+      
+      # Perform a source extraction on a local FITS file.
+      # <tt>file</tt> is any object with a #read method (such as File).
+      # Otherwise exactly as #extract.
+      def extract_from_file(file, transpose=false, *args)
+        raise "resource does not respond to #read" if !file.respond_to?(:read)
+
+        file = SOAP::SOAPBase64.new(file.read)
+        file.type = XSD::QName.new('http://www.w3.org/2001/XMLSchema', 'base64Binary')
+        transpose = transpose ? 1 : 0
+        
+        response = case args.size
+          when 0      then @extractor.wsextractor1VO(file, transpose)  # basic
+          when 1      then @extractor.wsextractor2VO(file, args.first, transpose)   # input params specified
+          when 2      then @extractor.wsextractor3VO(file, args.first, args.last, transpose) # input params/output flags specified
+          else
+            raise ArgumentError, "wrong number of optional arguments: #{args.size} > 2"
+        end
+        
+        vot_node = XML::Parser.string(response).parse.root.find_first("//*[local-name()='VOTABLE']")
+        VORuby::VOTable.from_xml(vot_node)
+      end
+      
+      # Perform a source extraction and crossmatch on a local FITS file.
+      # <tt>file</tt> is any object with a #read method (such as File).
+      # Otherwise exactly as #extract_and_xmatch.
+      def extract_and_xmatch_from_file(file, transpose=false, *args)
+        raise "resource does not respond to #read" if !file.respond_to?(:read)
+        
+        file = SOAP::SOAPBase64.new(file.read)
+        file.type = XSD::QName.new('http://www.w3.org/2001/XMLSchema', 'base64Binary')
+        transpose = transpose ? 1 : 0
+        
+        response = case args.size
+          when 0      then @extractor.wsextractor1VOXmatch(file, transpose)  # basic
+          when 1      then @extractor.wsextractor2VOXmatch(file, args.first, transpose)   # input params specified
+          when 2      then @extractor.wsextractor3VOXmatch(file, args.first, args.last, transpose) # input params/output flags specified
+          else
+            raise ArgumentError, "wrong number of optional arguments: #{args.size} > 2"
+        end
+        
+        vot_node = XML::Parser.string(response).parse.root.find_first("//*[local-name()='VOTABLE']")
+        VORuby::VOTable.from_xml(vot_node)
+      end
+
+      # Perform a source extraction on a remotely accessible FITS file.
+      # <tt>url</tt> may be a string or a URI object.  Otherwise exactly as for #extract.
+      def extract_from_url(url, transpose=false, *args)
+        transpose = transpose ? 1 : 0
+        
+        response = case args.size
+          when 0      then @extractor.wsextractorURL1VO(url.to_s, transpose)  # basic
+          when 1      then @extractor.wsextractorURL2VO(url.to_s, args.first, transpose)   # input params specified
+          when 2      then @extractor.wsextractorURL3VO(url.to_s, args.first, args.last, transpose) # input params/output flags specified
+          else
+            raise ArgumentError, "wrong number of optional arguments: #{args.size} > 2"
+        end
+        
+        vot_node = XML::Parser.string(response).parse.root.find_first("//*[local-name()='VOTABLE']")
+        VORuby::VOTable.from_xml(vot_node)
+      end
+      
+      # Perform a source extraction and crossmatch on a remotely accessible FITS file.
+      # <tt>url</tt> may be a string or a URI object.  Otherwise exactly as for #extract_and_xmatch.
+      def extract_and_xmatch_from_url(url, transpose=false, *args)
+        transpose = transpose ? 1 : 0
+        
+        response = case args.size
+          when 0      then @extractor.wsextractorURL1VOXmatch(url.to_s, transpose)  # basic
+          when 1      then @extractor.wsextractorURL2VOXmatch(url.to_s, args.first, transpose)   # input params specified
+          when 2      then @extractor.wsextractorURL3VOXmatch(url.to_s, args.first, args.last, transpose) # input params/output flags specified
+          else
+            raise ArgumentError, "wrong number of optional arguments: #{args.size} > 2"
+        end
+        
+        vot_node = XML::Parser.string(response).parse.root.find_first("//*[local-name()='VOTABLE']")
+        VORuby::VOTable.from_xml(vot_node)
+      end
+    end
+    
+  end
+end