rfits 0.0.1

data/lib/rfits/rfits.rb

@@ -0,0 +1,1328 @@
+require 'ftools'
+require 'ostruct'
+require 'csv'
+
+# RFits is a library for parsing the Flexible Image Transport System (FITS) files widely used in astronomy.
+#
+# ==== Installing
+#
+# RFits requires the C library CFITSIO (http://heasarc.gsfc.nasa.gov/docs/software/fitsio/fitsio.html)
+# to be installed.  In most cases this is as simple as:
+#
+#  > tar zxvf cfitsioxxxx.tar.gz
+#  > cd cfitsio
+#  > ./configure
+#  > make shared
+#  > sudo make install
+#
+# You can then install via rubygems in the usual way:
+#
+#  > gem install rfits
+#
+# ==== Using
+#
+#  require 'rubygems'
+#  require 'rfits'
+#
+#  RFits::File.open('m31.fits', 'rw') do |fits|  # m31.fits exists
+#    # first extension is an image
+#    img = fits[0]
+#    
+#    # retrieve/write header values using hash syntax
+#    header = img.header
+#    puts header['TELESCOP']     #=> 'KPNO 4.0 meter telescope'
+#    puts header['TELEQUIN']     #=> 2000.0
+#    puts header['SIMPLE']       #=> true
+#    puts header['TELFOCUS']     #=> -9998
+#    header['MY_HDR1'] = 'A nice value'
+#    header['MY_HDR2'] = 10
+#    header['MY_HDR3'] = 9.1
+#    header['MY_HDR4'] = Complex.new(4, 1)  # yes, you can do this
+#
+#    # retrieve/write pixel values using array syntax
+#    pixels = img.data
+#    first_pixel = pixels[0]                  # the first pixel
+#    pixel_list = pixels[0..10]               # pixels 0 through 10 as an array
+#    pixel_list = pixels[[0, 0], [10, 10]]    # pixels between the points [0, 0] and [10, 10]
+#    pixels[10] = 5                           # the ninth pixel value is set to 5
+#    pixels[3..7] = [1, 4, 2, 8]              # pixels 3 through 7 are set
+#
+#    # second extension is a binary table
+#    tbl = fits[1]
+#
+#    # access a table using array syntax
+#    data = tbl.data
+#    row = data[0]                                    # first row as a hetergeneous array
+#    col = data.column(2)                             # third column
+#    data[1] = [1, 1.2, 'blah', Complex.new(1, 1)]    # second row is set
+#    data.set_column(1, [1.3, 4.5, 7.8, 2.2])         # the second column is set
+#    col << [1, 1.2, 'blah', Complex.new(1, 1)]       # append a row
+#
+#    # you can find out things about the table columns
+#    metadata = tbl.column_information
+#    puts metadata[0].data_type   #=> :short
+#    puts metadata[0].name        #=> 'catalog_id'
+#
+#    # and add new ones
+#    metadata << {:name => 'new_column1', :format => 'A10'}  # append a new string column
+#    metadata[3] = {:name => 'new_column2', :format => 'I'}  # insert an integer column as the 4th column
+#  end
+module RFits
+  require 'rfits/ext/rfitsio'
+  
+  # A class representing a FITS file.
+  class File
+    include Enumerable
+  
+    attr_reader :io
+    
+    # Open an existing FITS file or create a new one.  The mode parameter
+    # may be on of:
+    # * r   opens a file for reading. If it doesn't exist, it creates it.
+    # * rw  opens afile for reading and writing. If it doesn't exist, it creates it.
+    # * rw+ opens a file for reading and writing. If it exists, it truncates it.
+    #
+    #  fits = RFits::File.new('m31.fits', 'rw')  # this is probably what you want
+    def initialize(path, mode="rw")
+      iomode = mode.match('w') ? IO::Proxy::READWRITE : IO::Proxy::READONLY
+      truncate = mode.match('\+') ? true : false
+      
+      if truncate and mode.match('w')
+        @io = IO::Proxy::fits_create_file("!#{path}")
+      else
+        @io = ::File.exists?(path) ? IO::Proxy.fits_open_file(path, iomode) : IO::Proxy::fits_create_file(path)
+      end
+    end
+    
+    # Works as RFits::File#new but accepts a block.  The FITS file is automatically
+    # closed after execution of the block.
+    #
+    #  RFits::File.open('m31.fits', 'rw') do |fits|
+    #    # do things to the FITS file, fits.close gets called  automatically
+    #  end
+    def self.open(path, mode="rw")
+      fits = File.new(path, mode)
+      if block_given?
+        yield fits
+        fits.close
+      else
+        fits
+      end
+    end
+    
+    # Close the FITS file.
+    #  file.close()
+    def close
+      IO::Proxy::fits_close_file(self.io)
+    end
+    
+    # The filesystem path to the FITS file.
+    #  puts file.path   # m31.fits
+    def path
+      IO::Proxy::fits_file_name(self.io)
+    end
+    
+    # The IO mode of the FITS file (i.e. IO::Proxy::READWRITE or IO::Proxy::READONLY)
+    #  puts file.mode   # 1 = IO::Proxy::READWRITE
+    def mode
+      IO::Proxy.fits_file_mode(self.io)
+    end
+    
+    # The type of URL of the FITS file (i.e. file:// or ftp://).
+    #  puts file.url_type   # file://
+    def url_type
+      IO::Proxy.fits_url_type(self.io)
+    end
+    
+    # Get the specified HDU associated with the FITS file.  Contrary
+    # to FITS conventions this is *zero-based* access.  So:
+    #  primary_hdu = fits[0]  # primary array
+    #  hdu = fits[2]  # third HDU
+    def [](extpos)
+      extpos = extpos < 0 ? (self.length + extpos) : extpos
+      
+      set_position(extpos)
+      hdu = case IO::Proxy.fits_get_hdu_type(self.io)
+        when IO::Proxy::IMAGE_HDU         then  Image.new(self, extpos, nil, nil)
+        when IO::Proxy::ASCII_TBL         then  AsciiTable.new(self, extpos, nil, nil)
+        when IO::Proxy::BINARY_TBL        then  BinaryTable.new(self, extpos, nil, nil)
+        else  HDU.new(self, extpos)
+      end
+      
+      hdu
+    end
+    
+    # Get the last HDU in the file.
+    def last
+      self[-1]
+    end
+    
+    # Get the first HDU in the file.
+    def first
+      self[0]
+    end
+    
+    # Iterates through each HDU in the FITS file.
+    #  fits.each do |hdu|
+    #    # do something...
+    #  end
+    def each
+      (0...self.length).each do |i|
+        yield self[i]
+      end
+    end
+    
+    # The number of HDUs in the FITS file.
+    def length
+      IO::Proxy.fits_get_num_hdus(self.io)
+    end
+    
+    # Delete the HDU at the specified position.  Again, this is
+    # zero-based access.
+    #  fits.delete_at(2)  # delete the third HDU
+    def delete_at(extpos)
+      set_position(extpos)
+      Proxy.fits_delete_hdu(self.io)
+    end
+    
+    # Delete the specified HDU.
+    #  fits.delete(hdu)
+    def delete(hdu)
+      delete_at(hdu.position)
+    end
+    
+    # Append a new HDU to the file.
+    #  fits << RFits::Image.new(@fits, nil, RFits::IO::Proxy::LONG_IMG, [4, 4])  # notice you can leave the position nil
+    def <<(hdu, *args)
+      hdu.create(self.length, *args)
+    end
+    
+    # Insert a new HDU at the specified position.
+    #  fits[1] = RFits::Image.new(@fits, nil, RFits::IO::Proxy::LONG_IMG, [2, 3])  # the old hdu at pos 1 gets pushed down
+    def []=(pos, *args)
+      hdu = args[0]
+      hdu.create(pos, *args[1..-1])
+    end
+    
+    def set_position(extpos) #:nodoc:
+      IO::Proxy.fits_movabs_hdu(self.io, extpos + 1)
+    end
+  end
+  
+  # Represents the header keyword information of an HDU.  Behaves
+  # much like a hash.
+  class Header
+    include Enumerable
+    
+    # The HDU associated with the header.
+    attr_reader :hdu
+    
+    # Initialize the header.  This doesn't actually write bytes to file--use Header#create for that.
+    #  header = Header.new(hdu)
+    def initialize(hdu)
+      @hdu = hdu
+    end
+    
+    # Retrieve the value of the specified keyword.
+    # If _include_comment_ is true, the returned value will be a two-element
+    # array with the value as the first element, and the comment as the second.
+    # The return type of the value will be determined automatically--this is
+    # almost always what you want.  However, if necessary, you may specify the type using _as_,
+    # which may be one of: "C" (string), "L" (logical), "I" (integer), "F" (float) or "C" (complex)
+    # and the library will try to do the right thing.
+    #
+    #  puts header['OBJNAME']             # M31
+    #  puts header['OBJNAME', true]       # ['M31', 'The name of the object']
+    #  puts header['BITPIX']              # 8
+    #  puts header['BITPIX', false, 'F']  # 8.0
+    def [](keyname, include_comment=false, as=nil)
+      self.hdu.reset_position()
+      IO::Proxy.fits_read_keyn(self.hdu.file.io, 0)
+     
+      begin
+        keytype = as ? as : IO::Proxy.fits_get_keytype(IO::Proxy.fits_read_keyword(self.hdu.file.io, keyname).first) rescue IO::Exception
+        key = case keytype
+          when 'C'          then IO::Proxy.fits_read_key(self.hdu.file.io, IO::Proxy::TSTRING, keyname)
+          when 'L'          then IO::Proxy.fits_read_key(self.hdu.file.io, IO::Proxy::TLOGICAL, keyname)
+          when 'I'          then IO::Proxy.fits_read_key(self.hdu.file.io, IO::Proxy::TLONG, keyname)
+          when 'F'          then IO::Proxy.fits_read_key(self.hdu.file.io, IO::Proxy::TDOUBLE, keyname)
+          when 'X'          then IO::Proxy.fits_read_key(self.hdu.file.io, IO::Proxy::TDBLCOMPLEX, keyname)
+          else  IO::Proxy.fits_read_key(self.hdu.file.io, IO::Proxy::TSTRING, keyname)
+        end
+        include_comment ? key : key.first
+      rescue IO::Exception
+        nil
+      end
+    end
+    
+    # Set the value of the keyword.  If _keyvalue_ is an array, the first
+    # element of that array is assumed to be the value, and the second the
+    # comment.  The value may be a: String, boolean, Fixnum, Float or Complex
+    # object.  Anything else will be serialized using it's to_s method and
+    # saved as a string.
+    #
+    #  header['TEST1'] = 123                    # set keyword value to 123
+    #  header['TEST1'] = [123, 'a test integer'] # set keyword value to 123 with "a test integer" as the comment
+    def []=(keyname, keyvalue)
+      self.hdu.reset_position()
+      
+      value, comment = keyvalue.is_a?(Array) ? keyvalue : [keyvalue, nil]
+      
+      dtype = case value
+        when String     then IO::Proxy::TSTRING
+        when TrueClass  then IO::Proxy::TLOGICAL
+        when FalseClass then IO::Proxy::TLOGICAL
+        when Fixnum     then IO::Proxy::TLONG
+        when Float      then IO::Proxy::TDOUBLE
+        when Complex    then IO::Proxy::TDBLCOMPLEX
+        else
+          value = value.to_s
+          IO::Proxy::TSTRING
+      end
+
+      IO::Proxy.fits_update_key(self.hdu.file.io, dtype, keyname, value, comment)
+    end
+    
+    # Iterate through each keyword pair in the header.  By default,
+    # values will be converted to their appropriate types, but this can
+    # be overridden by setting _typecast_ to false.  Additionally,
+    # COMMENT and HISTORY keywords are ignored unless _comment_keywords_
+    # is set to true.
+    #
+    #   header.each do |name, value, comment|
+    #    puts "#{name} = #{value}"
+    #   end
+    def each(typecast=true, comment_keywords=false)
+      self.hdu.reset_position()
+      
+      (1..self.length).each do |i|
+        keyname = value = comment = nil
+        if typecast
+          keyname = IO::Proxy.fits_read_keyn(self.hdu.file.io, i).first
+          value, comment = self[keyname, true]
+        else
+          keyname, value, comment = IO::Proxy.fits_read_keyn(self.hdu.file.io, i)
+        end
+        
+        yield(keyname, value, comment) unless (keyname == "COMMENT" or keyname == "HISTORY") and !comment_keywords
+      end
+    end
+    
+    # Delete the specified keyword.
+    #  header.delete('OBJNAME')
+    def delete(keyname)
+      self.hdu.reset_position()
+      IO::Proxy.fits_delete_key(self.hdu.file.io, keyname)
+    end
+    
+    # The number of keyword pairs in the header.
+    #  puts header.length   # 62
+    def length
+      self.hdu.reset_position()
+      IO::Proxy.fits_get_hdrspace(self.hdu.file.io).first
+    end
+    
+    # Retrieve COMMENT keywords as a string.
+    #  puts header.comments   # This file is part of the EUVE Science Archive. It contains...        
+    def comment
+      self.hdu.reset_position()
+      
+      statements = []
+      self.each(false, true) do |keyname, keyvalue, keycomment|
+        statements << keycomment.strip.gsub(/^\'/, '').gsub(/\'$/, '') if keyname == 'COMMENT'
+      end
+      
+      statements.join("\n")
+    end
+    
+    # Append a COMMENT keyword.
+    #  header.comment = "My comment"
+    def comment=(comment)
+      self.hdu.reset_position()
+      IO::Proxy.fits_write_comment(self.hdu.file.io, comment)
+    end
+    
+    # Retrieve HISTORY keywords as a strong.
+    #  puts header.history
+    def history
+      self.hdu.reset_position()
+      
+      statements = []
+      self.each(false, true) do |keyname, keyvalue, keycomment|
+        statements << keycomment.strip.gsub(/^\'/, '').gsub(/\'$/, '') if keyname == 'HISTORY'
+      end
+      
+      statements.join("\n")
+    end
+    
+    # Append a HISTORY comment.
+    #  header.history = "My history"
+    def history=(history)
+      self.hdu.reset_position()
+      IO::Proxy.fits_write_history(self.hdu.file.io, history)
+    end
+    
+    # Convert the header to a string.
+    def to_s
+      self.hdu.reset_position()
+      IO::Proxy.fits_hdr2str(self.hdu.file.io, false, [], 0)
+    end
+  end
+  
+  # Represents the actual pixels in a FITS file.
+  class ImageData
+    include Enumerable
+    
+    BITPIX_IMG_MAP = {
+      IO::Proxy::BYTE_IMG => IO::Proxy::TBYTE,
+      IO::Proxy::SHORT_IMG => IO::Proxy::TSHORT,
+      IO::Proxy::LONG_IMG => IO::Proxy::TLONG,
+      IO::Proxy::LONGLONG_IMG => IO::Proxy::TLONGLONG,
+      IO::Proxy::FLOAT_IMG => IO::Proxy::TFLOAT,
+      IO::Proxy::DOUBLE_IMG => IO::Proxy::TDOUBLE,
+      IO::Proxy::SBYTE_IMG => IO::Proxy::TSBYTE,
+      IO::Proxy::USHORT_IMG => IO::Proxy::TUSHORT,
+      IO::Proxy::ULONG_IMG => IO::Proxy::TULONG
+    }
+    
+    # The image the data belongs to.
+    attr_reader :image
+    
+    # Create an ImageData object associated with the specified image.
+    def initialize(image)
+      @image = image
+    end
+    
+    # An alias for ImageData#pixels, but automatically chooses the
+    # datatype for you based on the type of image (i.e. BITPIX).
+    def [](*args)
+      self.pixels(BITPIX_IMG_MAP[self.image.bitpix], *args)
+    end
+    
+    # An alias for ImageData#set_pixels, but automatically chooses the
+    # datatype for you based on the type of image (i.e. BITPIX).
+    def []=(*args)
+      self.set_pixels(BITPIX_IMG_MAP[self.image.bitpix], *args)
+    end
+    
+    # Retrieve the value of a pixel, or a range of pixels.  The value
+    # is coerced into an appropriate class according to the datatype provided.
+    # Can be used in a number of ways.  The simplest plucks the nth pixel from the image array:
+    #
+    #  image.data.pixels(IO::Proxy::TSHORT, 0)  # first pixel in the image (remember zero-based indexing?)
+    #  image.data.pixels(IO::Proxy::TSHORT, image.data[image.data.size - 1])  # last pixel in the image
+    #
+    # You can also choose a range of contiguous pixels, in which case an array of values is returned:
+    # 
+    #  image.data.pixels(IO::Proxy::TSHORT, 0..10)  # retrieve first 10 pixels
+    #
+    # or pick the single pixel at a particular coordinate:
+    # 
+    #  image.data.pixels(IO::Proxy::TSHORT, 4, 5)
+    #
+    # or equivalently:
+    #
+    #  image.data.pixels(IO::Proxy::TSHORT, [4, 5])
+    #
+    # In addition, you can give an (x,y) coordinate and a number of pixels, assuming the coordinates are zero-based:
+    #
+    #  image.data.pixels(IO::Proxy::TSHORT, [4, 5], 10)  # 10 pixels starting at the point [4, 5]
+    #
+    # or get all the pixels between two points:
+    #
+    #  image.data.pixels(IO::Proxy::TSHORT, [4, 5], [6, 6]) # all the pixels between the points [4, 5] and [6, 6]
+    def pixels(datatype, *args)
+      self.image.reset_position()
+      
+      pixnum = nelem = nil
+      pixel_values = case args.size
+        when 1  # 1 argument
+          if args.first.is_a?(Range) # a range of pixels
+            pixnum = args.first.first.to_i < 0 ? self.length + args.first.first.to_i : args.first.first.to_i + 1
+            nelem = args.first.exclude_end? ?
+              args.first.last.to_i - args.first.first.to_i + 1:
+              args.first.last.to_i - args.first.first.to_i
+          elsif args.first.is_a?(Fixnum) # the nth pixel
+            pixnum = args.first.to_i < 0 ? self.length + args.first.to_i : args.first.to_i + 1
+            nelem = 1
+          elsif args.first.is_a?(Array) # array representing single pixel
+            return(IO::Proxy.fits_read_pix(self.image.file.io, datatype, args.first.collect{ |c| c + 1 }, 1, nil).first.first)
+          else
+            raise ArgumentError, "Argument should be an integer, an integer range, or an array of integers."
+          end
+
+          IO::Proxy.fits_read_img(self.image.file.io, datatype, pixnum, nelem, nil).first
+        when 2 # 2 arguments
+          if args.first.is_a?(Fixnum) and args.last.is_a?(Fixnum) # the pixel at the coordinate
+            IO::Proxy.fits_read_pix(self.image.file.io, datatype, [args.first.to_i+1, args.last.to_i+1], 1, nil).first
+          elsif args.first.is_a?(Array) and args.last.is_a?(Fixnum) # a starting coordinate + some number of pixels
+            fpixel = args.first.collect{ |p| p + 1 }
+            IO::Proxy.fits_read_pix(self.image.file.io, datatype, fpixel, args.last.to_i, nil).first
+          elsif args.first.is_a?(Array) and args.last.is_a?(Array) # a starting coordinate + ending coordinate
+            fpixel = args.first.collect{ |p| p + 1 }
+            lpixel = args.last.collect{ |p| p + 1 }
+            IO::Proxy.fits_read_subset(self.image.file.io, datatype, fpixel, lpixel, args.first.collect{ |dim| 1 }, nil).first
+          else
+            raise ArgumentError, "Arguments should be two fixnums, an array and a fixnum, or two arrays."
+          end
+        else
+          raise ArgumentError, "Arguments should be an integer, an integer range, an array of integers, two fixnums, an array and a fixnum, or two arrays."
+      end
+
+      pixel_values.size == 1 ? pixel_values.first : pixel_values
+    end
+    
+    # Set the value of a pixel, or a range of pixels.  The value
+    # is coerced into an appropriate class according to the datatype provided.
+    # Can be used in a number of ways.  The simplest sets the nth pixel in the image array:
+    #
+    #  image.data.set_pixels(IO::Proxy::TSHORT, 0, 5)  # first pixel in the image is set to 5
+    #
+    # You can also set a range of contiguous pixels:
+    # 
+    #  image.data.set_pixels(IO::Proxy::TSHORT, 0..10, [5, 5, 3, 1, 0, 9, 5, 6, 7, 1])  # set first 10 pixels
+    #
+    # or set the single pixel at a particular coordinate:
+    # 
+    #  image.data.set_pixels(IO::Proxy::TSHORT, 4, 5, 10) # set pixel at [4, 5] to 10
+    #
+    # or equivalently:
+    #
+    #  image.data.set_pixels(IO::Proxy::TSHORT, [4, 5], 10)
+    #
+    # In addition, you can give an (x,y) coordinate and a list of pixels, assuming the coordinates are zero-based:
+    #
+    #  image.data.set_pixels(IO::Proxy::TSHORT, [4, 5], [1, 2, 3, 4])  # four pixels with values 1, 2, 3, 4 starting at [4, 5]
+    #
+    # or set the pixels between two points:
+    #
+    #  image.data.set_pixels(IO::Proxy::TSHORT, [0, 0], [1, 1], [5, 6, 7, 8]) # set pixels to (5, 6, 7, 8) between [0, 0] and [1, 1]
+    def set_pixels(datatype, *args)
+      self.image.reset_position()
+      
+      val = args.last.is_a?(Array) ? args.last : [args.last]
+      case args.size
+        when 2
+          if args.first.is_a?(Fixnum)
+            pixnum = args.first.to_i < 0 ? self.length + args.first.to_i : args.first.to_i + 1
+            IO::Proxy.fits_write_img(self.image.file.io, datatype, pixnum, val.size, val)
+          elsif args.first.is_a?(Range)
+            pixnum = args.first.first.to_i < 0 ? self.length + args.first.first.to_i : args.first.first.to_i + 1
+            nelem = args.first.exclude_end? ?
+              args.first.last.to_i - args.first.first.to_i + 1:
+              args.first.last.to_i - args.first.first.to_i
+            IO::Proxy.fits_write_img(self.image.file.io, datatype, pixnum, nelem, val)
+          elsif(args.first.is_a?(Array))
+            IO::Proxy.fits_write_pixnull(self.image.file.io, datatype, args.first.collect{ |c| c + 1 }, val.size, val, nil)
+          else
+            raise ArgumentError, "Selector should be an integer, an integer range, or an array of integers."
+          end
+        when 3
+          if args.first.is_a?(Fixnum) and args[-2].is_a?(Fixnum)
+            IO::Proxy.fits_write_pixnull(self.image.file.io, datatype, args[0..-2].collect{ |c| c + 1 }, val.size, val, nil)
+          elsif args.first.is_a?(Array) and args[-2].is_a?(Fixnum)
+            IO::Proxy.fits_write_pixnull(self.image.file.io, datatype, args.first.collect{ |c| c + 1 }, args[-2], val, nil)
+          elsif args.first.is_a?(Array) and args[-2].is_a?(Array)
+            IO::Proxy.fits_write_subset(self.image.file.io, datatype,
+              args.first.collect{ |c| c + 1 }, args[1].collect{ |c| c + 1 },
+              val)
+          else
+            raise ArgumentError, "Selectors should be two fixnums, an array and a fixnum, or two arrays."
+          end
+        else
+          raise ArgumentError, "Selectors should be an integer, an integer range, an array of integers, two fixnums, an array and a fixnum, or two arrays."
+      end
+    end
+    
+    # The number of pixels in the image array.
+    def length
+      self.image.naxes.inject(1){ |product, n| product *= n }
+    end
+    
+    # Iterate through each pixel in the array.
+    def each
+      (0...self.length).each do |i|
+        yield self[i]
+      end
+    end
+    
+    # Retrieve the ith (where i is zero-based) row of the image array.
+    # Assumes a two-dimensional image.
+    def row(i)
+      self[[0, i], self.image.naxes.first]
+    end
+    
+    # Set the ith row of a 2D image to the specified pixels.
+    def set_row(i, vals)
+      self[[0, i], self.image.naxes.first] = vals
+    end
+    
+    # Iterate through each row of pixels in the array.
+    # Assumes a two-dimensional image.
+    def each_row
+      (0...self.image.naxes.last).each do |i|
+        yield(self.row(i), i)
+      end
+    end
+    
+    # Retrieve the ith (where i is zero-based) column of the image array.
+    # Assumes a two-dimensional image.
+    def column(i)
+      pixel_list = []
+      (0...self.image.naxes.first).each do |row|
+        pixel_list << self[i, row]
+      end
+      
+      pixel_list
+    end
+    
+    # Set the ith column of a 2D image to the specified pixels.
+    def set_column(i, vals)
+      (0...self.image.naxes.first).each do |row|
+        self[i, row] = vals[row]
+      end
+    end
+    
+    # Iterate through each column of pixels in the array.
+    # Assumes a two-dimensional image.
+    def each_column
+      (0...self.image.naxes.last).each do |i|
+        yield(self.column(i), i)
+      end
+    end
+    
+    # The first pixel in the image array.
+    def first
+      self[0]
+    end
+    
+    # The last pixel in the image array.
+    def last
+      self[self.length - 1]
+    end
+  end
+  
+  # Represents tabular data in a FITS file.
+  class TableData
+    include Enumerable
+    
+    # The table the data lives in.
+    attr_reader :table
+    
+    # Create a TableData object that is associated with the specifed table.
+    #  data = TableData.new(table)
+    def initialize(table)
+      @table = table
+    end
+    
+    # Set the ith columns to the specified values.
+    #  data.set_column(2, [1, 2, 3, 4, 5])  # set the 3rd column (which is an integer column)
+    def set_column(i, values)
+      self.table.reset_position
+      
+      IO::Proxy.fits_write_colnull(self.table.file.io,
+        self.table.column_information[i].data_type(true), i+1, 1, 1, values.size,
+        values, nil)
+    end
+    
+    # Retrieve the ith column.
+    #  data.column(2)  # [1, 2, 3, 4, 5]
+    def column(i)
+      self.table.reset_position
+      
+      IO::Proxy.fits_read_col(self.table.file.io,
+        self.table.column_information[i].data_type(true), i+1, 1, 1, self.size, nil).first
+    end
+    
+    # Retrieve the ith row of data.
+    #  data[2]  # ['a1', 1.1, 3, Complex.new(3, 4)]
+    # or the value of the cell at the specified row and column.
+    #  data[2, 3] # Complex.new(3, 4)  # the 4th cell in the 3rd row
+    def [](*args)
+      self.table.reset_position
+      
+      result = case args.length
+        when 1 # retrieve the whole row
+          row = []
+          (0...self.table.column_information.size).each do |col|
+            row << IO::Proxy.fits_read_col(self.table.file.io,
+              self.table.column_information[col].data_type(true),
+              col+1, (args.first.to_i+1), 1, 1, nil).first.first
+          end
+          row
+        when 2 # retrieve the value of the cell
+          IO::Proxy.fits_read_col(self.table.file.io,
+            self.table.column_information[args.last].data_type(true),
+            (args.last.to_i)+1, (args.first.to_i)+1, 1, 1, nil).first.first
+        else
+          raise ArgumentError, "Selector should be an integer indicating the row, or two integers indicating the row and column."
+      end
+      
+      result
+    end
+    
+    # Alias for TableData#[]
+    def row(i)
+      self[i]
+    end
+    
+    # Set the ith row to the specified values
+    #  data[4] = ['new', 2.2, 7, Complex.new(5, 5)]
+    # or specify the value of a particular cell
+    #  data[4, 1] = 2.2  # the second column of the 5th row
+    def []=(*args)
+      self.table.reset_position
+      
+      i = args.first
+      
+      case args.length
+        when 2
+          values = args[1..-1].first
+          
+          (0...values.size).each do |col|
+            IO::Proxy.fits_write_colnull(self.table.file.io,
+              self.table.column_information[col].data_type(true), col+1, i+1, 1, 1,
+              [values[col]], nil)
+          end
+        when 3
+          col = args[1]
+          values = args[2..-1]
+          
+          IO::Proxy.fits_write_colnull(self.table.file.io,
+            self.table.column_information[col].data_type(true), col+1, i+1, 1, 1,
+            values, nil)
+        else
+          raise ArgumentError, "Selector should be an integer indicating the row, or two integers indicating the row and column."
+      end
+    end
+    
+    # Append a new row.
+    #  data << ['new', 2.2, 7, Complex.new(5, 5)]
+    def <<(values)
+      self[self.size] = values
+    end
+    
+    # Alias for TableData#[]=
+    def set_row(i, values)
+      self[i] = values
+    end
+  
+    # The number of rows in the table.
+    #  table.length  # 5
+    def length
+      self.table.reset_position
+      IO::Proxy.fits_get_num_rows(self.table.file.io)
+    end
+    
+    # Alias for TableData#length
+    def size
+      self.length
+    end
+    
+    # Delete the ith row.
+    #  table.delete(2)  # delete the 3rd row
+    def delete(i)
+      self.table.reset_position
+      IO::Proxy.fits_delete_rows(self.table.file.io, i+1, 1)
+    end
+    
+    # Alias for TableData#each.
+    def each_row
+      self.each do |row|
+        yield row
+      end
+    end
+    
+    # Iterate through each row in the table.
+    def each
+      self.table.reset_position
+      
+      (0...self.size).each do |i|
+        yield self[i]
+      end
+    end
+    
+    # Iterate through each column in the table.
+    def each_column
+      (0...self.table.column_information.size).each do |i|
+        yield self.column(i)
+      end
+    end
+    
+    # Retrieve the first row in the table.
+    #  table.first  # ['blah', 23.1, 9, Complex.new(4, 5)]
+    def first
+      self[0]
+    end
+    
+    # Retrieve the last row in the table.
+    #  table.last  # ['new', 2.2, 7, Complex.new(5, 5)]
+    def last
+      self[self.size - 1]
+    end
+    
+    # Convert the rows to a string.  Currently an alias to TableData#to_csv
+    def to_s
+      self.to_csv
+    end
+    
+    # Convert the rows in the table to CSV.
+    def to_csv
+      buffer = ''
+
+      self.each_row do |row|
+        CSV.generate_row(row.collect{ |cell| cell.to_s }, row.size, buffer)
+      end
+      
+      buffer
+    end
+  end
+  
+  # The base class for all HDUs.  It's possible to use this on its
+  # own, but really it's intended to be abstract.
+  class HDU
+    HDU_TYPE_MAP = {
+      IO::Proxy::IMAGE_HDU => :image,
+      IO::Proxy::ASCII_TBL => :ascii_tbl,
+      IO::Proxy::BINARY_TBL => :binary_tbl,
+      IO::Proxy::ANY_HDU => :other
+    }
+    
+    # The file object associated with the HDU.
+    attr_reader :file
+    
+    # The header associated with the HDU.
+    attr_reader :header
+    
+    # The data associated with the HDU.
+    attr_reader :data
+    
+    # Initialize a new HDU in the specified file at the specified position (zero-based).
+    # This doesn't actually write bytes to file--use HDU#create for that.
+    #  fits = File.open('m31.fits', 'rw') do |f|
+    #    hdu = HDU.new(f, 2)
+    #  end
+    def initialize(file, extpos)
+      @file = file
+      @extpos = extpos
+      
+      @header = Header.new(self)
+      @data = ImageData.new(self)
+    end
+    
+    # Get the type of HDU.  Possibilities are: :image, :ascii_tbl, :binary_tbl, :other
+    def hdu_type
+      reset_position()
+      HDU_TYPE_MAP[IO::Proxy.fits_get_hdu_type(self.file.io)] || :unknown
+    end
+    
+    # Get the position of the HDU.
+    #  puts hdu.position   # 2 -> this is the third HDU in the file
+    def position
+      reset_position()
+      IO::Proxy.fits_get_hdu_num(self.file.io) - 1
+    end
+    
+    def reset_position
+      IO::Proxy.fits_movabs_hdu(self.file.io, @extpos + 1)
+    end
+  end
+  
+  # A set of routines for setting and retrieving compression characterstics.
+  module Compressible
+    COMPRESSION_TYPE_MAP = {
+      IO::Proxy::RICE_1 => :rice,
+      IO::Proxy::GZIP_1 => :gzip,
+      IO::Proxy::PLIO_1 => :plio,
+      IO::Proxy::HCOMPRESS_1 => :hcompress
+    }
+     
+    COMPRESSION_DIM_KEY = 'ZNAXIS'
+    COMPRESSION_TYPE_KEY = 'ZCOMPTYPE'
+    COMPRESSION_TILE_KEY_ROOT = 'ZTILE'
+    COMPRESSION_VAR_KEY_ROOT = 'ZNAME'
+    COMPRESSION_VAR_VAL_ROOT = 'ZVAL'
+    COMPRESSION_NOISE_BIT_NAME_VALUE = 'NOISEBIT'
+    COMPRESSION_SCALE_NAME_VALUE = 'SCALE'
+    COMPRESSION_SMOOTH_NAME_VALUE = 'SMOOTH'
+     
+    # Activate compression on the image.
+    # "options" is a hash with the following keys:
+    # [:compression_type] the type of compression (:rice, :gzip, :plio, :hcompress).  Required.
+    # [:tile_dim]     the size of the tiles used in compression.  Optional.
+    # [:noise_bits]   applicable for floating point images only.  Optional.
+    # [:hcomp_scale]  scale factor for use in hcompress compression.  Optional.
+    # [:hcomp_smooth] smoothing factor for use in hcompress compression.  Optional.
+    def activate_compression
+      self.compression_type = self.compression_options[:compression_type] if self.compression_options[:compression_type]
+      self.tile_dim = self.compression_options[:tile_dim] if self.compression_options[:tile_dim]
+      self.noise_bits = self.compression_options[:noise_bits] if self.compression_options[:noise_bits]
+      self.hcomp_scale = self.compression_options[:hcomp_scale] if self.compression_options[:hcomp_scale]
+      self.hcomp_smooth = self.compression_options[:hcomp_smooth] if self.compression_options[:hcomp_smooth]
+    end
+    
+    # Turn off compression for the image.
+    def deactivate_compression
+      self.compression_type = 0
+    end
+    
+    # Retrieve the compression type of the image.  Possible values: :rice, :gzip, :plio, :hcompress
+    def compression_type
+      reset_position()
+      
+      ctype = case self.header['ZCMPTYPE']
+        when 'GZIP_1'       then IO::Proxy::GZIP_1
+        when 'RICE_1'       then IO::Proxy::RICE_1
+        when 'HCOMPRESS_1'  then IO::Proxy::HCOMPRESS_1
+        when 'PLIO_1'       then IO::Proxy::PLIO_1
+        else
+          raise "Unknown compression type #{self.header[COMPRESSION_TYPE_KEY]}."
+      end
+      
+      COMPRESSION_TYPE_MAP[ctype]
+    end
+    
+    # Set the compression type of the image.  Possible values: :rice, :gzip, :plio, :hcompress
+    #  image.compression_type = :gzip
+    def compression_type=(ctype)
+      ctype ? IO::Proxy.fits_set_compression_type(self.file.io, COMPRESSION_TYPE_MAP.invert[ctype.to_sym] || ctype) :
+        IO::Proxy.fits_set_compression_type(self.file.io, nil)
+    end
+    
+    # Get the tile dimensions for the compressed image.
+    def tile_dim
+      reset_position()
+      
+      tile_dims = []
+      (1..self.header[COMPRESSION_DIM_KEY]).each do |i|
+        tile_dims << self.header["#{COMPRESSION_TILE_KEY_ROOT}#{i}"]
+      end
+      
+      tile_dims
+    end
+    
+    # Set the tile dimensions for the compressed image.
+    #  image.tile_dim = [5, 5]
+    def tile_dim=(tilesizes)
+      IO::Proxy.fits_set_tile_dim(self.file.io, tilesizes.size, tilesizes)
+    end
+    
+    # Get the noise bits for the compressed image.
+    def noise_bits
+      reset_position()
+      
+      zname_name, zname_value, zname_comment = self.header.find { |name, value, comment|
+        name.match(/^#{COMPRESSION_VAR_KEY_ROOT}/) and value == COMPRESSION_NOISE_BIT_NAME_VALUE
+      }
+      zname_name ? self.header["#{COMPRESSION_VAR_VAL_ROOT}#{zname_name.match(/^#{COMPRESSION_VAR_KEY_ROOT}(\d+)$/)[1]}"] : nil
+    end
+    
+    # Set the noise bits for the compressed image.
+    def noise_bits=(bits)
+      IO::Proxy.fits_set_noise_bits(self.file.io, bits.to_i)
+    end
+    
+    # Get the hcompress scale if the image is compressed using hcompress.
+    def hcomp_scale
+      reset_position()
+
+      zname_name, zname_value, zname_comment = self.header.find { |name, value, comment|
+        name.match(/^#{COMPRESSION_VAR_KEY_ROOT}/) and value == COMPRESSION_SCALE_NAME_VALUE
+      }
+      zname_name ? self.header["#{COMPRESSION_VAR_VAL_ROOT}#{zname_name.match(/^#{COMPRESSION_VAR_KEY_ROOT}(\d+)$/)[1]}"] : nil
+    end
+    
+    # Set the hcompress scale if the image is compressed using hcompress.
+    def hcomp_scale=(scale)
+      IO::Proxy.fits_set_hcomp_scale(self.file.io, scale.to_i)
+    end
+    
+    # Get the hcompress smoothing factor if the image is compressed using hcompress.
+    def hcomp_smooth
+      reset_position()
+      
+      zname_name, zname_value, zname_comment = self.header.find { |name, value, comment|
+        name.match(/^#{COMPRESSION_VAR_KEY_ROOT}/) and value == COMPRESSION_SMOOTH_NAME_VALUE
+      }
+      zname_name ? self.header["#{COMPRESSION_VAR_VAL_ROOT}#{zname_name.match(/^#{COMPRESSION_VAR_KEY_ROOT}(\d+)$/)[1]}"] : nil
+    end
+    
+    # Set the hcompress smoothing factor if the image is compressed using hcompress.
+    def hcomp_smooth=(smooth)
+      IO::Proxy.fits_set_hcomp_smooth(self.file.io, smooth.to_i)
+    end
+  end
+  
+  # An Image HDU.
+  class Image < HDU
+    include Compressible
+    
+    attr_reader :compression_options
+    
+    IMG_TYPE_MAP = {
+      IO::Proxy::BYTE_IMG => :byte,
+      IO::Proxy::SHORT_IMG => :short,
+      IO::Proxy::LONG_IMG => :long,
+      IO::Proxy::LONGLONG_IMG => :longlong,
+      IO::Proxy::FLOAT_IMG => :float,
+      IO::Proxy::DOUBLE_IMG => :double
+    }
+    
+    # Instantiate a new image in the specified file at the specified position,
+    # of a certain data type and size.
+    # "coptions" is optional, but if present see Compressible#activate_compression for allowed format.
+    #
+    # If you do activate compression for an image there is one "gotcha" that might take you by surprise:
+    # if there are no existing HDUs in the file and you add a compressed image, an extra image HDU at the
+    # start of the file will be created.  In other words, your new compressed image will be at fits[1]
+    # *not* fits[0].  This is because cfitsio compresses the image by wrapping it in a binary table,
+    # but the FITS specification mandates that the primary HDU must always be an image array.
+    def initialize(file, extpos, bitpix, naxes, coptions=nil)
+      super(file, extpos)
+      
+      @bitpix = bitpix
+      @naxes = naxes
+      
+      @compression_options = coptions
+    end
+  
+    # Actually create a physical image (i.e. write bytes).
+    # "at" is the position at which to insert the image.
+    def create(at)
+      self.deactivate_compression
+      
+      # A dummy image gets added if to the top of the file if
+      # the first image added is compressed.
+      @extpos = (self.file.length == 0 and self.compression_options) ? at + 1 : at
+      
+      self.file.set_position(at - 1 < 0 ? 0 : at - 1)
+      self.activate_compression() if self.compression_options
+      IO::Proxy.fits_insert_img(self.file.io, @bitpix, @naxes.size, @naxes)
+    
+      # This just makes sure something is written out right away.
+      self.header['RFITS1234'] = 'temp'
+      self.header.delete('RFITS1234')
+    end
+    
+    # Alias for Image#dim
+    def naxis
+      self.dim
+    end
+    
+    # The number of dimensions of the image (i.e. 2).
+    def dim
+      reset_position()
+      IO::Proxy.fits_get_img_dim(self.file.io)
+    end
+    
+    # The size of each dimension (i.e. [512, 512]).
+    def size
+      reset_position()
+      IO::Proxy.fits_get_img_size(self.file.io, self.naxis)
+    end
+    
+    # Alias for Image#size
+    def naxes
+      self.size
+    end
+    
+    # Alter image dimensions to the specified size.
+    #  img.naxes = [1000, 200]
+    def naxes=(naxes)
+      reset_position()
+      IO::Proxy.fits_resize_img(self.file.io, self.bitpix, naxes.size, naxes)
+    end
+    
+    # The type of image.  Possibilities include: :byte, :short, :long, :longlong, :float, :double
+    def image_type
+      reset_position()
+      etype = IO::Proxy.fits_get_img_equivtype(self.file.io)
+      IMG_TYPE_MAP[etype] || etype
+    end
+    
+    # Number of bits per data pixel.  By default returns the "equivalent type" unless _equiv_ is set to false.
+    def bitpix(equiv=true)
+      reset_position()
+      equiv ? IO::Proxy.fits_get_img_equivtype(self.file.io) : IO::Proxy.fits_get_img_type(self.file.io)
+    end
+    
+    # Alter the datatype of the image.
+    #  img.bitpix = IO::Proxy::LONG_IMG
+    def bitpix=(bitpix)
+      reset_position()
+      IO::Proxy.fits_resize_img(self.file.io, bitpix, self.naxis, self.naxes)
+    end
+    
+    # Resize the image to the specified dimensions and data type.
+    #  img.resize(IO::Proxy::LONG_IMG, [1000, 200])
+    def resize(bitpix, naxes)
+      reset_position()
+      IO::Proxy.fits_resize_img(self.file.io, bitpix, naxes.size, naxes)
+    end
+    
+    # Returns true if the image is compressed, false otherwise.
+    def compressed?
+      reset_position()
+      IO::Proxy.fits_is_compressed_image(self.file.io) == 1 ? true : false
+    end
+  end
+  
+  # A class that encapsulates knowledge about the name and type of a column in a table.
+  class ColumnInformation
+    COLUMN_TYPE_MAP = {
+      IO::Proxy::TBIT => :bit,
+      IO::Proxy::TBYTE => :byte,
+      IO::Proxy::TLOGICAL => :logical,
+      IO::Proxy::TSTRING => :string,
+      IO::Proxy::TSHORT => :short,
+      IO::Proxy::TLONG => :long,
+      IO::Proxy::TFLOAT => :float,
+      IO::Proxy::TDOUBLE => :double,
+      IO::Proxy::TCOMPLEX => :complex,
+      IO::Proxy::TDBLCOMPLEX => :dblcomplex
+    }
+    
+    # The table the column belongs to.
+    attr_reader :table
+    
+    # The position of the column in the table.
+    attr_reader :position
+    
+    # Create a new ColumnInformation object on the specified table (of type AsciiTable or BinaryTable)
+    # at the specified location (a zero-based index).
+    #  ci = ColumnInformation.new(tbl, 2)   # the third column in the table
+    def initialize(table, position)
+      @table = table
+      @position = position
+    end
+    
+    # The name of the column.
+    #  ci.name   # 'column_3'
+    def name
+      self.table.reset_position
+      IO::Proxy.fits_get_colname(self.table.file.io, IO::Proxy::CASEINSEN, "#{self.position + 1}").first
+    end
+    
+    # The data type of the column.  May be one of:
+    #   :bit, :byte, :logical, :string, :short, :long, :float, :double, :complex, :dblcomplex
+    # If the data type is unrecognized, an integer corresponding to the cfitsio data type
+    # will be returned instead.
+    #  ci.data_type   # :string
+    def data_type(as_int=false)
+      self.table.reset_position
+      type_info = IO::Proxy.fits_get_coltype(self.table.file.io, self.position+1)
+      
+      as_int ? type_info[0] : COLUMN_TYPE_MAP[type_info[0]] || type_info[0]
+    end
+    
+    # The vector repeat count of the column.  An AsciiTable will always have a repeat of 1.
+    #  ci.repeat  # 10
+    def repeat
+      self.table.reset_position
+      type_info = IO::Proxy.fits_get_coltype(self.table.file.io, self.position+1)
+      
+      type_info[1]
+    end
+    
+    # The width, in bytes, of the column.
+    #  ci.width  # 10
+    def width
+      self.table.reset_position
+      type_info = IO::Proxy.fits_get_coltype(self.table.file.io, self.position+1)
+      
+      type_info[2]
+    end
+    
+    # The display width (i.e. the width of the column if it were to be converted into it's string representation).
+    #  ci.display_width  # 10
+    def display_width
+      self.table.reset_position
+      IO::Proxy.fits_get_col_display_width(self.table.file.io, self.position+1)
+    end
+    
+    # The number of dimensions of the column.  "maxdim" is the maximum number of dimensions
+    # to return and defaults to 1.
+    #  ci.dim  # 1
+    def dim(maxdim=1)
+      self.table.reset_position
+      dim_info = IO::Proxy.fits_read_tdim(self.table.file.io, self.position+1, 1)
+      
+      dim_info[0]
+    end
+    
+    # An alias for ColumnInformation#dim
+    def naxis(*args)
+      self.dim(*args)
+    end
+    
+    # The size of the dimensions of the column.  "maxdim" is the maximum number of dimensions
+    # to return and defaults to 1.
+    #   ci.size  # [1]
+    def size(maxdim=1)
+      self.table.reset_position
+      dim_info = IO::Proxy.fits_read_tdim(self.table.file.io, self.position+1, maxdim)
+      
+      return dim_info[1]
+    end
+    
+    # An alias for ColumnInformation#size
+    def naxes(*args)
+      self.size(*args)
+    end
+  end
+  
+  # A list of ColumnInformation objects representing the set
+  # of column definitions.  Behaves much like an array.
+  class ColumnInformationList
+    include Enumerable
+    
+    # The table the columns belong to.
+    attr_reader :table
+    
+    # Create a list of ColumnInformation from the specified table.
+    #  cil = ColumnInformationList.new(table)
+    def initialize(table)
+      @table = table
+    end
+    
+    # Retrieve the ith column's information.
+    #  cil[1]  # the second column's information
+    def [](i)
+      self.table.reset_position
+      ColumnInformation.new(self.table, i)
+    end
+    
+    # Insert a column into the ith position.
+    # "options" is a hash with two keys:
+    #
+    # [:name]   the name of the column
+    # [:format] the format of the column as explained in the cfitsio documentation
+    #
+    # You can also insert multiple columns at the same time by passing an array
+    # of hashes of the format explained above.
+    #  cil[1] = {:name => 'new_column_1', :format => 'A10'}
+    #  cil[1] = [{:name => 'new_column_1', :format => 'A10'}, {:name => 'new_column_2', :format => 'I'}]
+    def []=(i, options)
+      self.table.reset_position
+      
+      names = []
+      formats = []
+      if options.is_a?(Array)
+        options.each do |spec|
+          names << spec[:name]
+          formats << spec[:format]
+        end
+      else
+        names = [options[:name]]
+        formats = [options[:format]]
+      end
+      
+      IO::Proxy.fits_insert_cols(self.table.file.io, i+1, names.size, names, formats)
+    end
+    
+    # Iterate through each ColumnInformation object.
+    def each
+      (0...self.size).each do |i|
+        yield self[i]
+      end
+    end
+    
+    # Append a new column to the table.  See ColumnInformationList#[]= for details
+    # on what "options" can look like.
+    #  cil << {:name => 'new_column_1', :format => 'A10'}
+    #  cil << [{:name => 'new_column_1', :format => 'A10'}, {:name => 'new_column_2', :format => 'I'}]
+    def <<(options)
+      self[self.size] = options
+    end
+    
+    # Delete the ith column.
+    #  cil.delete(1)  # delete the second column
+    def delete(i)
+      self.table.reset_position
+      IO::Proxy.fits_delete_col(self.table.file.io, i+1)
+    end
+    
+    # The number of columns in the table.
+    #  cil.size  # 4
+    def size
+      self.table.reset_position
+      IO::Proxy.fits_get_num_cols(self.table.file.io)
+    end
+  end
+  
+  # A class representing a generic table extension.  Is intended to be abstract.
+  class Table < HDU
+    # Metadata for each column.
+    attr_reader :column_information
+    
+    # Tabular data.
+    attr_reader :data
+    
+    def initialize(file, extpos, names, formats, extname=nil, units=nil)
+      super(file, extpos)
+      
+      @column_names = names
+      @column_formats = formats
+      @extname = extname
+      @column_units = units
+      
+      @column_information = ColumnInformationList.new(self)
+      @data = TableData.new(self)
+    end
+    
+    # Convert a table to CSV.
+    def to_csv
+      col_names = self.column_information.collect{ |ci| ci.name }
+      
+      buffer = ''
+      CSV.generate_row(col_names, col_names.size, buffer)
+      buffer << self.data.to_csv
+      
+      buffer
+    end
+    
+    # Convert a table to a string.  Currently an alias for Table#to_csv.
+    def to_s
+      self.to_csv
+    end
+  end
+  
+  # A class representing an ASCII table.
+  class AsciiTable < Table
+    def create(at)
+      self.file.set_position(at - 1 < 0 ? 0 : at - 1)
+      
+      IO::Proxy.fits_insert_atbl(self.file.io, 0, 0, @column_names.size,
+        @column_names,
+        nil,
+        @column_formats,
+        @column_units,
+        @extname, 0)
+        
+      @extpos = at
+      
+      # This just makes sure something is written out right away.
+      self.header['RFITS1234'] = 'temp'
+      self.header.delete('RFITS1234')
+    end
+  end
+  
+  # A class representing a binary table.
+  class BinaryTable < Table
+    def create(at)
+      self.file.set_position(at - 1 < 0 ? 0 : at - 1)
+
+      IO::Proxy.fits_insert_btbl(self.file.io, 0, @column_names.size,
+        @column_names,
+        @column_formats,
+        @column_units,
+        @extname, 0)
+        
+      @extpos = at
+      
+      # This just makes sure something is written out right away.
+      self.header['RFITS1234'] = 'temp'
+      self.header.delete('RFITS1234')
+    end
+  end
+end