Uses of Class
nom.tam.fits.FitsException

Packages that use FitsException
Package
Description
nom.tam.fits
The core classes of nom-tam-fits.
nom.tam.fits.header
Standardized FITS header keywords.
nom.tam.fits.utilities
A collection of useful classes.
nom.tam.image
Image tiling support.
nom.tam.image.compression.hdu
Compressing and decompressing HDUs, for both images and binary tables.
nom.tam.util
Various commonly used classes for nom-tam-fits.

  • Uses of FitsException in nom.tam.fits

    Subclasses of FitsException in nom.tam.fits
    Modifier and Type
    Class
    Description
    class 
    FitsIntegrityException
    Failed checksum verification.
    class 
    HeaderCardException
    Exception that is generated when a header record is in violation of the standard, or encounters some other header card specific issue.
    class 
    HierarchNotEnabledException
    The keyword is a HIERARCH-style long FITS keyword but the library does not have the hierarch support enabled at present.
    class 
    LongStringsNotEnabledException
    The string value does not fit into a signle 80-character wide FITS header record, and the library does not have long string support enabled at present.
    class 
    LongValueException
    The value cannot fit into the available header space, as requested.
    class 
    PaddingException
    This exception is thrown if padding is missing between the end of a FITS data segment and the end-of-file.
    class 
    TruncatedFileException
    When an EOF is encountered in the middle of an HDU.
    class 
    UnclosedQuoteException
    A header value with an unclosed single quote.
    class 
    ValueTypeException
    Invalid value type used for a standard header keyword.
    Methods in nom.tam.fits that throw FitsException
    Modifier and Type
    Method
    Description
    int
    BinaryTable.addBitsColumn(Object o)
    Adds a column of bits.
    int
    AsciiTable.addColumn(Object newCol)
     
    int
    AsciiTable.addColumn(Object newCol, int width)
    Adds an ASCII table column with the specified ASCII text width for storing its elements.
    int
    AsciiTableHDU.addColumn(Object newCol)
     
    int
    BinaryTable.addColumn(Object o)
    Adds a new column with the specified data array, with some default mappings.
    int
    BinaryTableHDU.addColumn(Object data)
     
    int
    TableData.addColumn(Object newCol)
    Add a column to the table, without updating the header of an encompassing HDU.
    int
    TableHDU.addColumn(Object newCol)
    Add a column to the table without any associated header information.
    int
    BinaryTable.addComplexColumn(Object o, Class<?> decimalType)
    Adds a column of complex values stored as the specified decimal type of components in the FITS.
    int
    BinaryTable.addFlattenedColumn(Object o, int... dims)
    Deprecated.
    (for internal use) No longer used, will be removed in the future
    void
    Fits.addHDU(BasicHDU<?> myHDU)
    Add an HDU to the Fits object.
    int
    AsciiTable.addRow(Object[] newRow)
    Beware that adding rows to ASCII tables may be very inefficient.
    int
    BinaryTable.addRow(Object[] o)
    Adds a row to the table.
    int
    TableData.addRow(Object[] newRow)
    Add a row at the end of the table without updating the header of an encompassing HDU.
    int
    TableHDU.addRow(Object[] newRows)
    Add a row to the end of the table.
    default int
    TableData.addRowEntries(Object... entries)
    Like TableData.addRow(Object[]), but with a vararg list of row entries.
    int
    BinaryTable.addStringColumn(String[] o)
    Adds a column of string values (one per row), optimized for storage size.
    int
    BinaryTable.addVariableSizeColumn(Object o)
    Adds a new variable-length data column, populating it with the specified data object.
    long
    BasicHDU.calcChecksum()
    Deprecated.
    Use BasicHDU.verifyIntegrity() instead when appropriate.
    long
    Data.calcChecksum()
    Computes and returns the FITS checksum for this data, for example to compare against the stored DATASUM in the FITS header (e.g. via BasicHDU.getStoredDatasum()).
    long
    Fits.calcChecksum(int hduIndex)
    Deprecated.
    Use BasicHDU.verifyIntegrity() instead when appropriate.
    long
    Fits.calcDatasum(int hduIndex)
    Calculates the data checksum for a given HDU in the Fits.
    ImageData
    ImageData.convertTo(Class<?> type)
    Converts this image HDU to another image HDU of a different type, possibly using a qunatizer for the integer-decimal conversion of the data elements.
    final boolean
    BinaryTableHDU.convertToBits(int col)
    Converts a column from FITS logical values to bits.
    BinaryTable
    BinaryTable.copy()
    Returns an independent copy of the binary table.
    static void
    BinaryTable.createColumnDataFor(BinaryTable table)
    Deprecated.
    (for internal use) It may become a private method in the future.
    static BinaryTable.ColumnDesc
    BinaryTable.ColumnDesc.createForDelimitedStringArrays(byte delim)
    Creates a new column descriptor for variable-length arrays of delimited string entries.
    static BinaryTable.ColumnDesc
    BinaryTable.ColumnDesc.createForFixedArrays(Class<?> type, int... dim)
    Creates a new column descriptor for fixed-shape non-string arrays.
    static BinaryTable.ColumnDesc
    BinaryTable.ColumnDesc.createForScalars(Class<?> type)
    Creates a new column descriptor for a non-string based scalar column.
    static BinaryTable.ColumnDesc
    BinaryTable.ColumnDesc.createForStrings(int len)
    Creates a new column descriptor for single string entries of fixed maximum length.
    static BinaryTable.ColumnDesc
    BinaryTable.ColumnDesc.createForStrings(int len, int... outerDims)
    Creates a new column descriptor for arrays of string entries of fixed maximum length.
    static BinaryTable.ColumnDesc
    BinaryTable.ColumnDesc.createForVariableSize(Class<?> type)
    Creates a new column descriptor for variable length 1D arrays or strings.
    static BinaryTable.ColumnDesc
    BinaryTable.ColumnDesc.createForVariableStringArrays(int len)
    Creates a new column descriptor for variable-length arrays of fixed-length string entries.
    static RandomGroupsHDU
    RandomGroupsHDU.createFrom(Object[][] data)
    Creates a random groups HDU from an Object[nGroups][2] array.
    static Data
    FitsFactory.dataFactory(Header hdr)
    Deprecated.
    (for internal use) Will reduce visibility in the future
    long
    BinaryTable.defragment()
    Defragments the heap area of this table, compacting the heap area, and returning the number of bytes by which the heap size has been reduced.
    void
    AsciiTable.deleteColumns(int start, int len)
     
    void
    BinaryTable.deleteColumns(int start, int len)
     
    void
    TableData.deleteColumns(int col, int len)
    Removes a set of consecutive columns from this table, without updating assocu=iated the header information for the columns that were removed.
    void
    TableHDU.deleteColumnsIndexOne(int column, int len)
    Deprecated.
    It is not entirely foolproof for keeping the header in sync -- it is better to use TableData.deleteColumns(int, int) to edit tables before wrapping them in an HDU and editing the header as necessary to incorporate custom entries.
    void
    TableHDU.deleteColumnsIndexOne(int column, int len, String[] fields)
    Deprecated.
    It is not entirely foolproof for keeping the header in sync -- it is better to use TableData.deleteColumns(int, int) to edit tables before wrapping them in an HDU and editing the header as necessary to incorporate custom entries.
    void
    TableHDU.deleteColumnsIndexZero(int column, int len)
    Deprecated.
    It is not entirely foolproof for keeping the header in sync -- it is better to use TableData.deleteColumns(int, int) to edit tables before wrapping them in an HDU and editing the header as necessary to incorporate custom entries.
    void
    TableHDU.deleteColumnsIndexZero(int column, int len, IFitsHeader[] fields)
    Deprecated.
    It is not entirely foolproof for keeping the header in sync -- it is better to use TableData.deleteColumns(int, int) to edit tables before wrapping them in an HDU and editing the header as necessary to incorporate custom entries.
    void
    Fits.deleteHDU(int n)
    Delete an HDU from the HDU list.
    void
    AsciiTable.deleteRows(int start, int len)
    Beware that repeatedly deleting rows from ASCII tables may be very inefficient.
    void
    BinaryTable.deleteRows(int row, int len)
     
    void
    TableData.deleteRows(int row, int len)
    Removes a set of consecutive rows from this table without updating any associated header information for an encompassing HDU.
    void
    TableHDU.deleteRows(int row)
    Deprecated.
    It is not entirely foolproof for keeping the header in sync -- it is better to use TableData.deleteRows(int, int) to edit tables before wrapping them in an HDU and editing the header as necessary to incorporate custom entries.
    void
    TableHDU.deleteRows(int firstRow, int nRow)
    Deprecated.
    It is not entirely foolproof for keeping the header in sync -- it is better to use TableData.deleteRows(int, int) to edit tables before wrapping them in an HDU and editing the header as necessary to incorporate custom entries.
    void
    Data.detach()
    Detaches this data object from the input (if any), such as a file or stream, but not before loading data from the previously assigned input into memory.
    static AsciiTable
    AsciiTableHDU.encapsulate(Object o)
    Deprecated.
    (for internal use) Use AsciiTable.fromColumnMajor(Object[]) instead.
    static BinaryTable
    BinaryTableHDU.encapsulate(Object o)
    Deprecated.
    (for internal use) Use BinaryTable.fromColumnMajor(Object[]) or BinaryTable.fromRowMajor(Object[][]) instead.
    static ImageData
    ImageHDU.encapsulate(Object o)
    Deprecated.
    (for internal use) Use ImageData.from(Object) instead.
    static RandomGroupsData
    RandomGroupsHDU.encapsulate(Object o)
    Deprecated.
    (for internal use) Will reduce visibility in the future
    static UndefinedData
    UndefinedHDU.encapsulate(Object o)
    Deprecated.
    (for internal use) Will reduce visibility in the future
    void
    BinaryTable.fillHeader(Header h)
    Deprecated.
    (for internal use) Visibility should be reduced to protected.
    static AsciiTable
    AsciiTable.fromColumnMajor(Object[] columns)
    Creates an ASCII table from existing data in column-major format order.
    static BinaryTable
    BinaryTable.fromColumnMajor(Object[] columns)
    Creates a binary table from existing data in column-major format order.
    static BinaryTable
    BinaryTable.fromRowMajor(Object[][] table)
    Creates a binary table from existing table data in row-major format.
    Object
    BinaryTable.get(int row, int col)
    Returns a table element using the usual Java boxing for primitive scalar (singleton) entries, or packaging complex values as ComplexValue, or as appropriate primitive or object arrays.
    int[]
    BasicHDU.getAxes()
    In FITS files the index represented by NAXIS1 is the index that changes most rapidly.
    Bitpix
    BasicHDU.getBitpix()
    Return the Bitpix enum type for this HDU.
    final int
    BasicHDU.getBitPix()
    Deprecated.
    (for internal use) Will reduce visibility or remove entirely in the future.
    long
    BasicHDU.getBlankValue()
    Deprecated.
    This is only applicable to ImageHDU or RandomGroupsHDU with integer type data and not for other HDU or data types.
    long
    ImageHDU.getBlankValue()
    Returns the integer value that signifies blank (missing or null) data in an integer image.
    long
    RandomGroupsHDU.getBlankValue()
    Returns the integer value that signifies blank (missing or null) data in an integer image.
    Object
    AsciiTable.getColumn(int col)
    Returns the data for a particular column in as a flattened 1D array of elements.
    Object
    BinaryTable.getColumn(int col)
    Returns the data for a particular column in as an array of elements.
    Object
    TableData.getColumn(int col)
    Returns the data for a particular column in as an array of elements.
    Object
    TableHDU.getColumn(int col)
    Returns the data for a particular column in as an array of elements.
    Object
    TableHDU.getColumn(String colName)
    Returns the data for a particular column in as an array of elements.
    String
    TableHDU.getColumnFormat(int index)
    Get the FITS type of a column in the table.
    Object[]
    TableHDU.getColumns()
    Returns the data for all columns in as an array.
    Header
    Fits.getCompleteHeader(int n)
    Returns the 'complete' header of the nth HDU in this FITS file/object.
    Header
    Fits.getCompleteHeader(String name)
    Returns the complete header of the first HDU by the specified name in this FITS file/object.
    Header
    Fits.getCompleteHeader(String name, int version)
    Returns the complete header of the first HDU by the specified name and version in this FITS file/object.
    Object[]
    AsciiTable.getData()
     
    ColumnTable<?>
    BinaryTable.getData()
     
    Object
    Data.getData()
    Returns the underlying Java representation of the data contained in this HDU's data segment.
    void
    FitsHeap.getData(int offset, Object array)
    Gets data for a Java array from the heap.
    Object[][]
    RandomGroupsData.getData()
     
    byte[]
    UndefinedData.getData()
     
    static BinaryTable.ColumnDesc
    BinaryTable.getDescriptor(Header header, int col)
    Extracts a column descriptor from the FITS header for a given column index
    final double
    BinaryTable.getDouble(int row, int col)
    Returns the decimal value, if possible, of a scalar table entry.
    Object
    AsciiTable.getElement(int row, int col)
     
    Object
    BinaryTable.getElement(int row, int col)
    Returns a table element as a Java array.
    Object
    TableData.getElement(int row, int col)
    Returns the data element in this table.
    Object
    TableHDU.getElement(int row, int col)
    Returns a specific element from this table
    Object[]
    BinaryTable.getFlatColumns()
    Deprecated.
    (for internal use) It may be private in the future.
    Object
    BinaryTable.getFlattenedColumn(int col)
    Deprecated.
    (for internal use) It may be reduced to private visibility in the future.
    BasicHDU<?>
    Fits.getHDU(int n)
    Returns the n'th HDU.
    BasicHDU<?>
    Fits.getHDU(String name)
    Returns the HDU by the given extension name (defined by EXTNAME header keyword).
    BasicHDU<?>
    Fits.getHDU(String name, int version)
    Returns the HDU by the given extension name and version (defined by EXTNAME and EXTVER keywords).
    Object
    RandomGroupsData.getImage(int group)
    Returns the image component stored in the specified group.
    final Object
    Data.getKernel()
    Same as Data.getData().
    final Boolean
    BinaryTable.getLogical(int row, int col)
    Returns the boolean value, if possible, for scalar elements.
    final long
    BinaryTable.getLong(int row, int col)
    Returns a 64-bit integer value, if possible, of a scalar table entry.
    final Number
    BinaryTable.getNumber(int row, int col)
    Returns the numerical value, if possible, for scalar elements.
    double
    RandomGroupsHDU.getParameter(String name, int group)
    Returns the value for a given group parameter.
    Header
    Fits.getPrimaryHeader()
    Returns the primary header of this FITS file, that is the header of the primary HDU in this Fits object.
    Object
    BinaryTable.getRawElement(int row, int col)
    Deprecated.
    (for internal use) Will reduce visibility in the future.
    Object[]
    AsciiTable.getRow(int row)
     
    Object[]
    BinaryTable.getRow(int row)
     
    Object[]
    TableData.getRow(int row)
    Returns an array of elements in a particualr table row.
    Object[]
    TableHDU.getRow(int row)
    Returns a specific row from this table
    long
    BasicHDU.getStoredChecksum()
    Deprecated.
    Not very useful, since it has no meaning other than ensuring that the checksum of the HDU yields (int) -1 (that is 0xffffffff) after including this value for the CHECKSUM keyword in the header.
    long
    BasicHDU.getStoredDatasum()
    Returns the FITS checksum for the HDU's data that is stored in the header of this HDU under the DATASUM keyword.
    final String
    BinaryTable.getString(int row, int col)
    Returns the string value, if possible, for scalar elements.
    static BasicHDU<?>
    FitsFactory.hduFactory(Object o)
    Deprecated.
    Use Fits.makeHDU(Object) instead (this method may either be migrated to Fits entirely or else have visibility reduced to the package level).
    static <DataClass extends Data>
    BasicHDU<DataClass>
    FitsFactory.hduFactory(Header hdr, DataClass d)
    Deprecated.
    (for internal use)/ Will reduce visibility in the future
    static BasicHDU<?>
    FitsFactory.HDUFactory(Object o)
    Deprecated.
    Use Fits.makeHDU(Object) instead (will removed in the future.
    static <DataClass extends Data>
    BasicHDU<DataClass>
    FitsFactory.HDUFactory(Header hdr, DataClass d)
    Deprecated.
    (duplicate method for internal use) Same as FitsFactory.hduFactory(Header, Data), and will be removed in the future.
    abstract void
    BasicHDU.info(PrintStream stream)
    Print out some information about this HDU.
    void
    Fits.insertHDU(BasicHDU<?> myHDU, int position)
    Insert a FITS object into the list of HDUs.
    Data
    Header.makeData()
    Deprecated.
    (for internal use) Normally we either want to write a Java object to FITS (in which case we have the dataand want to make a header for it), or we read some data from a FITS input.
    static <DataClass extends Data>
    BasicHDU<DataClass>
    Fits.makeHDU(DataClass data)
    Creates a new empty HDU for the given data type.
    static BasicHDU<?>
    Fits.makeHDU(Object o)
    Creates an HDU that wraps around the specified data object.
    static BasicHDU<?>
    Fits.makeHDU(Header h)
    Creates a new empty HDU based on the header description of the data
    static AsciiTable
    AsciiTableHDU.manufactureData(Header hdr)
    Deprecated.
    (for internal use) Will reduce visibility in the future
    static BinaryTable
    BinaryTableHDU.manufactureData(Header header)
    Deprecated.
    (for internal use) Will reduce visibility in the future
    static ImageData
    ImageHDU.manufactureData(Header hdr)
    Deprecated.
    (for internal use) Will reduce visibility in the future
    static RandomGroupsData
    RandomGroupsHDU.manufactureData(Header header)
    Deprecated.
    (for internal use) Will reduce visibility in the future
    static UndefinedData
    UndefinedHDU.manufactureData(Header hdr)
    Deprecated.
    (for internal use) Will reduce visibility in the future
    static Header
    AsciiTableHDU.manufactureHeader(Data d)
    Deprecated.
    (for internal use) Will reduce visibility in the future
    static Header
    BinaryTableHDU.manufactureHeader(Data data)
    Deprecated.
    (for internal use) Will reduce visibility in the future
    static Header
    ImageHDU.manufactureHeader(Data d)
    Deprecated.
    (for internal use) Will reduce visibility in the future
    static Header
    UndefinedHDU.manufactureHeader(Data d)
    Deprecated.
    (for internal use) Will reduce visibility in the future
    static void
    ImageData.overrideHeaderAxes(Header header, int... sizes)
    (for expert users) Overrides the image size description in the header to the specified Java array dimensions.
    static void
    FitsUtil.pad(ArrayDataOutput stream, long size)
    Deprecated.
    (for internal use) Visibility may be reduced to package level in the future
    static void
    FitsUtil.pad(ArrayDataOutput stream, long size, byte fill)
    Deprecated.
    (for internal use) Visibility may be reduced to private in the future
    void
    Header.pointToData(Data o)
    Deprecated.
    Use the appropriate Header constructor instead.
    void
    AsciiTable.read(ArrayDataInput in)
     
    void
    BasicHDU.read(ArrayDataInput stream)
     
    void
    BinaryTable.read(ArrayDataInput in)
     
    void
    Data.read(ArrayDataInput in)
    Reads the data or skips over it for reading later, depending on whether reading from a stream or a random acessible input, respectively.
    BasicHDU<?>[]
    Fits.read()
    Return all HDUs for the Fits object.
    void
    Fits.read(InputStream is)
    Deprecated.
    Use Fits(InputStream) constructor instead.
    void
    FitsElement.read(ArrayDataInput in)
    Read a FITS element from the input, starting at the current position.
    void
    FitsHeap.read(ArrayDataInput str)
     
    void
    ImageData.read(ArrayDataInput in)
     
    BasicHDU<?>
    Fits.readHDU()
    Read the next HDU on the default input stream.
    static void
    FitsUtil.reposition(FitsIO o, long offset)
    Deprecated.
    This method wraps an IOException into a FitsException for no good reason really.
    void
    BasicHDU.rewrite()
     
    void
    Data.rewrite()
     
    void
    Fits.rewrite()
    Re-writes all HDUs that have been loaded (and possibly modified) to the disk, if possible -- or else does nothing.
    void
    FitsElement.rewrite()
    Rewrite the contents of the element in place.
    void
    FitsHeap.rewrite()
     
    void
    Header.rewrite()
     
    void
    BinaryTable.set(int row, int col, Object o)
    The Swiss-army knife of setting table entries, including Java boxing, and with some support for automatic type conversions.
    void
    BasicHDU.setChecksum()
    Computes the checksums for this HDU and stores the CHECKSUM and DATASUM values in the header.
    void
    Fits.setChecksum()
    Add or modify the CHECKSUM keyword in all headers.
    void
    Fits.setChecksum(int hduIndex)
    Computes the CHECKSUM and DATASUM values for the specified HDU index and stores them in the HUS's header.
    static void
    Fits.setChecksum(BasicHDU<?> hdu)
    Deprecated.
    use FitsCheckSum.setChecksum(BasicHDU)
    void
    AsciiTable.setColumn(int col, Object newData)
     
    void
    BinaryTable.setColumn(int col, Object o)
     
    void
    TableData.setColumn(int col, Object newCol)
    Sets new data for a table column.
    void
    TableHDU.setColumn(int col, Object newCol)
    Update a column within a table.
    void
    TableHDU.setColumn(String colName, Object newCol)
    Update a column within a table.
    boolean
    BinaryTable.setComplexColumn(int index)
    Convert a column from float/double to float complex/double complex.
    boolean
    BinaryTableHDU.setComplexColumn(int index)
    Convert a column in the table to complex.
    void
    AsciiTable.setElement(int row, int col, Object newData)
     
    void
    BinaryTable.setElement(int row, int col, Object o)
    Consider using the more Java-friendly BinaryTable.set(int, int, Object) with implicit scalar type conversions.
    void
    TableData.setElement(int row, int col, Object element)
    Sets new data element in this table.
    void
    TableHDU.setElement(int row, int col, Object element)
    Update a single element within the table.
    void
    BinaryTable.setFlattenedColumn(int col, Object data)
    Deprecated.
    (for internal use) It may be reduced to private visibility in the future.
    void
    AsciiTable.setRow(int row, Object[] newData)
     
    void
    BinaryTable.setRow(int row, Object[] data)
     
    void
    TableData.setRow(int row, Object[] newRow)
    Sets new data for a table row.
    void
    TableHDU.setRow(int row, Object[] newRow)
    Update a row within a table.
    default void
    TableData.setRowEntries(int row, Object... entries)
    Like TableData.setRow(int, Object[]) but with vararg list of entries.
    int
    Fits.size()
    Deprecated.
    The meaning of size of ambiguous.
    void
    Fits.skipHDU()
    Skip the next HDU on the default input stream.
    void
    Fits.skipHDU(int n)
    Skip HDUs on the associate input stream.
    BinaryTableHDU
    BinaryTable.toHDU()
     
    abstract BasicHDU<?>
    Data.toHDU()
    Returns an approprotae HDU object that encapsulates this FITS data, and contains the minimal mandatory header description for that data.
    ImageHDU
    ImageData.toHDU()
     
    RandomGroupsHDU
    RandomGroupsData.toHDU()
     
    void
    AsciiTable.updateAfterDelete(int oldNCol, Header hdr)
    Deprecated.
    It is not entirely foolproof for keeping the header in sync -- it is better to (re)wrap tables in a new HDU and editing the header as necessary to incorporate custom entries.
    void
    BinaryTable.updateAfterDelete(int oldNcol, Header hdr)
    Deprecated.
    It is not entirely foolproof for keeping the header in sync -- it is better to (re)wrap tables in a new HDU after column deletions, and then edit the new header as necessary to incorporate custom entries.
    void
    TableData.updateAfterDelete(int oldNcol, Header hdr)
    Deprecated.
    It is not entirely foolproof for keeping the header in sync -- it is better to (re)wrap tables in a new HDU after column deletions, and then edit the new header as necessary to incorporate custom entries.
    void
    Header.validate(boolean asPrimary)
    Validates this header by making it a proper primary or extension header.
    boolean
    BasicHDU.verifyDataIntegrity()
    Checks that the HDUs data checksum is correct.
    boolean
    BasicHDU.verifyIntegrity()
    Checks the HDU's integrity, using the recorded CHECKSUM and/or DATASUM keywords if present.
    void
    Fits.verifyIntegrity()
    Checks the integrity of all HDUs.
    static BinaryTableHDU
    BinaryTableHDU.wrap(BinaryTable tab)
    Wraps the specified table in an HDU, creating a header for it with the essential table description.
    void
    AsciiTable.write(ArrayDataOutput str)
     
    void
    BasicHDU.write(ArrayDataOutput stream)
     
    void
    BinaryTable.write(ArrayDataOutput os)
     
    void
    BinaryTableHDU.write(ArrayDataOutput out)
     
    abstract void
    Data.write(ArrayDataOutput o)
     
    void
    Fits.write(DataOutput os)
    Deprecated.
    This method is poorly conceived as we cannot really write FITS to just any DataOutput but only to specific ArrayDataOutput, which utilize FitsEncoder to convert Java types to FITS binary format, such as FitsOutputStream or FitsFile (or else a wrapped DataOutputStream).
    void
    Fits.write(File file)
    Writes the contents to a new file.
    void
    Fits.write(String fileName)
    Writes the contents to the specified file.
    void
    Fits.write(FitsFile file)
    Writes the contents to a designated FITS file.
    void
    Fits.write(FitsOutputStream out)
    Writes the contents to a designated FITS output stream.
    void
    FitsElement.write(ArrayDataOutput out)
    Writes the contents of the element to a data sink, adding padding as necessary if the element (such as a header or data segment) is expected to complete the FITS block of 2880 bytes.
    void
    FitsHeap.write(ArrayDataOutput str)
     
    void
    Header.write(ArrayDataOutput out)
     
    void
    ImageData.write(ArrayDataOutput o)
     
    void
    RandomGroupsData.write(ArrayDataOutput str)
     
    void
    RandomGroupsHDU.write(ArrayDataOutput stream)
     
    void
    UndefinedData.write(ArrayDataOutput o)
     
    void
    Header.writeUnchecked(ArrayDataOutput out)
    (for internal use) Similar to Header.write(ArrayDataOutput), but writes the header as is, without ensuring that mandatory keys are present, and in the correct order, or that checksums are updated.
    Constructors in nom.tam.fits that throw FitsException
    Modifier
    Constructor
    Description
     
    AsciiTable(Header hdr)
    Deprecated.
    (for internal use) Visibility may be reduced to the package level in the future.
     
    AsciiTable(Header hdr, boolean preferInt)
    Deprecated.
    Use AsciiTable.setI10PreferInt(boolean) instead prior to reading ASCII tables.
     
    BinaryTable(Object[] columns)
    Deprecated.
    The constructor is ambiguous, use BinaryTable.fromColumnMajor(Object[]) instead.
     
    BinaryTable(Object[][] rowColTable)
    Deprecated.
    The constructor is ambiguous, use BinaryTable.fromRowMajor(Object[][]) instead.
     
    BinaryTable(Header header)
    Deprecated.
    (for internal use) This constructor should only be called from a Fits object reading an input; visibility may be reduced to the package level in the future.
     
    BinaryTable(ColumnTable<?> tab)
    Deprecated.
    DO NOT USE -- it will be removed in the future.
     
    ColumnDesc(Class<?> base, int... dim)
    Creates a new column descriptor for the specified boxed Java type, and fixed array shape.
     
    Fits(File myFile)
    Creates a new (empty) FITS container associated with a file input.
     
    Fits(File myFile, boolean compressed)
    Deprecated.
    Use Fits(File) instead (compression is auto detected).
     
    Fits(InputStream str)
    Creates a new (empty) FITS container associated with the given input stream.
     
    Fits(InputStream str, boolean compressed)
    Deprecated.
    Use Fits(InputStream) instead (compression is auto detected).
     
    Fits(String filename)
    Creates a new (empty) FITS container with a file or URL as its input.
     
    Fits(String filename, boolean compressed)
    Deprecated.
    Use Fits(String) instead (compression is auto detected).
     
    Fits(URL myURL)
    Creates a new (empty) FITS container with a given URL as its input.
     
    Fits(URL myURL, boolean compressed)
    Deprecated.
    Use Fits(URL) instead (compression is auto detected).
     
    Fits(FitsFile src)
    Creates a new (empty) FITS container associated with FitsFile input.
     
    Fits(RandomAccessFileIO src)
    Creates a new (empty) FITS container associated with an input that supports generalized random access.
     
    FitsDate(String dStr)
    Convert a FITS date string to a Java Date object.
     
    Header(Data o)
    Create a header which points to the given data object.
     
    ImageData(Header h)
    (for internal use) Create an array from a header description.
     
    UndefinedData(Header h)
    Deprecated.
    (for internal use).

  • Uses of FitsException in nom.tam.fits.header

    Methods in nom.tam.fits.header that throw FitsException
    Modifier and Type
    Method
    Description
    void
    Stokes.Parameters.fillImageHeader(Header header, int coordinateIndex)
    Adds WCS description for the coordinate axis containing Stokes parameters.
    void
    Stokes.Parameters.fillTableHeader(Header header, int column, int coordinateIndex)
    Adds WCS description for the coordinate axis containing Stokes parameters to a table column containign images.
    static Bitpix
    Bitpix.forArrayID(char id)
    Returns the standard BITPIX object for the given Java array ID.
    static Bitpix
    Bitpix.forNumberType(Class<? extends Number> dataType)
    Returns the standard BITPIX object for a number type.
    static Bitpix
    Bitpix.forPrimitiveType(Class<?> dataType)
    Returns the standard BITPIX object for a primitive type.
    static Bitpix
    Bitpix.forValue(int ival)
    Returns the standard BITPIX enum value for a given integer value, such as 8, 16, 32, 64, -32, or -64.
    static Bitpix
    Bitpix.forValue(int ival, boolean allowRepair)
    Returns the standard BITPIX enum value for a given integer value, such as 8, 16, 32, 64, -32, or -64.
    static Bitpix
    Bitpix.fromHeader(Header h)
    Returns the standard BITPIX object based on the value assigned to the BITPIX keyword in the header
    static Bitpix
    Bitpix.fromHeader(Header h, boolean allowRepair)
    Returns the standard BITPIX object based on the value assigned to the BITPIX keyword in the header
    static Map.Entry<Integer,Stokes.Parameters>
    Stokes.fromImageHeader(Header header)
    Returns a mapping of a Java array dimension to a set of Stokes parameters, based on the WCS coordinate description in the image header.
    static Map.Entry<Integer,Stokes.Parameters>
    Stokes.fromTableHeader(Header header, int column)
    Returns a mapping of a Java array dimension to a set of Stokes parameters, based on the WCS coordinate description in the image header.

  • Uses of FitsException in nom.tam.fits.utilities

    Methods in nom.tam.fits.utilities that throw FitsException
    Modifier and Type
    Method
    Description
    static long
    FitsCheckSum.checksum(BasicHDU<?> hdu)
    Deprecated.
    Use BasicHDU.verifyIntegrity() instead to verify checksums.
    static long
    FitsCheckSum.checksum(Data data)
    Deprecated.
    Use BasicHDU.verifyIntegrity() instead.
    static long
    FitsCheckSum.checksum(Header header)
    Deprecated.
    Use BasicHDU.verifyIntegrity() instead.
    static long
    FitsCheckSum.getStoredChecksum(Header header)
    Deprecated.
    Not very useful, since it has no meaning other than ensuring that the checksum of the HDU yields (int) -1 (that is 0xffffffff) after including this value for the CHECKSUM keyword in the header.
    static long
    FitsCheckSum.getStoredDatasum(Header header)
    Returns the DATASUM value stored in a FITS header.
    static void
    FitsCheckSum.setChecksum(BasicHDU<?> hdu)
    Computes and sets the DATASUM and CHECKSUM keywords for a given HDU.
    static void
    FitsCheckSum.setDatasum(Header header, long datasum)
    Sets the DATASUM and CHECKSUM keywords in a FITS header, based on the provided checksum of the data (calculated elsewhere) and the checksum calculated afresh for the header.

  • Uses of FitsException in nom.tam.image

    Methods in nom.tam.image that throw FitsException
    Modifier and Type
    Method
    Description
    void
    StreamingTileImageData.write(ArrayDataOutput o)
     
    Constructors in nom.tam.image that throw FitsException
    Modifier
    Constructor
    Description
     
    StreamingTileImageData(Header header, ImageTiler tiler, int[] corners, int[] lengths, int[] steps)
    Constructor for a tile image data object.

  • Uses of FitsException in nom.tam.image.compression.hdu

    Methods in nom.tam.image.compression.hdu that throw FitsException
    Modifier and Type
    Method
    Description
    BinaryTableHDU
    CompressedTableHDU.asBinaryTableHDU()
    Restores the original binary table HDU by decompressing the data contained in this compresed table HDU.
    final BinaryTableHDU
    CompressedTableHDU.asBinaryTableHDU(int tile)
    Restores a section of the original binary table HDU by decompressing a single compressed table tile.
    BinaryTableHDU
    CompressedTableHDU.asBinaryTableHDU(int fromTile, int toTile)
    Restores a section of the original binary table HDU by decompressing a selected range of compressed table tiles.
    ImageHDU
    CompressedImageHDU.asImageHDU()
    Restores the original image HDU by decompressing the data contained in this compresed image HDU.
    void
    CompressedImageHDU.compress()
    Performs the actual compression with the selected algorithm(s) and options.
    void
    CompressedTableData.compress(Header header)
    (for internal use) This should only be called by CompressedTableHDU, and should have reduced visibility accordingly.
    CompressedTableHDU
    CompressedTableHDU.compress()
    Performs the actual compression with the selected algorithm(s) and options.
    long
    CompressedTableData.defragment()
     
    void
    CompressedImageData.fillHeader(Header h)
     
    void
    CompressedTableData.fillHeader(Header h)
     
    static CompressedTableHDU
    CompressedTableHDU.fromBinaryTableHDU(BinaryTableHDU binaryTableHDU, int tileRows, String... columnCompressionAlgorithms)
    Prepare a compressed binary table HDU for the specified binary table.
    static CompressedImageHDU
    CompressedImageHDU.fromImageHDU(ImageHDU imageHDU, int... tileAxis)
    Prepare a compressed image hdu for the specified image. the tile axis that are specified with -1 default to tiling by rows.
    Object
    CompressedTableHDU.getColumnData(int col)
    Returns a particular section of a decompressed data column.
    Object
    CompressedTableHDU.getColumnData(int col, int fromTile, int toTile)
    Returns a particular section of a decompressed data column.
    int[]
    CompressedImageHDU.getImageAxes()
    Given this compressed HDU, get the original (decompressed) axes.
    ImageHDU
    CompressedImageHDU.getTileHDU(int[] corners, int[] lengths)
    Returns an ImageHDU, with the specified decompressed image area.
    int
    CompressedTableHDU.getTileRows()
    Returns the number of table rows that are compressed in each table tile.
    Buffer
    CompressedImageHDU.getUncompressedData()
    Deprecated.
    (for internal use) There is no reason why this should be exposed to users.
    static CompressedImageData
    CompressedImageHDU.manufactureData(Header hdr)
    Deprecated.
    (for internal use) Will reduce visibility in the future
    static CompressedTableData
    CompressedTableHDU.manufactureData(Header hdr)
    Deprecated.
    (for internal use) Will reduce visibility in the future
    void
    CompressedTableData.prepareUncompressedData(ColumnTable<?> data)
    Deprecated.
    (for internal use) This should only be called by CompressedTableHDU, and its visibility will be reduced accordingly in the future, not to mention that it should take a BinaryTable as its argument.
    CompressedImageHDU
    CompressedImageHDU.setCompressAlgorithm(String compressAlgorithm)
    Sets the compression algorithm to use, by its standard FITS name.
    CompressedImageHDU
    CompressedImageHDU.setQuantAlgorithm(String quantAlgorithm)
    Sets the quantization algorithm to use, by its standard FITS name.
    Constructors in nom.tam.image.compression.hdu that throw FitsException
    Modifier
    Constructor
    Description
     
    CompressedTableData(Header header)
    Creates a new compressed table data based on the prescription of the supplied header.

  • Uses of FitsException in nom.tam.util

    Subclasses of FitsException in nom.tam.util
    Modifier and Type
    Class
    Description
    class 
    TableException
    For when attempting to do something illegal or invalid with FITS tables.