Skip navigation links
  • Overview
  • Package
  • Class
  • Tree
  • Deprecated
  • Index
  • Help

Deprecated API

Contents

  • Interfaces
  • Classes
  • Enum Classes
  • Fields
  • Methods
  • Constructors
  • Enum Constants
  • Deprecated Interfaces
    Interface
    Description
    nom.tam.fits.compression.provider.param.api.IHeaderAccess
    This internal interface serves no purpose since 1.19. Will remove in some future. Prior to 1.19 Header threw hard HeaderCardException, and this class was added so we can convert these into soft IllegalArgumentException instead. However, now that we demoted HeaderCardException to be soft exceptions itself, there is no reason to convert. It just adds confusion.
  • Deprecated Classes
    Class
    Description
    nom.tam.fits.AbstractTableData
    Serves no purpose really. It can be removed in the future, letting AsciiTable extend Data and implement TableData instead.
    nom.tam.fits.BinaryTable.SaveState
    (for internal use) no longer used, and will be removed in the future.
    nom.tam.fits.compress.BasicCompressProvider
    Use ZCompressionProvider. or the more generic CompressionManager with a preference toward using the system command if possible. instead.
    nom.tam.fits.compress.CloseIS
    Needed only by deprecated compression classes. And it should not have visibility outside of this package anyway.
    nom.tam.fits.compress.CompressionLibLoaderProtection
    (for internal use) The visibility of this class may be reduced to package level in the future.
    nom.tam.fits.compress.ExternalBZip2CompressionProvider
    Use ZCompressionProvider, or the more generic CompressionManager with a preference toward using the system command if possible, instead.
    nom.tam.fits.compression.algorithm.hcompress.HCompressorQuantizeOption
    (for internal use) This class should not be exposed to users.

    Options to the HCompress compression algorithm when the compression includes quantization. When compressing tables and images using the HCompress algorithm, including quantization, users can control how exactly the compression and quantization are perfomed. When reading compressed FITS files, these options will be set automatically based on the header values recorded in the compressed HDU.

    nom.tam.fits.compression.algorithm.quant.Quantize
    (for internal use) This class sohuld have visibility reduced to the package level
    nom.tam.fits.compression.algorithm.rice.BitBuffer
    (for internal use) Its visibility may be reduced to the package level in the future.
    nom.tam.fits.compression.algorithm.rice.RiceQuantizeCompressOption
    (for internal use) This class should not be exposed to users.

    Options to the Rice compression algorithm when the compression includes quantization. When compressing tables and images using the Rice algorithm, including quantization, users can control how exactly the compression and quantization are perfomed. When reading compressed FITS files, these options will be set automatically based on the header values recorded in the compressed HDU.

    nom.tam.fits.compression.provider.param.api.HeaderAccess
    This class serves no purpose since 1.19. Will remove in some future. Prior to 1.19 Header threw hard HeaderCardException, and this class was added so we can convert these into soft IllegalArgumentException instead. However, now that we demoted HeaderCardException to be soft exceptions itself, there is no reason to convert. It just adds confusion.
    nom.tam.fits.compression.provider.param.api.HeaderCardAccess
    This class serves no purpose since 1.19. Will remove in some future. Prior to 1.19 Header threw hard HeaderCardException, and this class was added so we can convert these into soft IllegalArgumentException instead. However, now that we demoted HeaderCardException to be soft exceptions itself, there is no reason to convert. It just adds confusion.
    nom.tam.fits.header.FitsHeaderImpl
    Use the more intuitively named FitsKey class instead. This class is provided for compatibility with prior releases.
    nom.tam.fits.header.GenericKey
    This class duplicates functionality that is available in FitsKey, Standard, ans/or IFitsHeader.
    nom.tam.fits.header.hierarch.BlanksDotHierarchKeyFormatter
    Non-standard HIERARCH keyword formatter that separates hierarchical keyword component by multiple while spaces. Otherwise, it is similar to StandardIHierarchKeyFormatter. Its use over the more standard formatter is discouraged.
    nom.tam.fits.HeaderCardCountingArrayDataInput
    (for internal use) This class should not have public visibility. And really, the counting should be completely internalized by HeaderCard. Perhaps remove in a future major release.
    nom.tam.fits.HeaderCommentsMap
    (for internal use) No longer needed
    nom.tam.fits.HeaderOrder
    (for internal use) Visibility should be reduced to package level in the future
    nom.tam.fits.utilities.FitsLineAppender
    (for internal use) Replaced by the package-level nom.tam.fits.HeaderCardFormatter.
    nom.tam.fits.utilities.FitsSubString
    (for internal use) Was used by FitsLineAppender only.
    nom.tam.image.tile.operation.buffer.TileBufferRowBased
    Use TileBufferFactory instead to construct and access via TileBuffer interface. Its visiv=bility should be reduced to the package level in the future.
    nom.tam.util.array.MultiArrayCopyFactory
    (for internal use) use MultiArrayCopier instead. Make copies of multi-dimensional arrays.
    nom.tam.util.array.MultiArrayPointer
    ()for internal use) Visibility may be reduced to the package level in the future. A multi-dimensional array index. Used only by MultiArrayCopier and MultiArrayIterator.
    nom.tam.util.BufferDecoder
    Use FitsDecoder instead which provides a similar function but in a more consistent way and with a less misleading name. This is a rusty rail implementation for of an older abandoned class only, unsafe for general use. For reading non-FITS encoding you may also use InputDecoder as a base for implementing efficient custom decoding of binary inputs in general.
    nom.tam.util.BufferedDataInputStream
    Use FitsInputStream instead which provides the same functionality with a less misleading name, or else use ArrayInputStream as a base for a more generic implementation for any (non-FITS) encoding.
    nom.tam.util.BufferedDataOutputStream
    Use FitsOutputStream, which provides the exact same functionality but with a less misleading name, or else use ArrayOutputStream as a base for an implementation with any (non-FITS) encoding.
    nom.tam.util.BufferedFile
    Use FitsFile instead, which replaces the old BufferedFile with a less misleading name, or else ArrayDataFile, which provides a base for a more more generic implementation for efficient reading/writing arrays using any (non-FITS) encoding.
    nom.tam.util.BufferEncoder
    Use FitsEncoder instead which provides a similar function but in a more consistent way and with a less misleading name. This is a rusty rail implementation for of an older abandoned class only, unsafe for general use. For writing non-FITS encoding you may also use OutputEncoder as a base for implementing efficient custom encoding of binary outputs in general.
    nom.tam.util.BufferPointer
    (for internal use) It is a rusty-rail compatibility implementation only, unsafe for general use. No longer used within the FITS package itself. If you do attempt to use it with the deprecated APIs, beware that no data will be filled into the buffer of this object ever by the library, although its length and position fields may be updated to pretend as if the buffer were always hall full / half available...
    nom.tam.util.ByteFormatter
    This class should not be exposed in the public API and is intended for internal use only in ASCII tables. Also, it may have overlapping functionality with other classes, which should probably be eliminated for simplicity's sake (and thus less chance of nasty bugs).
    nom.tam.util.ByteParser
    This class should not be exposed in the public API and is intended for internal use only in ASCII tables. Also, it may have overlapping functionality with other classes, which should probably be eliminated for simplicity's sake (and thus less chance of nasty bugs).
    nom.tam.util.SafeClose
    Use try-with-resources constructs of Java 8+ instead.
    nom.tam.util.type.PrimitiveType
    Use ElementType instead.
    nom.tam.util.type.PrimitiveTypeBase
    Use ElementType instead.
    nom.tam.util.type.PrimitiveTypeHandler
    Use equivalent static methods of ElementType instead.
    nom.tam.util.type.PrimitiveTypes
    Use identical static fields of ElementType instead.
  • Deprecated Enum Classes
    Enum Class
    Description
    nom.tam.fits.header.extra.CXCStclSharedExt
    This enum is duplicated by both CXCExt and STScIExt, and users would (should) typically use one or the other.
  • Deprecated Fields
    Field
    Description
    nom.tam.fits.BasicHDU.BITPIX_BYTE
    Use Bitpix.VALUE_FOR_BYTE instead.
    nom.tam.fits.BasicHDU.BITPIX_DOUBLE
    Use Bitpix.VALUE_FOR_DOUBLE instead.
    nom.tam.fits.BasicHDU.BITPIX_FLOAT
    Use Bitpix.VALUE_FOR_FLOAT instead.
    nom.tam.fits.BasicHDU.BITPIX_INT
    Use Bitpix.VALUE_FOR_INT instead.
    nom.tam.fits.BasicHDU.BITPIX_LONG
    Use Bitpix.VALUE_FOR_LONG instead.
    nom.tam.fits.BasicHDU.BITPIX_SHORT
    Use Bitpix.VALUE_FOR_SHORT instead.
    nom.tam.fits.Data.dataSize
    Will be removed. Use Data.getTrueSize() instead. The size of the data when last read
    nom.tam.fits.Data.fileOffset
    Will be private. Access via Data.getFileOffset() The starting location of the data when last read
    nom.tam.fits.Data.input
    Will be private. Use Data.getRandomAccessInput() instead. The input stream used.
    nom.tam.fits.header.DateTime.TIMESYS_GMT
    Greenwich Mean time (GMT) timescale value; deprecated by the FITS standard, use DateTime.TIMESYS_UTC instead.
    nom.tam.fits.header.DateTime.TIMESYS_IAT
    Deprecated by the FITS standard, use DateTime.TIMESYS_TAI instead.
    nom.tam.fits.Header.MAX_COMMENT_ALIGN
    We will disable changing alignment in the future because it may violate the standard for 'fixed-format' header entries, and result in files that are unreadable by some other software. This constant will be obsoleted and removed.
    nom.tam.fits.Header.MIN_COMMENT_ALIGN
    We will disable changing alignment in the future because it may violate the standard for 'fixed-format' header entries, and result in files that are unreadable by some other software. This constant will be obsoleted and removed.
    nom.tam.util.type.ElementType.COPY_BLOCK_SIZE
    (for internal use) It's visibility may be reduced to the package level in the future.
    nom.tam.util.type.PrimitiveTypes.BOOLEAN
    Use ElementType.BOOLEAN instead
    nom.tam.util.type.PrimitiveTypes.BYTE
    Use ElementType.BYTE instead
    nom.tam.util.type.PrimitiveTypes.CHAR
    Use ElementType.CHAR instead
    nom.tam.util.type.PrimitiveTypes.DOUBLE
    Use ElementType.DOUBLE instead
    nom.tam.util.type.PrimitiveTypes.FLOAT
    Use ElementType.FLOAT instead
    nom.tam.util.type.PrimitiveTypes.INT
    Use ElementType.INT instead
    nom.tam.util.type.PrimitiveTypes.LONG
    Use ElementType.LONG instead
    nom.tam.util.type.PrimitiveTypes.SHORT
    Use ElementType.SHORT instead
    nom.tam.util.type.PrimitiveTypes.STRING
    Use ElementType.STRING instead
    nom.tam.util.type.PrimitiveTypes.UNKNOWN
    Use ElementType.UNKNOWN instead
  • Deprecated Methods
    Method
    Description
    nom.tam.fits.AsciiTable.updateAfterDelete(int, Header)
    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. May be removed from the API in the future.
    nom.tam.fits.AsciiTableHDU.encapsulate(Object)
    (for internal use) Use AsciiTable.fromColumnMajor(Object[]) instead. Will reduce visibility in the future
    nom.tam.fits.AsciiTableHDU.isData(Object)
    (for internal use) Will reduce visibility in the future
    nom.tam.fits.AsciiTableHDU.isHeader(Header)
    (for internal use) Will reduce visibility in the future
    nom.tam.fits.AsciiTableHDU.manufactureData(Header)
    (for internal use) Will reduce visibility in the future
    nom.tam.fits.AsciiTableHDU.manufactureHeader(Data)
    (for internal use) Will reduce visibility in the future
    nom.tam.fits.BasicHDU.calcChecksum()
    Use BasicHDU.verifyIntegrity() instead when appropriate. It's not particularly useful since integrity checking does not use or require knowledge of this sum. May be removed from future releases.
    nom.tam.fits.BasicHDU.getBitPix()
    (for internal use) Will reduce visibility or remove entirely in the future.
    nom.tam.fits.BasicHDU.getBlankValue()
    This is only applicable to ImageHDU or RandomGroupsHDU with integer type data and not for other HDU or data types.
    nom.tam.fits.BasicHDU.getBScale()
    This is only applicable to ImageHDU or RandomGroupsHDU with integer type data and not for other HDU or data types.
    nom.tam.fits.BasicHDU.getBUnit()
    This is only applicable to ImageHDU or RandomGroupsHDU and not for other HDU or data types.
    nom.tam.fits.BasicHDU.getBZero()
    This is only applicable to ImageHDU or RandomGroupsHDU with integer type data and not for other HDU or data types.
    nom.tam.fits.BasicHDU.getDummyHDU()
    Use NullDataHDU instead. Gets a HDU with no data, only header.
    nom.tam.fits.BasicHDU.getEpoch()
    use BasicHDU.getEquinox() instead
    nom.tam.fits.BasicHDU.getGroupCount()
    Should not be exposed outside of RandomGroupsHDU -- will reduce visibility in the future/
    nom.tam.fits.BasicHDU.getParameterCount()
    Should not be exposed outside of RandomGroupsHDU -- will reduce visibility in the future.
    nom.tam.fits.BasicHDU.getStoredChecksum()
    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. It will be removed in the future. Use BasicHDU.verifyIntegrity() instead when appropriate.
    nom.tam.fits.BasicHDU.getTrimmedString(String)
    (for internal use) Will reduced visibility in the future. Use Header.getStringValue(IFitsHeader) or similar instead followed by String.trim() if necessary.
    nom.tam.fits.BasicHDU.getTrimmedString(IFitsHeader)
    (for internal use) Will reduced visibility in the future. Use Header.getStringValue(String) or similar instead followed by String.trim() if necessary.
    nom.tam.fits.BasicHDU.isData(Object)
    (for internal use) Will be removed as it serves no purpose.
    nom.tam.fits.BasicHDU.isHeader(Header)
    (for internal use) Will be removed as it serves no purpose.
    nom.tam.fits.BinaryTable.addByteVaryingColumn()
    (for internal use) Used Only by CompressedTableData so it would make a better private method in there.. `
    nom.tam.fits.BinaryTable.addFlattenedColumn(Object, int...)
    (for internal use) No longer used, will be removed in the future
    nom.tam.fits.BinaryTable.ColumnDesc.getBase()
    Ambiguous, use BinaryTable.ColumnDesc.getLegacyBase() instead. It can be confusing since it is not clear if it refers to array element types used in FITS storage or on the java side when using the older array access, or if it refers to the class of entries in the main table, which may be heap pointers. It is also distinct from BinaryTable.ColumnDesc.getElementClass(), which returns the boxed type used by BinaryTable.get(int, int) or BinaryTable.set(int, int, Object).
    nom.tam.fits.BinaryTable.ColumnDesc.getDimens()
    (for internal use) Use BinaryTable.ColumnDesc.getEntryShape() instead. Not useful to users since it returns the dimensions of the primitive storage types, which is not always the dimension of table entries on the Java side.
    nom.tam.fits.BinaryTable.ColumnDesc.newInstance(int)
    (for internal use) This method should be private in the future.
    nom.tam.fits.BinaryTable.ColumnDesc.rowLen()
    (for internal use) It may be reduced to private visibility in the future. Returns the number of bytes that each element occupies in its FITS serialized form in the stored row data.
    nom.tam.fits.BinaryTable.createColumnDataFor(BinaryTable)
    (for internal use) It may become a private method in the future.
    nom.tam.fits.BinaryTable.createColumnTable(Object[], int[])
    (for internal use) This method should have visibility reduced to private
    nom.tam.fits.BinaryTable.fillHeader(Header)
    (for internal use) Visibility should be reduced to protected.
    nom.tam.fits.BinaryTable.getBases()
    (for internal use) Ambiguous, use BinaryTable.ColumnDesc.getElementClass() instead. Will remove in the future.
    nom.tam.fits.BinaryTable.getDimens()
    (for internal use) Use BinaryTable.ColumnDesc.getEntryShape() to access the shape of Java elements individually for columns instead. Not useful to users since it returns the dimensions of the primitive storage types, which is not always the dimension of elements on the Java side (notably for string entries).
    nom.tam.fits.BinaryTable.getFlatColumns()
    (for internal use) It may be private in the future.
    nom.tam.fits.BinaryTable.getFlattenedColumn(int)
    (for internal use) It may be reduced to private visibility in the future.
    nom.tam.fits.BinaryTable.getModelRow()
    (for internal use) Use BinaryTable.getElement(int, int) instead for low-level reading of tables in deferred mode. Not recommended for uses because it requires a deep understanding of how data (especially varialbe length columns) are represented in the FITS. Will reduce visibility to private in the future.
    nom.tam.fits.BinaryTable.getRawElement(int, int)
    (for internal use) Will reduce visibility in the future.
    nom.tam.fits.BinaryTable.getSizes()
    (for internal use) Use BinaryTable.ColumnDesc.getElementCount() instead. This one returns the number of elements in the FITS representation, not in the java representation. For example, for String entries, this returns the number of bytes stored, not the number of strings. Similarly, for complex values it returns the number of components not the number of values.
    nom.tam.fits.BinaryTable.getTypes()
    (for internal use) Use BinaryTable.ColumnDesc.getElementClass() instead. Not very useful to users since this returns the FITS primitive storage type for the data column.
    nom.tam.fits.BinaryTable.parseTDims(String)
    (for internal use) It may be reduced to private visibility in the future. Parse the TDIMS value. If the TDIMS value cannot be deciphered a one-d array with the size given in arrsiz is returned.
    nom.tam.fits.BinaryTable.readHeap(ArrayDataInput)
    (for internal use) unused.
    nom.tam.fits.BinaryTable.setFlattenedColumn(int, Object)
    (for internal use) It may be reduced to private visibility in the future. Sets a column with the data already flattened.
    nom.tam.fits.BinaryTable.updateAfterDelete(int, Header)
    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. May be removed from the API in the future.
    nom.tam.fits.BinaryTableHDU.encapsulate(Object)
    (for internal use) Use BinaryTable.fromColumnMajor(Object[]) or BinaryTable.fromRowMajor(Object[][]) instead. Will reduce visibility in the future.
    nom.tam.fits.BinaryTableHDU.isData(Object)
    (for internal use) Will reduce visibility in the future
    nom.tam.fits.BinaryTableHDU.isHeader()
    (for internal use) Will reduce visibility in the future
    nom.tam.fits.BinaryTableHDU.isHeader(Header)
    (for internal use) Will reduce visibility in the future
    nom.tam.fits.BinaryTableHDU.manufactureData(Header)
    (for internal use) Will reduce visibility in the future
    nom.tam.fits.BinaryTableHDU.manufactureHeader(Data)
    (for internal use) Will reduce visibility in the future
    nom.tam.fits.compression.algorithm.quant.QuantizeOption.getNullValueIndicator()
    use QuantizeOption.getBNull() instead (duplicate method). Returns the integer value that represents missing data (null) in the quantized representation.
    nom.tam.fits.compression.algorithm.quant.QuantizeOption.setCheckNull(boolean)
    QuantizeOption.setBNull(Integer) controls this feature automatically as needed. Sets whether we should expect the floating-point data to contain null values (normally NaNs).
    nom.tam.fits.compression.algorithm.quant.QuantizeOption.setCheckZero(boolean)
    It is strongly discouraged to treat 0.0 values as special. FITS only recognises NaN as a special floating-point value marking missing data. All other floating point values are considered valid measurements.
    nom.tam.fits.compression.algorithm.quant.QuantizeOption.setNullValue(double)
    The use of null values other than NaN for floating-point data types is not standard in FITS. You should therefore avoid using this method to change it. Returns the floating-point value that indicates a null datum in the image before quantization is applied. Normally, the FITS standard is that NaN values indicate null values in floating-point images. While this class allows using other values also, they are not recommended since they are not supported by FITS in a standard way.
    nom.tam.fits.compression.provider.param.api.ICompressColumnParameter.column()
    Provided for back compatibility only. Use ICompressColumnParameter.getColumnData() instead.
    nom.tam.fits.compression.provider.param.api.ICompressColumnParameter.column(Object, int)
    Provided for back compatibility only. Use ICompressColumnParameter.setColumnData(Object, int) instead.
    nom.tam.fits.compression.provider.param.api.ICompressColumnParameter.initializedColumn()
    Provided for back compatibility only. Use ICompressColumnParameter.getColumnData() instead.
    nom.tam.fits.compression.provider.param.api.ICompressColumnParameter.setValueFromColumn(int)
    Provided for back compatibility only. Use ICompressColumnParameter.setValueInColumn(int) instead.
    nom.tam.fits.compression.provider.param.api.ICompressHeaderParameter.getValueFromHeader(IHeaderAccess)
    Use ICompressHeaderParameter.getValueFromHeader(Header) instead.
    nom.tam.fits.compression.provider.param.api.ICompressHeaderParameter.setValueInHeader(IHeaderAccess)
    Use ICompressHeaderParameter.setValueInHeader(Header) instead
    nom.tam.fits.compression.provider.param.api.ICompressParameters.getValuesFromHeader(IHeaderAccess)
    Use ICompressParameters.getValuesFromHeader(Header) instead.
    nom.tam.fits.compression.provider.param.api.ICompressParameters.initializeColumns(IHeaderAccess, BinaryTable, int)
    Use ICompressParameters.initializeColumns(Header, BinaryTable, int) instead
    nom.tam.fits.compression.provider.param.api.ICompressParameters.setValueInColumn(int)
    Old, inconsistent method naming. Use ICompressParameters.setValuesInColumn(int) instead. set the option values, that are column based, into the columns at the specified index.
    nom.tam.fits.compression.provider.param.api.ICompressParameters.setValuesInHeader(IHeaderAccess)
    Use ICompressParameters.setValuesInHeader(Header) instead
    nom.tam.fits.compression.provider.param.api.IHeaderAccess.addValue(IFitsHeader, int)
    Just add values to the header directly
    nom.tam.fits.compression.provider.param.api.IHeaderAccess.addValue(IFitsHeader, String)
    Just add values to the header directly
    nom.tam.fits.compression.provider.param.api.IHeaderAccess.findCard(String)
    Use Header.getCard(String) instead.
    nom.tam.fits.compression.provider.param.api.IHeaderAccess.findCard(IFitsHeader)
    Use Header.getCard(IFitsHeader) instead.
    nom.tam.fits.compression.provider.param.base.CompressHeaderParameter.findZVal(IHeaderAccess)
    Use CompressHeaderParameter.findZVal(Header) instead.
    nom.tam.fits.compression.provider.param.base.CompressHeaderParameter.nextFreeZVal(IHeaderAccess)
    Use CompressHeaderParameter.nextFreeZVal(Header) instead.
    nom.tam.fits.Fits.calcChecksum(int)
    Use BasicHDU.verifyIntegrity() instead when appropriate. It's not particularly useful since integrity checking does not use or require knowledge of this sum. May be removed from future releases.
    nom.tam.fits.Fits.checksum(byte[])
    use FitsCheckSum.checksum(byte[])
    nom.tam.fits.Fits.currentSize()
    use Fits.getNumberOfHDUs() instead
    nom.tam.fits.Fits.fileInit(File, boolean)
    Will be private in 2.0. Get a stream from the file and then use the stream initialization.
    nom.tam.fits.Fits.randomInit(File)
    nom.tam.fits.Fits.read(InputStream)
    Use Fits(InputStream) constructor instead. We will remove this method in the future.
    nom.tam.fits.Fits.saveClose(InputStream)
    Use try-with-resources constructs in Java 8+ instead.
    nom.tam.fits.Fits.setChecksum(BasicHDU<?>)
    use FitsCheckSum.setChecksum(BasicHDU)
    nom.tam.fits.Fits.setStream(ArrayDataInput)
    This method is poorly conceived as we cannot really read FITS from just any ArrayDataInput but only those, which utilize FitsDecoder to convert Java types to FITS binary format, such as FitsInputStream or FitsFile (or else a wrapped DataInputStream). As such, this method is inherently unsafe as it can be used to parse FITS content iscorrectly. It will be removed from the public API in a future major release. Set the data stream to be used for future input.
    nom.tam.fits.Fits.size()
    The meaning of size of ambiguous. Use Fits.getNumberOfHDUs() instead. Note size() will read the input file/stream to the EOF before returning the number of HDUs which Fits.getNumberOfHDUs() does not. If you wish to duplicate this behavior and ensure that the input has been exhausted before getting the number of HDUs then use the sequence: read(); getNumberOfHDUs();
    nom.tam.fits.Fits.write(DataOutput)
    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). As such, this method is inherently unsafe as it can be used to create unreadable FITS files. It will be removed from a future major release. Use one of the more appropriate other write() methods instead. Writes the contents to an external file or stream. The file or stream remains open and it is up to the caller to close it as appropriate.
    nom.tam.fits.FitsFactory.dataFactory(Header)
    (for internal use) Will reduce visibility in the future
    nom.tam.fits.FitsFactory.FitsSettings.isSkipBlankAfterAssign()
    The FITS standard is very explicit that assignment must be "= " (equals followed by a space). If we allow skipping the space, it will result in a non-standard FITS, and may render it unreadable for other tools.
    nom.tam.fits.FitsFactory.hduFactory(Object)
    Use Fits.makeHDU(Object) instead (this method may either be migrated to Fits entirely or else have visibility reduced to the package level).
    nom.tam.fits.FitsFactory.hduFactory(Header, DataClass)
    (for internal use)/ Will reduce visibility in the future
    nom.tam.fits.FitsFactory.HDUFactory(Object)
    Use Fits.makeHDU(Object) instead (will removed in the future. Duplicate of FitsFactory.hduFactory(Object)
    nom.tam.fits.FitsFactory.HDUFactory(Header, DataClass)
    (duplicate method for internal use) Same as FitsFactory.hduFactory(Header, Data), and will be removed in the future.
    nom.tam.fits.FitsFactory.isSkipBlankAfterAssign()
    The FITS standard is very explicit that assignment must be "= " (equals followed by a blank space). If we allow skipping the space, it will result in a non-standard FITS, that is likely to break compatibility with other tools.
    nom.tam.fits.FitsFactory.setSkipBlankAfterAssign(boolean)
    The FITS standard is very explicit that assignment must be "= " (equals followed by a blank space). It is also very specific that string values must have their opening quote in byte 11 (counted from 1). If we allow skipping the space, we will violate both standards in a way that is likely to break compatibility with other tools.
    nom.tam.fits.FitsUtil.addPadding(int)
    use FitsUtil.addPadding(long) instead. Calculates the amount of padding needed to complete the last FITS block at the specified current size.
    nom.tam.fits.FitsUtil.byteArrayToStrings(byte[], int)
    (for internal use) No longer used internally, will be removed in the future.
    nom.tam.fits.FitsUtil.findOffset(Closeable)
    (for internal use) Visibility may be reduced to the package level in the future.
    nom.tam.fits.FitsUtil.maxLength(String[])
    (for internal use) No longer used internally, may be removed in the future.
    nom.tam.fits.FitsUtil.pad(ArrayDataOutput, long)
    (for internal use) Visibility may be reduced to package level in the future
    nom.tam.fits.FitsUtil.pad(ArrayDataOutput, long, byte)
    (for internal use) Visibility may be reduced to private in the future
    nom.tam.fits.FitsUtil.padding(int)
    see Use FitsUtil.padding(long) instead.
    nom.tam.fits.FitsUtil.reposition(FitsIO, long)
    This method wraps an IOException into a FitsException for no good reason really. A revision of the API could reduce the visibility of this method, and/or procees the underlying exception instead.
    nom.tam.fits.FitsUtil.stringsToByteArray(String[], int)
    (for internal use) Visibility may be reduced to package level in the future.
    nom.tam.fits.Header.addHexValue(String, long, String)
    Not supported by the FITS standard, so do not use. It was included due to a misreading of the standard itself. We will remove this method in the future.
    nom.tam.fits.Header.findKey(String)
    Use Header.findCard(String) or Header.getCard(String) instead. Find the card associated with a given key.
    nom.tam.fits.header.GenericKey.create(String)
    Use FitsKey(String, VALUE, String) instead.
    nom.tam.fits.header.GenericKey.create(String[])
    (for internal use) Creates a array of generic FITS header keys. The resulting keys have no HDU assignment or value type restrictions, not default comments. As such they may be used for accessing existing keys by the specified names, more so than for adding new values.
    nom.tam.fits.header.GenericKey.getN(String)
    Use IFitsHeader.extractIndices(String) instead.
    nom.tam.fits.header.GenericKey.lookup(String)
    Use Standard.match(String) instead.
    nom.tam.fits.Header.getBigDecimalValue(String)
    The FITS header does not support decimal types beyond those that can be represented by a 64-bit IEEE double-precision floating point value.
    nom.tam.fits.Header.getBigDecimalValue(String, BigDecimal)
    The FITS header does not support decimal types beyond those that can be represented by a 64-bit IEEE double-precision floating point value.
    nom.tam.fits.Header.getBigDecimalValue(IFitsHeader)
    The FITS header does not support decimal types beyond those that can be represented by a 64-bit IEEE double-precision floating point value.
    nom.tam.fits.Header.getBigDecimalValue(IFitsHeader, BigDecimal)
    The FITS header does not support decimal types beyond those that can be represented by a 64-bit IEEE double-precision floating point value.
    nom.tam.fits.Header.getBigIntegerValue(String)
    The FITS header does not support integer types beyond those that can be represented by a 64-bit integer.
    nom.tam.fits.Header.getBigIntegerValue(String, BigInteger)
    The FITS header does not support integer types beyond those that can be represented by a 64-bit integer.
    nom.tam.fits.Header.getBigIntegerValue(IFitsHeader)
    The FITS header does not support integer types beyond those that can be represented by a 64-bit integer.
    nom.tam.fits.Header.getBigIntegerValue(IFitsHeader, BigInteger)
    The FITS header does not support integer types beyond those that can be represented by a 64-bit integer.
    nom.tam.fits.Header.getCard(int)
    An iterator from Header.iterator(int) or Header.iterator() should be used for sequential access to the header.
    nom.tam.fits.Header.getHexValue(String)
    Not supported by the FITS standard, so do not use. It was included due to a misreading of the standard itself.
    nom.tam.fits.Header.getHexValue(String, long)
    Not supported by the FITS standard, so do not use. It was included due to a misreading of the standard itself.
    nom.tam.fits.Header.getKey(int)
    An iterator from Header.iterator(int) or Header.iterator() should be used for sequential access to the header.
    nom.tam.fits.Header.getOriginalSize()
    for internal use) It should be a private method in the future. Returns the original size of the header in the stream from which it was read.
    nom.tam.fits.Header.iterator(int)
    We should never use indexed access to the header. This function will be removed in 2.0.
    nom.tam.fits.Header.makeData()
    (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. In either case, there is no benefit of exposing such a function as this to the user.
    nom.tam.fits.Header.pointToData(Data)
    Use the appropriate Header constructor instead. Will remove in a future releae.
    nom.tam.fits.Header.removeCard(String)
    (duplicate method) Use Header.deleteKey(String) instead.
    nom.tam.fits.Header.resetOriginalSize()
    Use Header.ensureCardSpace(int) with 1 as the argument instead.

    Resets any prior preallocated header space, such as was explicitly set by Header.ensureCardSpace(int), or when the header was read from a stream to ensure it remains rewritable, if possible.

    For headers read from a stream, this will affect Header.rewriteable(), so users should not call this method unless they do not intend to Header.rewrite() this header into the original FITS.

    nom.tam.fits.Header.setBitpix(int)
    Use the safer Header.setBitpix(Bitpix) instead.
    nom.tam.fits.Header.setBitpix(Bitpix)
    (for internall use) Visibility will be reduced to the package level in the future.
    nom.tam.fits.Header.setCommentAlignPosition(int)
    Not recommended as it may violate the FITS standart for 'fixed-format' header entries, and make our FITS files unreadable by software that expects strict adherence to the standard. We will remove this feature in the future.
    nom.tam.fits.Header.setLongStringsEnabled(boolean)
    nom.tam.fits.Header.setNaxes(int)
    (for internal use) Visibility will be reduced to the package level in the future.
    nom.tam.fits.Header.setNaxis(int, int)
    (for internal use) Visibility will be reduced to the package level in the future.
    nom.tam.fits.Header.setSimple(boolean)
    (for internall use) Visibility will be reduced to the package level in the future.
    nom.tam.fits.Header.setXtension(String)
    (for internall use) Visibility will be reduced to the package level in the future.
    nom.tam.fits.Header.size()
    use Header.getNumberOfCards(). The units of the size of the header may be unclear.
    nom.tam.fits.header.Standard.context(Class<?>)
    (for internal use) Using HeaderCard.setComment(String) after creating a header card with this keyword provides a more transparent way of setting context-specific comments. This convoluted approach is no longer supported and will be removed in the future.
    nom.tam.fits.header.Standard.getCommentByKey(String)
    ()for internal use)
    nom.tam.fits.header.Standard.setCommentByKey(String, String)
    ()for internal use)
    nom.tam.fits.HeaderCard.createHexValueCard(String, long)
    Not supported by the FITS standard, so do not use. It was included due to a misreading of the standard itself.
    nom.tam.fits.HeaderCard.createHexValueCard(String, long, String)
    Not supported by the FITS standard, so do not use. It was included due to a misreading of the standard itself.
    nom.tam.fits.HeaderCard.getHexValue()
    Not supported by the FITS standard, so do not use. It was included due to a misreading of the standard itself.
    nom.tam.fits.HeaderCard.saveNewHeaderCard(String, String, boolean)
    This was to be used internally only, without public visibility. It will become unexposed to users in a future release...
    nom.tam.fits.HeaderCard.setHexValue(long)
    Not supported by the FITS standard, so do not use. It was included due to a misreading of the standard itself.
    nom.tam.fits.HeaderCardBuilder.noScale()
    Use HeaderCardBuilder.autoPrecision() instead
    nom.tam.fits.HeaderCardBuilder.scale(int)
    Use HeaderCardBuilder.precision(int) instead.
    nom.tam.fits.HeaderCardCountingArrayDataInput.cardRead()
    (for internal use) Visibility will be reduced to the package level, or will be removed entirely.
    nom.tam.fits.HeaderCardCountingArrayDataInput.getPhysicalCardsRead()
    (for internal use) Visibility will be reduced to the package level, or will be removed entirely.
    nom.tam.fits.HeaderCardCountingArrayDataInput.in()
    (for internal use) Visibility will be reduced to the package level, or will be removed entirely.
    nom.tam.fits.HeaderCardCountingArrayDataInput.mark()
    (for internal use) Visibility will be reduced to the package level, or will be removed entirely.
    nom.tam.fits.HeaderCardCountingArrayDataInput.markSupported()
    (for internal use) Visibility will be reduced to the package level, or will be removed entirely.
    nom.tam.fits.HeaderCardCountingArrayDataInput.reset()
    (for internal use) Visibility will be reduced to the package level, or will be removed entirely.
    nom.tam.fits.HeaderCommentsMap.deleteComment(String)
    nom.tam.fits.HeaderCommentsMap.getComment(String)
    nom.tam.fits.HeaderCommentsMap.updateComment(String, String)
    nom.tam.fits.ImageHDU.encapsulate(Object)
    (for internal use) Use ImageData.from(Object) instead. Will reduce visibility in the future
    nom.tam.fits.ImageHDU.isData(Object)
    (for internal use) Will reduce visibility in the future
    nom.tam.fits.ImageHDU.isHeader(Header)
    (for internal use) Will reduce visibility in the future
    nom.tam.fits.ImageHDU.manufactureData(Header)
    (for internal use) Will reduce visibility in the future
    nom.tam.fits.ImageHDU.manufactureHeader(Data)
    (for internal use) Will reduce visibility in the future
    nom.tam.fits.RandomGroupsHDU.encapsulate(Object)
    (for internal use) Will reduce visibility in the future
    nom.tam.fits.RandomGroupsHDU.isData(Object)
    (for internal use) Will reduce visibility in the future
    nom.tam.fits.RandomGroupsHDU.isHeader(Header)
    (for internal use) Will reduce visibility in the future
    nom.tam.fits.RandomGroupsHDU.manufactureData(Header)
    (for internal use) Will reduce visibility in the future
    nom.tam.fits.TableData.updateAfterDelete(int, Header)
    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. May be removed from the API in the future.
    nom.tam.fits.TableHDU.deleteColumnsIndexOne(int, int)
    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. May be removed from the API in the future.
    nom.tam.fits.TableHDU.deleteColumnsIndexOne(int, int, String[])
    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. May be removed from the API in the future.
    nom.tam.fits.TableHDU.deleteColumnsIndexZero(int, int)
    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. May be removed from the API in the future.
    nom.tam.fits.TableHDU.deleteColumnsIndexZero(int, int, IFitsHeader[])
    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. May be removed from the API in the future.
    nom.tam.fits.TableHDU.deleteRows(int)
    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. May be removed from the API in the future.
    nom.tam.fits.TableHDU.deleteRows(int, int)
    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. May be removed from the API in the future.
    nom.tam.fits.TableHDU.setColumnMeta(int, String, String, String, boolean)
    use TableHDU.setColumnMeta(int, IFitsHeader, String, String, boolean)
    nom.tam.fits.TableHDU.setCurrentColumn(int)
    (for internal use) Will be removed int the future (no longer used).
    nom.tam.fits.TableHDU.setCurrentColumn(int, boolean)
    (for internal use) Will have private access in the future.
    nom.tam.fits.UndefinedHDU.encapsulate(Object)
    (for internal use) Will reduce visibility in the future
    nom.tam.fits.UndefinedHDU.isData(Object)
    (for internal use) Will reduce visibility in the future
    nom.tam.fits.UndefinedHDU.isHeader(Header)
    (for internal use) Will reduce visibility in the future
    nom.tam.fits.UndefinedHDU.manufactureData(Header)
    (for internal use) Will reduce visibility in the future
    nom.tam.fits.UndefinedHDU.manufactureHeader(Data)
    (for internal use) Will reduce visibility in the future
    nom.tam.fits.utilities.FitsCheckSum.checksumEnc(long, boolean)
    Use FitsCheckSum.encode(long, boolean) instead.
    nom.tam.fits.utilities.FitsCheckSum.differenceOf(long, long)
    Not foolproof, because of the carry over handling in checksums, some additionas are not reversible. E.g. 0xffffffff + 0xffffffff = 0xffffffff, but 0xffffffff - 0xffffffff = 0;
    nom.tam.fits.utilities.FitsCheckSum.getStoredChecksum(Header)
    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. It will be removed in the future.
    nom.tam.image.compression.bintable.BinaryTableTile.fillHeader(Header)
    ( for internal use) No longer used.
    nom.tam.image.compression.hdu.CompressedImageHDU.getUncompressedData()
    (for internal use) There is no reason why this should be exposed to users. Use CompressedImageHDU.asImageHDU() instead. Future release may restrict the visibility to private.
    nom.tam.image.compression.hdu.CompressedImageHDU.isHeader()
    nom.tam.image.compression.hdu.CompressedImageHDU.isHeader(Header)
    (for internal use) Will reduce visibility in the future
    nom.tam.image.compression.hdu.CompressedImageHDU.manufactureData(Header)
    (for internal use) Will reduce visibility in the future
    nom.tam.image.compression.hdu.CompressedTableData.prepareUncompressedData(ColumnTable<?>)
    (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.
    nom.tam.image.compression.hdu.CompressedTableHDU.isHeader(Header)
    (for internal use) Will reduce visibility in the future
    nom.tam.image.compression.hdu.CompressedTableHDU.manufactureData(Header)
    (for internal use) Will reduce visibility in the future
    nom.tam.image.compression.tile.mask.AbstractNullPixelMask.getMaskBytes()
    (for internal use) Visibility may be reduced to package level in the future.
    nom.tam.image.tile.operation.buffer.TileBufferFactory.createTileBuffer(ElementType<Buffer>, int, int, int, int)
    for internal use only
    nom.tam.util.array.MultiArrayCopyFactory.select(Class<?>, Class<?>)
    for internal use only. This ought to be private.
    nom.tam.util.array.MultiArrayPointer.isSubArray(Object)
    ()for internal use) Visibility may be reduced to private.
    nom.tam.util.ArrayDataInput.readArray(Object)
    Use ArrayDataInput.readLArray(Object) instead.
    nom.tam.util.ArrayDataInput.skipAllBytes(int)
    This call is handled by ArrayDataInput.skipAllBytes(long), without the need for a separate implementation. Skips a number of bytes from the input. See ArrayDataInput.skipAllBytes(long).
    nom.tam.util.ArrayFuncs.computeLSize(Object)
    Use FitsEncoder.computeSize(Object) instead.
    nom.tam.util.ArrayFuncs.computeSize(Object)
    Use FitsEncoder.computeSize(Object) instead.
    nom.tam.util.ArrayFuncs.copyArray(Object, Object)
    (for internal use)
    nom.tam.util.ArrayFuncs.nElements(Object)
    May silently underestimate size if number is > 2 G.
    nom.tam.util.ArrayFuncs.nLElements(Object)
    Use the more aptly named ArrayFuncs.countElements(Object) instead.
    nom.tam.util.AsciiFuncs.isWhitespace(char)
    Use Character.isWhitespace(char) instead.
    nom.tam.util.BufferDecoder.checkBuffer(int)
    No longer used internally, kept only for back-compatibility since it used to be a needed abstract method. It's safest if you never override or call this method from your code!
    nom.tam.util.BufferDecoder.eofCheck(EOFException, int, int, int)
    No longer used internally, kept only for back-compatibility since it used to be a needed abstract method.
    nom.tam.util.BufferedDataOutputStream.checkBuf(int)
    No longer used internally, but kept for back compatibility (and it does exactly nothing)
    nom.tam.util.BufferEncoder.needBuffer(int)
    No longer used internally, kept only for back-compatibility since it used to be a needed abstract method. It's safest if you never override or call this method from your code!
    nom.tam.util.BufferPointer.init(int)
    Rusty rail implementation only.
    nom.tam.util.ColumnTable.getBases()
    Use ColumnTable.getElementClass(int) instead. This method may be removed in the future.
    nom.tam.util.ColumnTable.getExtraState()
    (for internal use) No longer used, will be removed in the future.
    nom.tam.util.ColumnTable.getSizes()
    Use ColumnTable.getElementSize(int) instead. This method may be removed in the future.
    nom.tam.util.ColumnTable.getTypes()
    Use ColumnTable.getTypeChar(int) instead. This method may be removed in the future.
    nom.tam.util.ColumnTable.setExtraState(T)
    (for internal use) No longer used, will be removed in the future. We used the extra state to carry properties of an enclosing class in this enclosed object, so we could inherit those to new enclosing class instances. This is bad practie. If one needs data from the enclosing object, it should be handled by passing the enclsing object, and not this enclosed table.
    nom.tam.util.Cursor.add(KEY, VALUE)
    Use Cursor.add(Object) instead
    nom.tam.util.FitsDecoder.readAsciiLine()
    (for internal use) Low-level reading/writing should be handled internally as arrays by this library only.
    nom.tam.util.FitsDecoder.readBoolean()
    (for internal use) Low-level reading/writing should be handled internally as arrays by this library only.
    nom.tam.util.FitsDecoder.readByte()
    (for internal use) Low-level reading/writing should be handled internally as arrays by this library only.
    nom.tam.util.FitsDecoder.readChar()
    (for internal use) Low-level reading/writing should be handled internally as arrays by this library only.
    nom.tam.util.FitsDecoder.readDouble()
    (for internal use) Low-level reading/writing should be handled internally as arrays by this library only.
    nom.tam.util.FitsDecoder.readFloat()
    (for internal use) Low-level reading/writing should be handled internally as arrays by this library only.
    nom.tam.util.FitsDecoder.readInt()
    (for internal use) Low-level reading/writing should be handled internally as arrays by this library only.
    nom.tam.util.FitsDecoder.readLong()
    (for internal use) Low-level reading/writing should be handled internally as arrays by this library only.
    nom.tam.util.FitsDecoder.readShort()
    (for internal use) Low-level reading/writing should be handled internally as arrays by this library only.
    nom.tam.util.FitsDecoder.readUnsignedByte()
    (for internal use) Low-level reading/writing should be handled internally as arrays by this library only.
    nom.tam.util.FitsDecoder.readUnsignedShort()
    (for internal use) Low-level reading/writing should be handled internally as arrays by this library only.
    nom.tam.util.FitsEncoder.writeBoolean(Boolean)
    (for internal use) Low-level reading/writing should be handled internally as arrays by this library only.
    nom.tam.util.FitsEncoder.writeByte(int)
    (for internal use) Low-level reading/writing should be handled internally as arrays by this library only.
    nom.tam.util.FitsEncoder.writeChar(int)
    (for internal use) Low-level reading/writing should be handled internally as arrays by this library only.
    nom.tam.util.FitsEncoder.writeDouble(double)
    (for internal use) Low-level reading/writing should be handled internally as arrays by this library only.
    nom.tam.util.FitsEncoder.writeFloat(float)
    (for internal use) Low-level reading/writing should be handled internally by this library only.
    nom.tam.util.FitsEncoder.writeInt(int)
    (for internal use) Low-level reading/writing should be handled internally as arrays by this library only.
    nom.tam.util.FitsEncoder.writeLong(long)
    (for internal use) Low-level reading/writing should be handled internally as arrays by this library only.
    nom.tam.util.FitsEncoder.writeShort(int)
    (for internal use) Low-level reading/writing should be handled internally as arrays by this library only.
    nom.tam.util.FitsFile.readArray(Object)
    nom.tam.util.FitsInputStream.readPrimitiveArray(Object)
    use ArrayInputStream.readLArray(Object) instead
    nom.tam.util.FitsOutputStream.writePrimitiveArray(Object)
    use ArrayOutputStream.writeArray(Object) instead
    nom.tam.util.type.ElementType.individualSize()
    Use ElementType.isVariableSize() instead.
    nom.tam.util.type.PrimitiveTypeHandler.nearestValueOf(int)
    Use ElementType.forNearestBitpix(int) instead.
    nom.tam.util.type.PrimitiveTypeHandler.valueOf(char)
    Use ElementType.forDataID(char) instead.
    nom.tam.util.type.PrimitiveTypeHandler.valueOf(int)
    Use ElementType.forBitpix(int) instead.
    nom.tam.util.type.PrimitiveTypeHandler.valueOf(Class<?>)
    Use ElementType.forClass(Class) instead.
  • Deprecated Constructors
    Constructor
    Description
    nom.tam.fits.AsciiTable(Header)
    (for internal use) Visibility may be reduced to the package level in the future.
    nom.tam.fits.AsciiTable(Header, boolean)
    Use AsciiTable.setI10PreferInt(boolean) instead prior to reading ASCII tables.
    nom.tam.fits.AsciiTableHDU(Header, AsciiTable)
    (for internal use) Its visibility should be reduced to package level in the future.
    nom.tam.fits.BasicHDU(Header, DataClass)
    intended for internal use. Its visibility should be reduced to package level in the future.
    nom.tam.fits.BinaryTable(Object[])
    The constructor is ambiguous, use BinaryTable.fromColumnMajor(Object[]) instead. One could call this method with any row-major Object[][] table by mistake.
    nom.tam.fits.BinaryTable(Object[][])
    The constructor is ambiguous, use BinaryTable.fromRowMajor(Object[][]) instead. You can have a column-major array that has no scalar primitives which would also be an Object[][] and could be passed erroneously.
    nom.tam.fits.BinaryTable(Header)
    (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.
    nom.tam.fits.BinaryTable(ColumnTable<?>)
    DO NOT USE -- it will be removed in the future.
    nom.tam.fits.BinaryTable.SaveState(List<BinaryTable.ColumnDesc>, FitsHeap)
    (for internal use) no longer in use. Will remove in the future.
    nom.tam.fits.BinaryTableHDU(Header, BinaryTable)
    (for internal use) Its visibility should be reduced to package level in the future.
    nom.tam.fits.compression.provider.param.quant.ZBlankColumnParameter(QuantizeOption)
    (for internal use) the visibility of this constructor may be reduced to the package level in future releases.
    nom.tam.fits.compression.provider.param.rice.RiceBlockSizeParameter(RiceCompressOption)
    (for internal use) the visibility of this constructor may be reduced to the package level in future releases.
    nom.tam.fits.compression.provider.param.rice.RiceBytePixParameter(RiceCompressOption)
    (for internal use) the visibility of this constructor may be reduced to the package level in future releases.
    nom.tam.fits.Fits(File, boolean)
    Use Fits(File) instead (compression is auto detected). Will remove in the future.
    nom.tam.fits.Fits(InputStream, boolean)
    Use Fits(InputStream) instead (compression is auto detected). Will remove in the future.
    nom.tam.fits.Fits(String, boolean)
    Use Fits(String) instead (compression is auto detected). Will be a private method in the future.
    nom.tam.fits.Fits(URL, boolean)
    Use Fits(URL) instead (compression is auto detected). Will remove in the future.
    nom.tam.fits.HeaderCard(String, String, boolean)
    Use HeaderCard(String, String, String), or HeaderCard.createCommentStyleCard(String, String) instead.
    nom.tam.fits.HeaderCard(String, String, String, boolean)
    Use HeaderCard(String, String, String), or HeaderCard.createCommentStyleCard(String, String) instead.
    nom.tam.fits.HeaderCard(HeaderCardCountingArrayDataInput)
    (for internal use) Its visibility may be reduced or may be removed entirely in the future. Card counting should be internal to HeaderCard.
    nom.tam.fits.HeaderCardCountingArrayDataInput(ArrayDataInput)
    (for internal use) Visibility will be reduced to the package level, or will be removed entirely.
    nom.tam.fits.ImageHDU(Header, ImageData)
    (for internal use) Its visibility should be reduced to package level in the future.
    nom.tam.fits.RandomGroupsHDU(Header, RandomGroupsData)
    (for internal use) Its visibility should be reduced to package level in the future.
    nom.tam.fits.TableHDU(Header, T)
    intended for internal use. Its visibility should be reduced to package level in the future.
    nom.tam.fits.UndefinedData(Object)
    (for internal use). Users should always construct known data types. Reduce visibility to the package level.
    nom.tam.fits.UndefinedData(Header)
    (for internal use). Visibility will be reduced to the package level in the future.
    nom.tam.fits.UndefinedHDU(Header, UndefinedData)
    (for internal use) Its visibility should be reduced to package level in the future.
    nom.tam.image.compression.bintable.BinaryTableTileCompressor(CompressedTableData, ColumnTable<?>, BinaryTableTileDescription)
    (for internal use) Its visibility will be reduced in the future, not to mention that it should take a BinaryTable as its argument with heap and all. It cannot be used for compressing binary tables with variable-length columns.
    nom.tam.image.compression.bintable.BinaryTableTileDecompressor(CompressedTableData, ColumnTable<?>, BinaryTableTileDescription)
    (for internal use) The visibility will be reduced in the future, not to mention that it should take a binary table as its argument, with heap and all. It cannot be used for decompressing binary tables with variable-length columns.
    nom.tam.image.tile.operation.AbstractTiledImageOperation(Class<OPERATION>)
    (for internal use) This constructor should have protected visibility.
    nom.tam.util.array.MultiArrayPointer()
    ()for internal use) Visibility may be reduced to private.
    nom.tam.util.BufferPointer()
    Rusty rail implementation only.
    nom.tam.util.BufferPointer(byte[])
    Rusty rail implementation only.
    nom.tam.util.type.PrimitiveType(int, boolean, Class<?>, Class<?>, Class<B>, char, int)
    nom.tam.util.type.PrimitiveTypeBase(int, boolean, Class<?>, Class<?>, Class<B>, char, int)
  • Deprecated Enum Constants
    Enum Constant
    Description
    nom.tam.fits.header.Compression.ZBLOCKED
    nom.tam.fits.header.DataDescription.TDMAXn
    Use Standard.TDMAXn instead.
    nom.tam.fits.header.DataDescription.TDMINn
    Use Standard.TDMINn instead.
    nom.tam.fits.header.DataDescription.TLMAXn
    Use Standard.TLMAXn instead.
    nom.tam.fits.header.DataDescription.TLMINn
    Use Standard.TLMINn instead.
    nom.tam.fits.header.IFitsHeader.HDU.PRIMARY_EXTENSION
    Use IFitsHeader.HDU.ANY instead.
    nom.tam.fits.header.NonStandard.CONTINUE
    The CONTINUE key is now part of the FITS 4.0 standard, so use Standard.CONTINUE instead.
    nom.tam.fits.header.NonStandard.INHERIT
    Part of the FITS standard, use Standard.INHERIT instead.
    nom.tam.fits.header.ObservationDurationDescription.DATE_END
    Part of the FITS standard, use DateTime.DATE_END instead
    nom.tam.fits.header.ObservationDurationDescription.TELAPSE
    Part of the FITS standard, use DateTime.TELAPSE instead.
    nom.tam.fits.header.Standard.BLOCKED
    no blocksize other that 2880 may be used.
    nom.tam.fits.header.Standard.EPOCH
    Deprecated by the FITS standard in favor of Standard.EQUINOX.
    nom.tam.fits.header.Standard.RADECSYS
    Deprecated in the current FITS satndard, use Standard.RADESYS instead.
    nom.tam.fits.header.Standard.RESTFREQ
    Deprecated in the current FITS standard, use Standard.RESTFRQ instead.
    nom.tam.fits.header.WCS.EPOCH
    Deprecated in the current FITS standard, use WCS.EQUINOXa instead.
    nom.tam.fits.header.WCS.nCROTn
    The FITS standard deprecated this keyword. Use WCS.nnPCna and WCS.nnCDnainstead. [deg] The coordinate axis rotation in the physical unit of the axis (if defined) for array entries in this column (trailing index). The number of coordinate axes (leading index) defined this way should match the dimensionality of the array elements in the column.
    nom.tam.fits.header.WCS.RADECSYS
    Deprecated in the current FITS standard, use WCS.RADESYSa instead.
    nom.tam.fits.header.WCS.RESTFREQ
    Deprecated in the current FITS standard, use WCS.RESTFRQa instead.
    nom.tam.fits.header.WCS.TCROTn
    The FITS standard deprecated this keyword. Use WCS.TPCn_na and WCS.TCDn_nainstead. [deg] The coordinate axis rotation in the physical unit of the axis (if defined) for the (1D) pixel lists in this column (trailing index).