<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Less Familiar Objects — Astropy v0.2.4</title>
<link rel="stylesheet" href="../../../_static/bootstrap-astropy.css" type="text/css" />
<link rel="stylesheet" href="../../../_static/pygments.css" type="text/css" />
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT: '../../../',
VERSION: '0.2.4',
COLLAPSE_INDEX: false,
FILE_SUFFIX: '.html',
HAS_SOURCE: true
};
</script>
<script type="text/javascript" src="../../../_static/jquery.js"></script>
<script type="text/javascript" src="../../../_static/underscore.js"></script>
<script type="text/javascript" src="../../../_static/doctools.js"></script>
<script type="text/javascript" src="../../../_static/sidebar.js"></script>
<link rel="shortcut icon" href="../../../_static/astropy_logo.ico"/>
<link rel="top" title="Astropy v0.2.4" href="../../../index.html" />
<link rel="up" title="FITS File handling (astropy.io.fits)" href="../index.html" />
<link rel="next" title="Executable Scripts" href="scripts.html" />
<link rel="prev" title="Verification" href="verification.html" />
</head>
<body>
<div class="topbar">
<a class="brand" title="Documentation Home" href="../../../index.html"></a>
<ul>
<li><a class="homelink" title="AstroPy Homepage" href="http://www.astropy.org"></a></li>
<li><a title="General Index" href="../../../genindex.html">Index</a></li>
<li><a title="Python Module Index" href="../../../py-modindex.html">Modules</a></li>
<li>
<form action="../../../search.html" method="get">
<input type="text" name="q" placeholder="Search" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
</li>
</ul>
</div>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right">
<a href="scripts.html" title="Executable Scripts">
next »
</a>
</li>
<li class="right">
<a href="verification.html" title="Verification">
« previous
</a>
|
</li>
<li>
<a href="../../../index.html">Astropy v0.2.4</a>
»
</li>
<li><a href="../index.html" accesskey="U">FITS File handling (<tt class="docutils literal"><span class="pre">astropy.io.fits</span></tt>)</a> »</li>
<li>Less Familiar Objects</li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body">
<div class="section" id="less-familiar-objects">
<h1>Less Familiar Objects<a class="headerlink" href="#less-familiar-objects" title="Permalink to this headline">¶</a></h1>
<p>In this chapter, we’ll discuss less frequently used FITS data structures. They
include ASCII tables, variable length tables, and random access group FITS
files.</p>
<div class="section" id="ascii-tables">
<h2>ASCII Tables<a class="headerlink" href="#ascii-tables" title="Permalink to this headline">¶</a></h2>
<p>FITS standard supports both binary and ASCII tables. In ASCII tables, all the
data are stored in a human readable text form, so it takes up more space and
extra processing to parse the text for numeric data.</p>
<p>In Astropy, the interface for ASCII tables and binary tables is basically the
same, i.e. the data is in the <tt class="docutils literal"><span class="pre">.data</span></tt> attribute and the <tt class="docutils literal"><span class="pre">field()</span></tt> method
is used to refer to the columns and returns a numpy array. When reading the
table, Astropy will automatically detect what kind of table it is.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="kn">from</span> <span class="nn">astropy.io</span> <span class="kn">import</span> <span class="n">fits</span>
<span class="gp">>>> </span><span class="n">hdus</span> <span class="o">=</span> <span class="n">fits</span><span class="o">.</span><span class="n">open</span><span class="p">(</span><span class="s">'ascii_table.fits'</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">hdus</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="o">.</span><span class="n">data</span><span class="p">[:</span><span class="mi">1</span><span class="p">]</span>
<span class="go">FITS_rec(</span>
<span class="gp">... </span><span class="p">[(</span><span class="mf">10.123000144958496</span><span class="p">,</span> <span class="mi">37</span><span class="p">)],</span>
<span class="gp">... </span><span class="n">dtype</span><span class="o">=</span><span class="p">[(</span><span class="s">'a'</span><span class="p">,</span> <span class="s">'>f4'</span><span class="p">),(</span><span class="s">'b'</span><span class="p">,</span><span class="s">'>i4'</span><span class="p">)])</span>
<span class="gp">>>> </span><span class="n">hdus</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">field</span><span class="p">(</span><span class="s">'a'</span><span class="p">)</span>
<span class="go">array([ 10.12300014, 5.19999981, 15.60999966, 0. ,</span>
<span class="go">345. ], dtype=float32)</span>
<span class="gp">>>> </span><span class="n">hdus</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">formats</span>
<span class="go">['E10.4', 'I5']</span>
</pre></div>
</div>
<p>Note that the formats in the record array refer to the raw data which are ASCII
strings (therefore ‘a11’ and ‘a5’), but the .formats attribute of data retains
the original format specifications (‘E10.4’ and ‘I5’).</p>
<div class="section" id="creating-an-ascii-table">
<h3>Creating an ASCII Table<a class="headerlink" href="#creating-an-ascii-table" title="Permalink to this headline">¶</a></h3>
<p>Creating an ASCII table from scratch is similar to creating a binary table. The
difference is in the Column definitions. The columns/fields in an ASCII table
are more limited than in a binary table. It does not allow more than one
numerical value in a cell. Also, it only supports a subset of what allowed in a
binary table, namely character strings, integer, and (single and double
precision) floating point numbers. Boolean and complex numbers are not allowed.</p>
<p>The format syntax (the values of the TFORM keywords) is different from that of a
binary table, they are:</p>
<div class="highlight-python"><pre>Aw Character string
Iw (Decimal) Integer
Fw.d Single precision real
Ew.d Single precision real, in exponential notation
Dw.d Double precision real, in exponential notation</pre>
</div>
<p>where, w is the width, and d the number of digits after the decimal point. The
syntax difference between ASCII and binary tables can be confusing. For example,
a field of 3-character string is specified ‘3A’ in a binary table and as ‘A3’ in
an ASCII table.</p>
<p>The other difference is the need to specify the table type when using either
<tt class="xref py py-meth docutils literal"><span class="pre">ColDef()</span></tt> or <a class="reference internal" href="../api/tables.html#astropy.io.fits.new_table" title="astropy.io.fits.new_table"><tt class="xref py py-func docutils literal"><span class="pre">new_table()</span></tt></a>.</p>
<p>The default value for tbtype is <tt class="docutils literal"><span class="pre">BinTableHDU</span></tt>.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">>>></span>
<span class="go"># Define the columns</span>
<span class="gp">>>> </span><span class="kn">import</span> <span class="nn">numpy</span> <span class="kn">as</span> <span class="nn">np</span>
<span class="gp">>>> </span><span class="kn">from</span> <span class="nn">astropy.io</span> <span class="kn">import</span> <span class="n">fits</span>
<span class="gp">>>> </span><span class="n">a1</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">array</span><span class="p">([</span><span class="s">'abcd'</span><span class="p">,</span> <span class="s">'def'</span><span class="p">])</span>
<span class="gp">>>> </span><span class="n">r1</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">array</span><span class="p">([</span><span class="mf">11.</span><span class="p">,</span> <span class="mf">12.</span><span class="p">])</span>
<span class="gp">>>> </span><span class="n">c1</span> <span class="o">=</span> <span class="n">fits</span><span class="o">.</span><span class="n">Column</span><span class="p">(</span><span class="n">name</span><span class="o">=</span><span class="s">'abc'</span><span class="p">,</span> <span class="n">format</span><span class="o">=</span><span class="s">'A3'</span><span class="p">,</span> <span class="n">array</span><span class="o">=</span><span class="n">a1</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">c2</span> <span class="o">=</span> <span class="n">fits</span><span class="o">.</span><span class="n">Column</span><span class="p">(</span><span class="n">name</span><span class="o">=</span><span class="s">'def'</span><span class="p">,</span> <span class="n">format</span><span class="o">=</span><span class="s">'E'</span><span class="p">,</span> <span class="n">array</span><span class="o">=</span><span class="n">r1</span><span class="p">,</span>
<span class="gp">... </span> <span class="n">bscale</span><span class="o">=</span><span class="mf">2.3</span><span class="p">,</span> <span class="n">bzero</span><span class="o">=</span><span class="mf">0.6</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">c3</span> <span class="o">=</span> <span class="n">fits</span><span class="o">.</span><span class="n">Column</span><span class="p">(</span><span class="n">name</span><span class="o">=</span><span class="s">'t1'</span><span class="p">,</span> <span class="n">format</span><span class="o">=</span><span class="s">'I'</span><span class="p">,</span> <span class="n">array</span><span class="o">=</span><span class="p">[</span><span class="mi">91</span><span class="p">,</span> <span class="mi">92</span><span class="p">,</span> <span class="mi">93</span><span class="p">])</span>
<span class="go"># Create the table</span>
<span class="gp">>>> </span><span class="n">x</span> <span class="o">=</span> <span class="n">fits</span><span class="o">.</span><span class="n">ColDefs</span><span class="p">([</span><span class="n">c1</span><span class="p">,</span> <span class="n">c2</span><span class="p">,</span> <span class="n">c3</span><span class="p">],</span> <span class="n">tbtype</span><span class="o">=</span><span class="s">'TableHDU'</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">hdu</span> <span class="o">=</span> <span class="n">fits</span><span class="o">.</span><span class="n">new_table</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">tbtype</span><span class="o">=</span><span class="s">'TableHDU'</span><span class="p">)</span>
<span class="go"># Or, simply,</span>
<span class="gp">>>> </span><span class="n">hdu</span> <span class="o">=</span> <span class="n">fits</span><span class="o">.</span><span class="n">new_table</span><span class="p">([</span><span class="n">c1</span><span class="p">,</span> <span class="n">c2</span><span class="p">,</span> <span class="n">c3</span><span class="p">],</span> <span class="n">tbtype</span><span class="o">=</span><span class="s">'TableHDU'</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">hdu</span><span class="o">.</span><span class="n">writeto</span><span class="p">(</span><span class="s">'ascii.fits'</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">hdu</span><span class="o">.</span><span class="n">data</span>
<span class="go">FITS_rec([('abcd', 11.0, 91), ('def', 12.0, 92), ('', 0.0, 93)],</span>
<span class="go"> dtype=[('abc', '|S3'), ('def', '|S14'), ('t1', '|S10')])</span>
</pre></div>
</div>
</div>
</div>
<div class="section" id="variable-length-array-tables">
<h2>Variable Length Array Tables<a class="headerlink" href="#variable-length-array-tables" title="Permalink to this headline">¶</a></h2>
<p>The FITS standard also supports variable length array tables. The basic idea is
that sometimes it is desirable to have tables with cells in the same field
(column) that have the same data type but have different lengths/dimensions.
Compared with the standard table data structure, the variable length table can
save storage space if there is a large dynamic range of data lengths in
different cells.</p>
<p>A variable length array table can have one or more fields (columns) which are
variable length. The rest of the fields (columns) in the same table can still
be regular, fixed-length ones. Astropy will automatically detect what kind of
field it is during reading; no special action is needed from the user. The data
type specification (i.e. the value of the TFORM keyword) uses an extra letter
‘P’ and the format is</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">rPt</span><span class="p">(</span><span class="nb">max</span><span class="p">)</span>
</pre></div>
</div>
<p>where r is 0, 1, or absent, t is one of the letter code for regular table data
type (L, B, X, I, J, etc. currently, the X format is not supported for variable
length array field in Astropy), and max is the maximum number of elements. So,
for a variable length field of int32, The corresponding format spec is,
e.g. ‘PJ(100)’.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">f</span> <span class="o">=</span> <span class="n">fits</span><span class="o">.</span><span class="n">open</span><span class="p">(</span><span class="s">'variable_length_table.fits'</span><span class="p">)</span>
<span class="gp">>>> </span><span class="k">print</span> <span class="n">f</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="o">.</span><span class="n">header</span><span class="p">[</span><span class="s">'tform5'</span><span class="p">]</span>
<span class="go">1PI(20)</span>
<span class="gp">>>> </span><span class="k">print</span> <span class="n">f</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">field</span><span class="p">(</span><span class="mi">4</span><span class="p">)[:</span><span class="mi">3</span><span class="p">]</span>
<span class="go">[array([1], dtype=int16) array([88, 2], dtype=int16)</span>
<span class="go">array([ 1, 88, 3], dtype=int16)]</span>
</pre></div>
</div>
<p>The above example shows a variable length array field of data type int16 and its
first row has one element, second row has 2 elements etc. Accessing variable
length fields is almost identical to regular fields, except that operations on
the whole filed are usually not possible. A user has to process the field row by
row.</p>
<div class="section" id="creating-a-variable-length-array-table">
<h3>Creating a Variable Length Array Table<a class="headerlink" href="#creating-a-variable-length-array-table" title="Permalink to this headline">¶</a></h3>
<p>Creating a variable length table is almost identical to creating a regular
table. The only difference is in the creation of field definitions which are
variable length arrays. First, the data type specification will need the ‘P’
letter, and secondly, the field data must be an objects array (as included in
the numpy module). Here is an example of creating a table with two fields, one
is regular and the other variable length array.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="kn">from</span> <span class="nn">astropy.io</span> <span class="kn">import</span> <span class="n">fits</span>
<span class="gp">>>> </span><span class="kn">import</span> <span class="nn">numpy</span> <span class="kn">as</span> <span class="nn">np</span>
<span class="gp">>>> </span><span class="n">c1</span> <span class="o">=</span> <span class="n">fits</span><span class="o">.</span><span class="n">Column</span><span class="p">(</span><span class="n">name</span><span class="o">=</span><span class="s">'var'</span><span class="p">,</span> <span class="n">format</span><span class="o">=</span><span class="s">'PJ()'</span><span class="p">,</span>
<span class="gp">... </span> <span class="n">array</span><span class="o">=</span><span class="n">np</span><span class="o">.</span><span class="n">array</span><span class="p">([[</span><span class="mf">45.</span><span class="p">,</span> <span class="mi">56</span><span class="p">]</span>
<span class="go"> [11, 12, 13]],</span>
<span class="gp">... </span> <span class="n">dtype</span><span class="o">=</span><span class="n">np</span><span class="o">.</span><span class="n">object</span><span class="p">))</span>
<span class="gp">>>> </span><span class="n">c2</span> <span class="o">=</span> <span class="n">fits</span><span class="o">.</span><span class="n">Column</span><span class="p">(</span><span class="n">name</span><span class="o">=</span><span class="s">'xyz'</span><span class="p">,</span> <span class="n">format</span><span class="o">=</span><span class="s">'2I'</span><span class="p">,</span> <span class="n">array</span><span class="o">=</span><span class="p">[[</span><span class="mi">11</span><span class="p">,</span> <span class="mi">3</span><span class="p">],</span> <span class="p">[</span><span class="mi">12</span><span class="p">,</span> <span class="mi">4</span><span class="p">]])</span>
<span class="go"># the rest is the same as a regular table.</span>
<span class="go"># Create the table HDU</span>
<span class="gp">>>> </span><span class="n">tbhdu</span> <span class="o">=</span> <span class="n">fits</span><span class="o">.</span><span class="n">new_table</span><span class="p">([</span><span class="n">c1</span><span class="p">,</span> <span class="n">c2</span><span class="p">])</span>
<span class="gp">>>> </span><span class="k">print</span> <span class="n">tbhdu</span><span class="o">.</span><span class="n">data</span>
<span class="go">FITS_rec([(array([45, 56]), array([11, 3], dtype=int16)),</span>
<span class="go"> (array([11, 12, 13]), array([12, 4], dtype=int16))],</span>
<span class="go"> dtype=[('var', '<i4', 2), ('xyz', '<i2', 2)])</span>
<span class="go"># write to a FITS file</span>
<span class="gp">>>> </span><span class="n">tbhdu</span><span class="o">.</span><span class="n">writeto</span><span class="p">(</span><span class="s">'var_table.fits'</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">hdu</span> <span class="o">=</span> <span class="n">fits</span><span class="o">.</span><span class="n">open</span><span class="p">(</span><span class="s">'var_table.fits'</span><span class="p">)</span>
<span class="go"># Note that heap info is taken care of (PCOUNT) when written to FITS file.</span>
<span class="gp">>>> </span><span class="n">hdu</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="o">.</span><span class="n">header</span>
<span class="go">XTENSION= 'BINTABLE' / binary table extension</span>
<span class="go">BITPIX = 8 / array data type</span>
<span class="go">NAXIS = 2 / number of array dimensions</span>
<span class="go">NAXIS1 = 12 / length of dimension 1</span>
<span class="go">NAXIS2 = 2 / length of dimension 2</span>
<span class="go">PCOUNT = 20 / number of group parameters</span>
<span class="go">GCOUNT = 1 / number of groups</span>
<span class="go">TFIELDS = 2 / number of table fields</span>
<span class="go">TTYPE1 = 'var '</span>
<span class="go">TFORM1 = 'PJ(3) '</span>
<span class="go">TTYPE2 = 'xyz '</span>
<span class="go">TFORM2 = '2I '</span>
</pre></div>
</div>
</div>
</div>
<div class="section" id="random-access-groups">
<h2>Random Access Groups<a class="headerlink" href="#random-access-groups" title="Permalink to this headline">¶</a></h2>
<p>Another less familiar data structure supported by the FITS standard is the
random access group. This convention was established before the binary table
extension was introduced. In most cases its use can now be superseded by the
binary table. It is mostly used in radio interferometry.</p>
<p>Like Primary HDUs, a Random Access Group HDU is always the first HDU of a FITS
file. Its data has one or more groups. Each group may have any number
(including 0) of parameters, together with an image. The parameters and the
image have the same data type.</p>
<p>All groups in the same HDU have the same data structure, i.e. same data type
(specified by the keyword BITPIX, as in image HDU), same number of parameters
(specified by PCOUNT), and the same size and shape (specified by NAXISn
keywords) of the image data. The number of groups is specified by GCOUNT and
the keyword NAXIS1 is always 0. Thus the total data size for a Random Access
Group HDU is</p>
<pre class="literal-block">
|BITPIX| * GCOUNT * (PCOUNT + NAXIS2 * NAXIS3 * ... * NAXISn)
</pre>
<div class="section" id="header-and-summary">
<h3>Header and Summary<a class="headerlink" href="#header-and-summary" title="Permalink to this headline">¶</a></h3>
<p>Accessing the header of a Random Access Group HDU is no different from any
other HDU. Just use the .header attribute.</p>
<p>The content of the HDU can similarly be summarized by using the
<a class="reference internal" href="../api/hdulists.html#astropy.io.fits.HDUList.info" title="astropy.io.fits.HDUList.info"><tt class="xref py py-meth docutils literal"><span class="pre">HDUList.info()</span></tt></a> method:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">f</span> <span class="o">=</span> <span class="n">fits</span><span class="o">.</span><span class="n">open</span><span class="p">(</span><span class="s">'random_group.fits'</span><span class="p">)</span>
<span class="gp">>>> </span><span class="k">print</span> <span class="n">f</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">header</span><span class="p">[</span><span class="s">'groups'</span><span class="p">]</span>
<span class="go">True</span>
<span class="gp">>>> </span><span class="k">print</span> <span class="n">f</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">header</span><span class="p">[</span><span class="s">'gcount'</span><span class="p">]</span>
<span class="go">7956</span>
<span class="gp">>>> </span><span class="k">print</span> <span class="n">f</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">header</span><span class="p">[</span><span class="s">'pcount'</span><span class="p">]</span>
<span class="go">6</span>
<span class="gp">>>> </span><span class="n">f</span><span class="o">.</span><span class="n">info</span><span class="p">()</span>
<span class="go">Filename: random_group.fits</span>
<span class="go">No. Name Type Cards Dimensions Format</span>
<span class="go">0 AN GroupsHDU 158 (3, 4, 1, 1, 1) Float32 7956 Groups</span>
<span class="go">6 Parameters</span>
</pre></div>
</div>
</div>
<div class="section" id="data-group-parameters">
<h3>Data: Group Parameters<a class="headerlink" href="#data-group-parameters" title="Permalink to this headline">¶</a></h3>
<p>The data part of a random access group HDU is, like other HDUs, in the
<tt class="docutils literal"><span class="pre">.data</span></tt> attribute. It includes both parameter(s) and image array(s).</p>
<ol class="arabic">
<li><p class="first">show the data in 100th group, including parameters and data</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="k">print</span> <span class="n">f</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">data</span><span class="p">[</span><span class="mi">99</span><span class="p">]</span>
<span class="go">(-8.1987486677035799e-06, 1.2010923615889215e-05,</span>
<span class="go">-1.011189139244005e-05, 258.0, 2445728., 0.10, array([[[[[ 12.4308672 ,</span>
<span class="go">0.56860745, 3.99993873],</span>
<span class="go">[ 12.74043655, 0.31398511, 3.99993873],</span>
<span class="go">[ 0. , 0. , 3.99993873],</span>
<span class="go">[ 0. , 0. , 3.99993873]]]]], dtype=float32))</span>
</pre></div>
</div>
</li>
</ol>
<p>The data first lists all the parameters, then the image array, for the
specified group(s). As a reminder, the image data in this file has the shape of
(1,1,1,4,3) in Python or C convention, or (3,4,1,1,1) in IRAF or FORTRAN
convention.</p>
<p>To access the parameters, first find out what the parameter names are, with the
.parnames attribute:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">f</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">parnames</span> <span class="c"># get the parameter names</span>
<span class="go">['uu--', 'vv--', 'ww--', 'baseline', 'date', 'date']</span>
</pre></div>
</div>
<p>The group parameter can be accessed by the <a class="reference internal" href="../api/hdus.html#astropy.io.fits.GroupData.par" title="astropy.io.fits.GroupData.par"><tt class="xref py py-meth docutils literal"><span class="pre">par()</span></tt></a> method. Like
the table <a class="reference internal" href="../api/tables.html#astropy.io.fits.FITS_rec.field" title="astropy.io.fits.FITS_rec.field"><tt class="xref py py-meth docutils literal"><span class="pre">field()</span></tt></a> method, the argument can be either index or
name:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="k">print</span> <span class="n">f</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">par</span><span class="p">(</span><span class="mi">0</span><span class="p">)[</span><span class="mi">99</span><span class="p">]</span> <span class="c"># Access group parameter by name or by index</span>
<span class="go">-8.1987486677035799e-06</span>
<span class="gp">>>> </span><span class="k">print</span> <span class="n">f</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">par</span><span class="p">(</span><span class="s">'uu--'</span><span class="p">)[</span><span class="mi">99</span><span class="p">]</span>
<span class="go">-8.1987486677035799e-06</span>
</pre></div>
</div>
<p>Note that the parameter name ‘date’ appears twice. This is a feature in the
random access group, and it means to add the values together. Thus:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">>>></span>
<span class="go"># Duplicate group parameter name 'date' for 5th and 6th parameters</span>
<span class="gp">>>> </span><span class="k">print</span> <span class="n">f</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">par</span><span class="p">(</span><span class="mi">4</span><span class="p">)[</span><span class="mi">99</span><span class="p">]</span>
<span class="go">2445728.0</span>
<span class="gp">>>> </span><span class="k">print</span> <span class="n">f</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">par</span><span class="p">(</span><span class="mi">5</span><span class="p">)[</span><span class="mi">99</span><span class="p">]</span>
<span class="go">0.10</span>
<span class="go"># When accessed by name, it adds the values together if the name is shared</span>
<span class="go"># by more than one parameter</span>
<span class="gp">>>> </span><span class="k">print</span> <span class="n">f</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">par</span><span class="p">(</span><span class="s">'date'</span><span class="p">)[</span><span class="mi">99</span><span class="p">]</span>
<span class="go">2445728.10</span>
</pre></div>
</div>
<p>The :meth`~GroupData.par` is a method for either the entire data object or one
data item (a group). So there are two possible ways to get a group parameter
for a certain group, this is similar to the situation in table data (with its
<a class="reference internal" href="../api/tables.html#astropy.io.fits.FITS_rec.field" title="astropy.io.fits.FITS_rec.field"><tt class="xref py py-meth docutils literal"><span class="pre">field()</span></tt></a> method):</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">>>></span>
<span class="go"># Access group parameter by selecting the row (group) number last</span>
<span class="gp">>>> </span><span class="k">print</span> <span class="n">f</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">par</span><span class="p">(</span><span class="mi">0</span><span class="p">)[</span><span class="mi">99</span><span class="p">]</span>
<span class="go">-8.1987486677035799e-06</span>
<span class="go"># Access group parameter by selecting the row (group) number first</span>
<span class="gp">>>> </span><span class="k">print</span> <span class="n">f</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">data</span><span class="p">[</span><span class="mi">99</span><span class="p">]</span><span class="o">.</span><span class="n">par</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
<span class="go">-8.1987486677035799e-06</span>
</pre></div>
</div>
<p>On the other hand, to modify a group parameter, we can either assign the new
value directly (if accessing the row/group number last) or use the
<tt class="xref py py-meth docutils literal"><span class="pre">setpar()</span></tt> method (if accessing the row/group number first). The
method <tt class="xref py py-meth docutils literal"><span class="pre">setpar()</span></tt> is also needed for updating by name if the
parameter is shared by more than one parameters:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">>>></span>
<span class="go"># Update group parameter when selecting the row (group) number last</span>
<span class="gp">>>> </span><span class="n">f</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">par</span><span class="p">(</span><span class="mi">0</span><span class="p">)[</span><span class="mi">99</span><span class="p">]</span> <span class="o">=</span> <span class="mf">99.</span>
<span class="go">>>></span>
<span class="go"># Update group parameter when selecting the row (group) number first</span>
<span class="gp">>>> </span><span class="n">f</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">data</span><span class="p">[</span><span class="mi">99</span><span class="p">]</span><span class="o">.</span><span class="n">setpar</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mf">99.</span><span class="p">)</span> <span class="c"># or setpar('uu--', 99.)</span>
<span class="go">>>></span>
<span class="go"># Update group parameter by name when the name is shared by more than</span>
<span class="go"># one parameters, the new value must be a tuple of constants or sequences</span>
<span class="gp">>>> </span><span class="n">f</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">data</span><span class="p">[</span><span class="mi">99</span><span class="p">]</span><span class="o">.</span><span class="n">setpar</span><span class="p">(</span><span class="s">'date'</span><span class="p">,</span> <span class="p">(</span><span class="mf">2445729.</span><span class="p">,</span> <span class="mf">0.3</span><span class="p">))</span>
<span class="gp">>>> </span><span class="n">f</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">data</span><span class="p">[:</span><span class="mi">3</span><span class="p">]</span><span class="o">.</span><span class="n">setpar</span><span class="p">(</span><span class="s">'date'</span><span class="p">,</span> <span class="p">(</span><span class="mf">2445729.</span><span class="p">,</span> <span class="p">[</span><span class="mf">0.11</span><span class="p">,</span> <span class="mf">0.22</span><span class="p">,</span> <span class="mf">0.33</span><span class="p">]))</span>
<span class="gp">>>> </span><span class="n">f</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">data</span><span class="p">[:</span><span class="mi">3</span><span class="p">]</span><span class="o">.</span><span class="n">par</span><span class="p">(</span><span class="s">'date'</span><span class="p">)</span>
<span class="go">array([ 2445729.11 , 2445729.22 , 2445729.33000001])</span>
</pre></div>
</div>
</div>
<div class="section" id="data-image-data">
<h3>Data: Image Data<a class="headerlink" href="#data-image-data" title="Permalink to this headline">¶</a></h3>
<p>The image array of the data portion is accessible by the
<tt class="xref py py-attr docutils literal"><span class="pre">data</span></tt> attribute of the data object. A numpy array is
returned:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="k">print</span> <span class="n">f</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">data</span><span class="p">[</span><span class="mi">99</span><span class="p">]</span>
<span class="go">array([[[[[ 12.4308672 , 0.56860745, 3.99993873],</span>
<span class="go">[ 12.74043655, 0.31398511, 3.99993873],</span>
<span class="go">[ 0. , 0. , 3.99993873],</span>
<span class="go">[ 0. , 0. , 3.99993873]]]]], type=float32)</span>
</pre></div>
</div>
</div>
<div class="section" id="creating-a-random-access-group-hdu">
<h3>Creating a Random Access Group HDU<a class="headerlink" href="#creating-a-random-access-group-hdu" title="Permalink to this headline">¶</a></h3>
<p>To create a random access group HDU from scratch, use <a class="reference internal" href="../api/hdus.html#astropy.io.fits.GroupData" title="astropy.io.fits.GroupData"><tt class="xref py py-meth docutils literal"><span class="pre">GroupData()</span></tt></a> to
encapsulate the data into the group data structure, and use <a class="reference internal" href="../api/hdus.html#astropy.io.fits.GroupsHDU" title="astropy.io.fits.GroupsHDU"><tt class="xref py py-meth docutils literal"><span class="pre">GroupsHDU()</span></tt></a>
to create the HDU itself:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">>>></span>
<span class="go"># Create the image arrays. The first dimension is the number of groups.</span>
<span class="gp">>>> </span><span class="n">imdata</span> <span class="o">=</span> <span class="n">numpy</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mf">100.0</span><span class="p">,</span> <span class="n">shape</span><span class="o">=</span><span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">5</span><span class="p">))</span>
<span class="go"># Next, create the group parameter data, we'll have two parameters.</span>
<span class="go"># Note that the size of each parameter's data is also the number of groups.</span>
<span class="go"># A parameter's data can also be a numeric constant.</span>
<span class="gp">>>> </span><span class="n">pdata1</span> <span class="o">=</span> <span class="n">numpy</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mi">10</span><span class="p">)</span> <span class="o">+</span> <span class="mf">0.1</span>
<span class="gp">>>> </span><span class="n">pdata2</span> <span class="o">=</span> <span class="mi">42</span>
<span class="go"># Create the group data object, put parameter names and parameter data</span>
<span class="go"># in lists assigned to their corresponding arguments.</span>
<span class="go"># If the data type (bitpix) is not specified, the data type of the image</span>
<span class="go"># will be used.</span>
<span class="gp">>>> </span><span class="n">x</span> <span class="o">=</span> <span class="n">fits</span><span class="o">.</span><span class="n">GroupData</span><span class="p">(</span><span class="n">imdata</span><span class="p">,</span> <span class="n">parnames</span><span class="o">=</span><span class="p">[</span><span class="s">'abc'</span><span class="p">,</span> <span class="s">'xyz'</span><span class="p">],</span>
<span class="gp">... </span> <span class="n">pardata</span><span class="o">=</span><span class="p">[</span><span class="n">pdata1</span><span class="p">,</span> <span class="n">pdata2</span><span class="p">],</span> <span class="n">bitpix</span><span class="o">=-</span><span class="mi">32</span><span class="p">)</span>
<span class="go"># Now, create the GroupsHDU and write to a FITS file.</span>
<span class="gp">>>> </span><span class="n">hdu</span> <span class="o">=</span> <span class="n">fits</span><span class="o">.</span><span class="n">GroupsHDU</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">hdu</span><span class="o">.</span><span class="n">writeto</span><span class="p">(</span><span class="s">'test_group.fits'</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">hdu</span><span class="o">.</span><span class="n">header</span>
<span class="go">SIMPLE = T / conforms to FITS standard</span>
<span class="go">BITPIX = -32 / array data type</span>
<span class="go">NAXIS = 5 / number of array dimensions</span>
<span class="go">NAXIS1 = 0</span>
<span class="go">NAXIS2 = 5</span>
<span class="go">NAXIS3 = 2</span>
<span class="go">NAXIS4 = 1</span>
<span class="go">NAXIS5 = 1</span>
<span class="go">EXTEND = T</span>
<span class="go">GROUPS = T / has groups</span>
<span class="go">PCOUNT = 2 / number of parameters</span>
<span class="go">GCOUNT = 10 / number of groups</span>
<span class="go">PTYPE1 = 'abc '</span>
<span class="go">PTYPE2 = 'xyz '</span>
<span class="gp">>>> </span><span class="k">print</span> <span class="n">hdu</span><span class="o">.</span><span class="n">data</span><span class="p">[:</span><span class="mi">2</span><span class="p">]</span>
<span class="go">FITS_rec[</span>
<span class="go">(0.10000000149011612, 42.0, array([[[[ 0., 1., 2., 3., 4.],</span>
<span class="go">[ 5., 6., 7., 8., 9.]]]], dtype=float32)),</span>
<span class="go">(1.1000000238418579, 42.0, array([[[[ 10., 11., 12., 13., 14.],</span>
<span class="go">[ 15., 16., 17., 18., 19.]]]], dtype=float32))</span>
<span class="go">]</span>
</pre></div>
</div>
</div>
</div>
<div class="section" id="compressed-image-data">
<h2>Compressed Image Data<a class="headerlink" href="#compressed-image-data" title="Permalink to this headline">¶</a></h2>
<p>A general technique has been developed for storing compressed image data in
FITS binary tables. The principle used in this convention is to first divide
the n-dimensional image into a rectangular grid of sub images or ‘tiles’.
Each tile is then compressed as a continuous block of data, and the resulting
compressed byte stream is stored in a row of a variable length column in a
FITS binary table. Several commonly used algorithms for compressing image
tiles are supported. These include, Gzip, Rice, IRAF Pixel List (PLIO), and
Hcompress.</p>
<p>For more details, reference “A FITS Image Compression Proposal” from:</p>
<blockquote>
<div><a class="reference external" href="http://www.adass.org/adass/proceedings/adass99/P2-42/">http://www.adass.org/adass/proceedings/adass99/P2-42/</a></div></blockquote>
<p>and “Registered FITS Convention, Tiled Image Compression Convention”:</p>
<blockquote>
<div><a class="reference external" href="http://fits.gsfc.nasa.gov/registry/tilecompression.html">http://fits.gsfc.nasa.gov/registry/tilecompression.html</a></div></blockquote>
<p>Compressed image data is accessed, in Astropy, using the optional
“astropy.io.fits.compression” module contained in a C shared library
(compression.so). If an attempt is made to access an HDU containing compressed
image data when the compression module is not available, the user is notified
of the problem and the HDU is treated like a standard binary table HDU. This
notification will only be made the first time compressed image data is
encountered. In this way, the compression module is not required in order for
Astropy to work.</p>
<div class="section" id="id1">
<h3>Header and Summary<a class="headerlink" href="#id1" title="Permalink to this headline">¶</a></h3>
<p>In Astropy, the header of a compressed image HDU appears to the user like any
image header. The actual header stored in the FITS file is that of a binary
table HDU with a set of special keywords, defined by the convention, to
describe the structure of the compressed image. The conversion between binary
table HDU header and image HDU header is all performed behind the scenes.
Since the HDU is actually a binary table, it may not appear as a primary HDU in
a FITS file.</p>
<p>The content of the HDU header may be accessed using the <tt class="docutils literal"><span class="pre">.header</span></tt> attribute:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">f</span> <span class="o">=</span> <span class="n">fits</span><span class="o">.</span><span class="n">open</span><span class="p">(</span><span class="s">'compressed_image.fits'</span><span class="p">)</span>
<span class="gp">>>> </span><span class="k">print</span> <span class="n">f</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="o">.</span><span class="n">header</span>
<span class="go">XTENSION= 'IMAGE ' / extension type</span>
<span class="go">BITPIX = 16 / array data type</span>
<span class="go">NAXIS = 2 / number of array dimensions</span>
<span class="go">NAXIS1 = 512 / length of data axis</span>
<span class="go">NAXIS2 = 512 / length of data axis</span>
<span class="go">PCOUNT = 0 / number of parameters</span>
<span class="go">GCOUNT = 1 / one data group (required keyword)</span>
<span class="go">EXTNAME = 'COMPRESSED' / name of this binary table extension</span>
</pre></div>
</div>
<p>The contents of the corresponding binary table HDU may be accessed using the
hidden <tt class="docutils literal"><span class="pre">._header</span></tt> attribute. However, all user interface with the HDU header
should be accomplished through the image header (the <tt class="docutils literal"><span class="pre">.header</span></tt> attribute).</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">f</span> <span class="o">=</span> <span class="n">fits</span><span class="o">.</span><span class="n">open</span><span class="p">(</span><span class="s">'compressed_image.fits'</span><span class="p">)</span>
<span class="gp">>>> </span><span class="k">print</span> <span class="n">f</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="o">.</span><span class="n">_header</span>
<span class="go">XTENSION= 'BINTABLE' / binary table extension</span>
<span class="go">BITPIX = 8 / 8-bit bytes</span>
<span class="go">NAXIS = 2 / 2-dimensional binary table</span>
<span class="go">NAXIS1 = 8 / width of table in bytes</span>
<span class="go">NAXIS2 = 512 / number of rows in table</span>
<span class="go">PCOUNT = 157260 / size of special data area</span>
<span class="go">GCOUNT = 1 / one data group (required keyword)</span>
<span class="go">TFIELDS = 1 / number of fields in each row</span>
<span class="go">TTYPE1 = 'COMPRESSED_DATA' / label for field 1</span>
<span class="go">TFORM1 = '1PB(384)' / data format of field: variable length array</span>
<span class="go">ZIMAGE = T / extension contains compressed image</span>
<span class="go">ZBITPIX = 16 / data type of original image</span>
<span class="go">ZNAXIS = 2 / dimension of original image</span>
<span class="go">ZNAXIS1 = 512 / length of original image axis</span>
<span class="go">ZNAXIS2 = 512 / length of original image axis</span>
<span class="go">ZTILE1 = 512 / size of tiles to be compressed</span>
<span class="go">ZTILE2 = 1 / size of tiles to be compressed</span>
<span class="go">ZCMPTYPE= 'RICE_1 ' / compression algorithm</span>
<span class="go">ZNAME1 = 'BLOCKSIZE' / compression block size</span>
<span class="go">ZVAL1 = 32 / pixels per block</span>
<span class="go">EXTNAME = 'COMPRESSED' / name of this binary table extension</span>
</pre></div>
</div>
<p>The contents of the HDU can be summarized by using either the <a class="reference internal" href="../api/files.html#astropy.io.fits.info" title="astropy.io.fits.info"><tt class="xref py py-func docutils literal"><span class="pre">info()</span></tt></a>
convenience function or method:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">fits</span><span class="o">.</span><span class="n">info</span><span class="p">(</span><span class="s">'compressed_image.fits'</span><span class="p">)</span>
<span class="go">Filename: compressed_image.fits</span>
<span class="go">No. Name Type Cards Dimensions Format</span>
<span class="go">0 PRIMARY PrimaryHDU 6 () int16</span>
<span class="go">1 COMPRESSED CompImageHDU 52 (512, 512) int16</span>
<span class="go">>>></span>
<span class="gp">>>> </span><span class="n">f</span> <span class="o">=</span> <span class="n">fits</span><span class="o">.</span><span class="n">open</span><span class="p">(</span><span class="s">'compressed_image.fits'</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">f</span><span class="o">.</span><span class="n">info</span><span class="p">()</span>
<span class="go">Filename: compressed_image.fits</span>
<span class="go">No. Name Type Cards Dimensions Format</span>
<span class="go">0 PRIMARY PrimaryHDU 6 () int16</span>
<span class="go">1 COMPRESSED CompImageHDU 52 (512, 512) int16</span>
<span class="go">>>></span>
</pre></div>
</div>
</div>
<div class="section" id="data">
<h3>Data<a class="headerlink" href="#data" title="Permalink to this headline">¶</a></h3>
<p>As with the header, the data of a compressed image HDU appears to the user as
standard uncompressed image data. The actual data is stored in the fits file
as Binary Table data containing at least one column (COMPRESSED_DATA). Each
row of this variable-length column contains the byte stream that was generated
as a result of compressing the corresponding image tile. Several optional
columns may also appear. These include, UNCOMPRESSED_DATA to hold the
uncompressed pixel values for tiles that cannot be compressed, ZSCALE and ZZERO
to hold the linear scale factor and zero point offset which may be needed to
transform the raw uncompressed values back to the original image pixel values,
and ZBLANK to hold the integer value used to represent undefined pixels (if
any) in the image.</p>
<p>The content of the HDU data may be accessed using the <tt class="docutils literal"><span class="pre">.data</span></tt> attribute:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">f</span> <span class="o">=</span> <span class="n">fits</span><span class="o">.</span><span class="n">open</span><span class="p">(</span><span class="s">'compressed_image.fits'</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">f</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="o">.</span><span class="n">data</span>
<span class="go">array([[38, 43, 35, ..., 45, 43, 41],</span>
<span class="go"> [36, 41, 37, ..., 42, 41, 39],</span>
<span class="go"> [38, 45, 37, ..., 42, 35, 43],</span>
<span class="go"> ...,</span>
<span class="go"> [49, 52, 49, ..., 41, 35, 39],</span>
<span class="go"> [57, 52, 49, ..., 40, 41, 43],</span>
<span class="go"> [53, 57, 57, ..., 39, 35, 45]], dtype=int16)</span>
</pre></div>
</div>
</div>
<div class="section" id="creating-a-compressed-image-hdu">
<h3>Creating a Compressed Image HDU<a class="headerlink" href="#creating-a-compressed-image-hdu" title="Permalink to this headline">¶</a></h3>
<p>To create a compressed image HDU from scratch, simply construct a
<a class="reference internal" href="../api/images.html#astropy.io.fits.CompImageHDU" title="astropy.io.fits.CompImageHDU"><tt class="xref py py-class docutils literal"><span class="pre">CompImageHDU</span></tt></a> object from an uncompressed image data array and its
associated image header. From there, the HDU can be treated just like any
other image HDU.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">hdu</span> <span class="o">=</span> <span class="n">fits</span><span class="o">.</span><span class="n">CompImageHDU</span><span class="p">(</span><span class="n">imageData</span><span class="p">,</span> <span class="n">imageHeader</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">hdu</span><span class="o">.</span><span class="n">writeto</span><span class="p">(</span><span class="s">'compressed_image.fits'</span><span class="p">)</span>
<span class="go">>>></span>
</pre></div>
</div>
<p>The API documentation for the <a class="reference internal" href="../api/images.html#astropy.io.fits.CompImageHDU" title="astropy.io.fits.CompImageHDU"><tt class="xref py py-class docutils literal"><span class="pre">CompImageHDU</span></tt></a> initializer method
describes the possible options for constructing a <a class="reference internal" href="../api/images.html#astropy.io.fits.CompImageHDU" title="astropy.io.fits.CompImageHDU"><tt class="xref py py-class docutils literal"><span class="pre">CompImageHDU</span></tt></a> object.</p>
</div>
</div>
</div>
</div>
</div>
</div>
<div class="sphinxsidebar">
<div class="sphinxsidebarwrapper"><h3>Page Contents</h3>
<ul>
<li><a class="reference internal" href="#">Less Familiar Objects</a><ul>
<li><a class="reference internal" href="#ascii-tables">ASCII Tables</a><ul>
<li><a class="reference internal" href="#creating-an-ascii-table">Creating an ASCII Table</a></li>
</ul>
</li>
<li><a class="reference internal" href="#variable-length-array-tables">Variable Length Array Tables</a><ul>
<li><a class="reference internal" href="#creating-a-variable-length-array-table">Creating a Variable Length Array Table</a></li>
</ul>
</li>
<li><a class="reference internal" href="#random-access-groups">Random Access Groups</a><ul>
<li><a class="reference internal" href="#header-and-summary">Header and Summary</a></li>
<li><a class="reference internal" href="#data-group-parameters">Data: Group Parameters</a></li>
<li><a class="reference internal" href="#data-image-data">Data: Image Data</a></li>
<li><a class="reference internal" href="#creating-a-random-access-group-hdu">Creating a Random Access Group HDU</a></li>
</ul>
</li>
<li><a class="reference internal" href="#compressed-image-data">Compressed Image Data</a><ul>
<li><a class="reference internal" href="#id1">Header and Summary</a></li>
<li><a class="reference internal" href="#data">Data</a></li>
<li><a class="reference internal" href="#creating-a-compressed-image-hdu">Creating a Compressed Image HDU</a></li>
</ul>
</li>
</ul>
</li>
</ul>
</div>
</div>
<div class="clearer"></div>
</div>
<footer class="footer">
<p class="pull-right">
<a href="http://github.com/astropy/astropy/tree/v0.2.4/docs/io/fits/usage/unfamiliar.rst">Edit This Page on Github</a>
<a href="../../../_sources/io/fits/usage/unfamiliar.txt"
rel="nofollow">Page Source</a>
<a href="#">Back to Top</a></p>
<p>
© Copyright 2011-2013, The Astropy Developers.<br/>
Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.1.3.
Last built 22 Oct 2013. <br/>
</p>
</footer>
</body>
</html>
