getBaseType() {
return this.tiledImageOperation.getBaseType();
}
protected ITileOperation getPreviousTileOperation() {
return this.tiledImageOperation.getTileOperation(getTileIndex() - 1);
}
protected TileBuffer getTileBuffer() {
return this.tileBuffer;
}
protected ITiledImageOperation getTiledImageOperation() {
return this.tiledImageOperation;
}
@Override
public ITileOperation setDimensions(int dataOffset, int width, int height) {
setTileBuffer(TileBufferFactory.createTileBuffer(getBaseType(), //
dataOffset, //
this.tiledImageOperation.getImageWidth(), //
width, height));
this.area.size(width, height);
return this;
}
protected void setTileBuffer(TileBuffer tileBuffer) {
this.tileBuffer = tileBuffer;
}
}
nom/tam/image/tile/operation/ITileOperation.java 0000664 0000000 0000000 00000002722 12755570700 020714 0 ustar root root package nom.tam.image.tile.operation;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2016 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
public interface ITileOperation {
ITileOperation setDimensions(int dataOffset, int width, int height);
void waitForResult();
}
nom/tam/image/tile/operation/TileArea.java 0000664 0000000 0000000 00000005130 12755570700 017507 0 ustar root root package nom.tam.image.tile.operation;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2016 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.util.Arrays;
/**
* Description of the erea the tile covers of an image, at the moment only 2
* dimentional tiles are supported.
*/
public class TileArea {
private int[] startPoint;
private int[] endPoint;
public TileArea end(int... newEndPoint) {
this.endPoint = Arrays.copyOf(newEndPoint, newEndPoint.length);
return this;
}
/**
* @param other
* the tile to test intersection with
* @return true if the tile intersects with the specified other tile?
*/
public boolean intersects(TileArea other) {
double x0 = this.startPoint[0];
double y0 = this.startPoint[1];
return other.endPoint[0] > x0 && //
other.endPoint[1] > y0 && //
other.startPoint[0] < this.endPoint[0] && //
other.startPoint[1] < this.endPoint[1];
}
public void size(int... sizes) {
this.endPoint = new int[this.startPoint.length];
for (int index = 0; index < this.startPoint.length; index++) {
this.endPoint[index] = this.startPoint[index] + sizes[index];
}
}
public TileArea start(int... newStartPoint) {
this.startPoint = Arrays.copyOf(newStartPoint, newStartPoint.length);
return this;
}
}
nom/tam/util/ 0000775 0000000 0000000 00000000000 12755570710 012116 5 ustar root root nom/tam/util/ByteParser.java 0000664 0000000 0000000 00000043165 12755570700 015051 0 ustar root root package nom.tam.util;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
/**
* This class provides routines for efficient parsing of data stored in a byte
* array. This routine is optimized (in theory at least!) for efficiency rather
* than accuracy. The values read in for doubles or floats may differ in the
* last bit or so from the standard input utilities, especially in the case
* where a float is specified as a very long string of digits (substantially
* longer than the precision of the type).
*
* The get methods generally are available with or without a length parameter
* specified. When a length parameter is specified only the bytes with the
* specified range from the current offset will be search for the number. If no
* length is specified, the entire buffer from the current offset will be
* searched.
*
* The getString method returns a string with leading and trailing white space
* left intact. For all other get calls, leading white space is ignored. If
* fillFields is set, then the get methods check that only white space follows
* valid data and a FormatException is thrown if that is not the case. If
* fillFields is not set and valid data is found, then the methods return having
* read as much as possible. E.g., for the sequence "T123.258E13", a getBoolean,
* getInteger and getFloat call would return true, 123, and 2.58e12 when called
* in succession.
*/
public class ByteParser {
private static final int EXPONENT_DENORMALISATION_CORR_LIMIT = -300;
private static final double EXPONENT_DENORMALISATION_FACTOR = 1.e-300;
private static final byte[] INFINITY_LOWER = AsciiFuncs.getBytes(ByteFormatter.INFINITY.toLowerCase());
private static final byte[] INFINITY_UPPER = AsciiFuncs.getBytes(ByteFormatter.INFINITY.toUpperCase());
private static final int INFINITY_LENGTH = ByteParser.INFINITY_UPPER.length;
private static final int INFINITY_SHORTCUT_LENGTH = 3;
private static final byte[] NOT_A_NUMBER_LOWER = AsciiFuncs.getBytes(ByteFormatter.NOT_A_NUMBER.toLowerCase());
private static final byte[] NOT_A_NUMBER_UPPER = AsciiFuncs.getBytes(ByteFormatter.NOT_A_NUMBER.toUpperCase());
private static final int NOT_A_NUMBER_LENGTH = ByteParser.NOT_A_NUMBER_UPPER.length;
/**
* The underlying number base used in this class.
*/
private static final int NUMBER_BASE = 10;
/**
* The underlying number base used in this class as a double value.
*/
private static final double NUMBER_BASE_DOUBLE = 10.;
/**
* Did we find a sign last time we checked?
*/
private boolean foundSign;
/**
* Array being parsed
*/
private byte[] input;
/**
* Length of last parsed value
*/
private int numberLength;
/**
* Current offset into input.
*/
private int offset;
/**
* Construct a parser.
*
* @param input
* The byte array to be parsed. Note that the array can be
* re-used by refilling its contents and resetting the offset.
*/
@SuppressFBWarnings(value = "EI_EXPOSE_REP", justification = "intended exposure of mutable data")
public ByteParser(byte[] input) {
this.input = input;
this.offset = 0;
}
/**
* Find the sign for a number . This routine looks for a sign (+/-) at the
* current location and return +1/-1 if one is found, or +1 if not. The
* foundSign boolean is set if a sign is found and offset is incremented.
*/
private int checkSign() {
this.foundSign = false;
if (this.input[this.offset] == '+') {
this.foundSign = true;
this.offset++;
return 1;
} else if (this.input[this.offset] == '-') {
this.foundSign = true;
this.offset++;
return -1;
}
return 1;
}
/**
* Get the integer value starting at the current position. This routine
* returns a double rather than an int/long to enable it to read very long
* integers (with reduced precision) such as
* 111111111111111111111111111111111111111111. Note that this routine does
* set numberLength.
*
* @param length
* The maximum number of characters to use.
*/
private double getBareInteger(int length) {
int startOffset = this.offset;
double number = 0;
while (length > 0 && this.input[this.offset] >= '0' && this.input[this.offset] <= '9') {
number *= ByteParser.NUMBER_BASE;
number += this.input[this.offset] - '0';
this.offset++;
length--;
}
this.numberLength = this.offset - startOffset;
return number;
}
/**
* @return a boolean value from the beginning of the buffer.
* @throws FormatException
* if the double was in an unknown format
*/
public boolean getBoolean() throws FormatException {
return getBoolean(this.input.length - this.offset);
}
/**
* @return a boolean value from a specified region of the buffer
* @param length
* The maximum number of characters used to parse this boolean.
* @throws FormatException
* if the double was in an unknown format
*/
public boolean getBoolean(int length) throws FormatException {
int startOffset = this.offset;
length -= skipWhite(length);
if (length == 0) {
throw new FormatException("Blank boolean field");
}
boolean value = false;
if (this.input[this.offset] == 'T' || this.input[this.offset] == 't') {
value = true;
} else if (this.input[this.offset] != 'F' && this.input[this.offset] != 'f') {
this.numberLength = 0;
this.offset = startOffset;
throw new FormatException("Invalid boolean value");
}
this.offset++;
this.numberLength = this.offset - startOffset;
return value;
}
/**
* @return the buffer being used by the parser
*/
@SuppressFBWarnings(value = "EI_EXPOSE_REP", justification = "intended exposure of mutable data")
public byte[] getBuffer() {
return this.input;
}
/**
* Read in the buffer until a double is read. This will read the entire
* buffer if fillFields is set.
*
* @return The value found.
* @throws FormatException
* if the double was in an unknown format
*/
public double getDouble() throws FormatException {
return getDouble(this.input.length - this.offset);
}
/**
* @return a parsed double from the buffer. Leading spaces are ignored.
* @param length
* The maximum number of characters used to parse this number. If
* fillFields is specified then exactly only whitespace may
* follow a valid double value.
* @throws FormatException
* if the double was in an unknown format
*/
public double getDouble(int length) throws FormatException {
int startOffset = this.offset;
boolean error = true;
double number;
// Skip initial blanks.
length -= skipWhite(length);
if (length == 0) {
this.numberLength = this.offset - startOffset;
return 0;
}
double mantissaSign = checkSign();
if (this.foundSign) {
length--;
}
// Look for the special strings NaN, Inf,
if (isCaseInsensitiv(length, ByteParser.NOT_A_NUMBER_LENGTH, ByteParser.NOT_A_NUMBER_LOWER, ByteParser.NOT_A_NUMBER_UPPER)) {
number = Double.NaN;
this.offset += ByteParser.NOT_A_NUMBER_LENGTH;
// Look for the longer string first then try the shorter.
} else if (isCaseInsensitiv(length, ByteParser.INFINITY_LENGTH, ByteParser.INFINITY_LOWER, ByteParser.INFINITY_UPPER)) {
number = Double.POSITIVE_INFINITY;
this.offset += ByteParser.INFINITY_LENGTH;
} else if (isCaseInsensitiv(length, ByteParser.INFINITY_SHORTCUT_LENGTH, ByteParser.INFINITY_LOWER, ByteParser.INFINITY_UPPER)) {
number = Double.POSITIVE_INFINITY;
this.offset += ByteParser.INFINITY_SHORTCUT_LENGTH;
} else {
number = getBareInteger(length); // This will update offset
length -= this.numberLength; // Set by getBareInteger
if (this.numberLength > 0) {
error = false;
}
// Check for fractional values after decimal
if (length > 0 && this.input[this.offset] == '.') {
this.offset++;
length--;
double numerator = getBareInteger(length);
if (numerator > 0) {
number += numerator / Math.pow(ByteParser.NUMBER_BASE_DOUBLE, this.numberLength);
}
length -= this.numberLength;
if (this.numberLength > 0) {
error = false;
}
}
if (error) {
this.offset = startOffset;
this.numberLength = 0;
throw new FormatException("Invalid real field");
}
// Look for an exponent ,Our Fortran heritage means that we allow
// 'D' for the exponent
// indicator.
if (length > 0 && (this.input[this.offset] == 'e' || this.input[this.offset] == 'E' || this.input[this.offset] == 'd' || this.input[this.offset] == 'D')) {
this.offset++;
length--;
if (length > 0) {
int sign = checkSign();
if (this.foundSign) {
length--;
}
int exponent = (int) getBareInteger(length);
// For very small numbers we try to miminize
// effects of denormalization.
if (exponent * sign > ByteParser.EXPONENT_DENORMALISATION_CORR_LIMIT) {
number *= Math.pow(ByteParser.NUMBER_BASE_DOUBLE, exponent * sign);
} else {
number =
ByteParser.EXPONENT_DENORMALISATION_FACTOR
* (number * Math.pow(ByteParser.NUMBER_BASE_DOUBLE, exponent * sign + ByteParser.EXPONENT_DENORMALISATION_CORR_LIMIT * -1));
}
}
}
}
this.numberLength = this.offset - startOffset;
return mantissaSign * number;
}
/**
* @return a floating point value from the buffer. (see getDouble(int())
* @throws FormatException
* if the float was in an unknown format
*/
public float getFloat() throws FormatException {
return (float) getDouble(this.input.length - this.offset);
}
/**
* @return a floating point value in a region of the buffer
* @param length
* The maximum number of characters used to parse this float.
* @throws FormatException
* if the float was in an unknown format
*/
public float getFloat(int length) throws FormatException {
return (float) getDouble(length);
}
/**
* @return an integer at the beginning of the buffer
* @throws FormatException
* if the integer was in an unknown format
*/
public int getInt() throws FormatException {
return getInt(this.input.length - this.offset);
}
/**
* @return a region of the buffer to an integer
* @param length
* The maximum number of characters used to parse this integer. @throws
* FormatException if the integer was in an unknown format
* @throws FormatException
* if the integer was in an unknown format
*/
public int getInt(int length) throws FormatException {
int startOffset = this.offset;
length -= skipWhite(length);
if (length == 0) {
this.numberLength = this.offset - startOffset;
return 0;
}
int number = 0;
boolean error = true;
int sign = checkSign();
if (this.foundSign) {
length--;
}
while (length > 0 && this.input[this.offset] >= '0' && this.input[this.offset] <= '9') {
number = number * ByteParser.NUMBER_BASE + this.input[this.offset] - '0';
this.offset++;
length--;
error = false;
}
if (error) {
this.numberLength = 0;
this.offset = startOffset;
throw new FormatException("Invalid Integer");
}
this.numberLength = this.offset - startOffset;
return sign * number;
}
/**
* @return a long in a specified region of the buffer
* @param length
* The maximum number of characters used to parse this long.
* @throws FormatException
* if the long was in an unknown format
*/
public long getLong(int length) throws FormatException {
int startOffset = this.offset;
// Skip white space.
length -= skipWhite(length);
if (length == 0) {
this.numberLength = this.offset - startOffset;
return 0;
}
long number = 0;
boolean error = true;
long sign = checkSign();
if (this.foundSign) {
length--;
}
while (length > 0 && this.input[this.offset] >= '0' && this.input[this.offset] <= '9') {
number = number * ByteParser.NUMBER_BASE + this.input[this.offset] - '0';
error = false;
this.offset++;
length--;
}
if (error) {
this.numberLength = 0;
this.offset = startOffset;
throw new FormatException("Invalid long number");
}
this.numberLength = this.offset - startOffset;
return sign * number;
}
/**
* @return the number of characters used to parse the previous number (or
* the length of the previous String returned).
*/
public int getNumberLength() {
return this.numberLength;
}
/**
* Get the current offset.
*
* @return The current offset within the buffer.
*/
public int getOffset() {
return this.offset;
}
/**
* @return a string.
* @param length
* The length of the string.
*/
public String getString(int length) {
String s = AsciiFuncs.asciiString(this.input, this.offset, length);
this.offset += length;
this.numberLength = length;
return s;
}
private boolean isCaseInsensitiv(int length, int constantLength, byte[] lowerConstant, byte[] upperConstant) {
if (length < constantLength) {
return false;
}
for (int i = 0; i < constantLength; i++) {
if (this.input[this.offset + i] != lowerConstant[i] && this.input[this.offset + i] != upperConstant[i]) {
return false;
}
}
return true;
}
/**
* Set the buffer for the parser.
*
* @param buf
* buffer to set
*/
@SuppressFBWarnings(value = "EI_EXPOSE_REP", justification = "intended exposure of mutable data")
public void setBuffer(byte[] buf) {
this.input = buf;
this.offset = 0;
}
/**
* Set the offset into the array.
*
* @param offset
* The desired offset from the beginning of the array.
*/
public void setOffset(int offset) {
this.offset = offset;
}
/**
* Skip bytes in the buffer.
*
* @param nBytes
* number of bytes to skip
*/
public void skip(int nBytes) {
this.offset += nBytes;
}
/**
* Skip white space. This routine skips with space in the input .
*
* @return the number of character skipped. White space is defined as ' ',
* '\t', '\n' or '\r'
* @param length
* The maximum number of characters to skip.
*/
public int skipWhite(int length) {
int i;
for (i = 0; i < length; i++) {
if (this.input[this.offset + i] != ' ' && this.input[this.offset + i] != '\t' && this.input[this.offset + i] != '\n' && this.input[this.offset + i] != '\r') {
break;
}
}
this.offset += i;
return i;
}
}
nom/tam/util/TableException.java 0000664 0000000 0000000 00000003066 12755570700 015673 0 ustar root root package nom.tam.util;
import nom.tam.fits.FitsException;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
public class TableException extends FitsException {
/**
* serial version id.
*/
private static final long serialVersionUID = 1L;
public TableException(String msg) {
super(msg);
}
}
nom/tam/util/ByteFormatter.java 0000664 0000000 0000000 00000074622 12755570700 015562 0 ustar root root package nom.tam.util;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
/**
* This class provides mechanisms for efficiently formatting numbers and
* Strings. Data is appended to existing byte arrays. Note that the formatting
* of real or double values may differ slightly (in the last bit) from the
* standard Java packages since this routines are optimized for speed rather
* than accuracy.
*
* The methods in this class create no objects.
*
* If a number cannot fit into the requested space the truncateOnOverlow flag
* controls whether the formatter will attempt to append it using the available
* length in the output (a la C or Perl style formats). If this flag is set, or
* if the number cannot fit into space left in the buffer it is 'truncated' and
* the requested space is filled with a truncation fill character. A
* TruncationException may be thrown if the truncationThrow flag is set.
*
* This class does not explicitly support separate methods for formatting reals
* in exponential notation. Real numbers near one are by default formatted in
* decimal notation while numbers with large (or very negative) exponents are
* formatted in exponential notation. By setting the limits at which these
* transitions take place the user can force either exponential or decimal
* notation.
*/
public final class ByteFormatter {
public static final String NOT_A_NUMBER = "NaN";
public static final String INFINITY = "Infinity";
public static final String NEGATIVE_INFINITY = "-Infinity";
/**
* Maximum magnitude to print in non-scientific notation.
*/
private static final double DEFAULT_SIMPLE_MAX = 1.e6;
/**
* Minimum magnitude to print in non-scientific notation.
*/
private static final double DEFAULT_SIMPLE_MIN = 1.e-3;
/**
* Digits. We could handle other bases by extending or truncating this list
* and changing the division by 10 (and it's factors) at various locations.
*/
private static final byte[] DIGITS = {
(byte) '0',
(byte) '1',
(byte) '2',
(byte) '3',
(byte) '4',
(byte) '5',
(byte) '6',
(byte) '7',
(byte) '8',
(byte) '9'
};
private static final long DOUBLE_EXPONENT_BIT_MASK = 0x7FF0000000000000L;
private static final int DOUBLE_EXPONENT_EXCESS = 52;
/**
* The hidden bit in normalized double numbers.
*/
private static final long DOUBLE_EXPONENT_NORMALIZE_BIT = 0x0010000000000000L;
/**
* Used to check if double is normalized
*/
private static final int DOUBLE_MIN_EXPONENT = -1023;
private static final int DOUBLE_SHIFT_BASE = 17;
private static final int DOUBLE_SHIFT_LIMIT = 200;
private static final long DOUBLE_VALUE_BIT_MASK = 0x000FFFFFFFFFFFFFL;
private static final int FLOAT_EXPONENT_BIT_MASK = 0x7F800000;
private static final int FLOAT_EXPONENT_EXCESS = 23;
/**
* The hidden bit in normalized floating point numbers.
*/
private static final int FLOAT_EXPONENT_NORMALIZE_BIT = 0x00800000;
/**
* Used to check if float is normalized
*/
private static final int FLOAT_MIN_EXPONENT = -127;
private static final int FLOAT_SHIFT_BASE = 8;
private static final int FLOAT_SHIFT_LIMIT = 30;
private static final int FLOAT_VALUE_BIT_MASK = 0x007FFFFF;
private static final double I_LOG_10 = 1. / Math.log(ByteFormatter.NUMBER_BASE);
private static final long LONG_TO_INT_MODULO = 1000000000L;
private static final int MAX_LONG_LENGTH = 19;
/**
* The maximum single digit integer. Special case handling when rounding up
* and when incrementing the exponent.
*/
private static final int MAXIMUM_SINGLE_DIGIT_INTEGER = 9;
/**
* The maximum two digit integer. When we increment an exponent of this
* value, the exponent gets longer. Don't need to worry about 999 since
* exponents can't be that big.
*/
private static final int MAXIMUM_TWO_DIGIT_INTEGER = 99;
private static final int TEMP_BUFFER_SIZE = 32;
/**
* The underlying number base used in this class.
*/
private static final int NUMBER_BASE = 10;
/**
* Powers of 10. We over extend on both sides. These should perhaps be
* tabulated rather than computed though it may be faster to calculate them
* than to read in the extra bytes in the class file.
*/
private static final double[] NUMBER_BASE_POWERS;
/**
* What do we use to fill when we cannot print the number?Default is often
* used in Fortran.
*/
private static final byte TRUNCATION_FILL = (byte) '*';
/**
* What index of tenpow is 10^0
*/
private static final int ZERO_POW;
static { // Static initializer
int min = (int) Math.floor((int) (Math.log(Double.MIN_VALUE) * ByteFormatter.I_LOG_10));
int max = (int) Math.floor((int) (Math.log(Double.MAX_VALUE) * ByteFormatter.I_LOG_10));
max++;
NUMBER_BASE_POWERS = new double[max - min + 1];
for (int i = 0; i < ByteFormatter.NUMBER_BASE_POWERS.length; i++) {
ByteFormatter.NUMBER_BASE_POWERS[i] = Math.pow(ByteFormatter.NUMBER_BASE, i + min);
}
ZERO_POW = -min;
}
/**
* Internal buffers used in formatting fields
*/
private final byte[] tbuf1 = new byte[ByteFormatter.TEMP_BUFFER_SIZE];
private final byte[] tbuf2 = new byte[ByteFormatter.TEMP_BUFFER_SIZE];
/**
* This method formats a double given a decimal mantissa and exponent
* information.
*
* @param val
* The original number
* @param buf
* Output buffer
* @param off
* Offset into buffer
* @param len
* Maximum number of characters to use in buffer.
* @param mant
* A decimal mantissa for the number.
* @param lmant
* The number of characters in the mantissa
* @param shift
* The exponent of the power of 10 that we shifted val to get the
* given mantissa.
* @return Offset of next available character in buffer. @ * if the value
* was truncated
*/
private int combineReal(double val, byte[] buf, int off, int len, byte[] mant, int lmant, int shift) {
// First get the minimum size for the number
double pos = Math.abs(val);
boolean simple = false;
int minSize;
int maxSize;
if (pos >= ByteFormatter.DEFAULT_SIMPLE_MIN && pos <= ByteFormatter.DEFAULT_SIMPLE_MAX) {
simple = true;
}
int exp = lmant - shift - 1;
int lexp = 0;
if (!simple) {
lexp = format(exp, this.tbuf2, 0, ByteFormatter.TEMP_BUFFER_SIZE);
minSize = lexp + 2; // e.g., 2e-12
maxSize = lexp + lmant + 2; // add in "." and e
} else {
if (exp >= 0) {
minSize = exp + 1; // e.g. 32
// Special case. E.g., 99.9 has
// minumum size of 3.
int i;
for (i = 0; i < lmant && i <= exp; i++) {
if (mant[i] != (byte) '9') {
break;
}
}
if (i > exp && i < lmant && mant[i] >= (byte) '5') {
minSize++;
}
maxSize = lmant + 1; // Add in "."
if (maxSize <= minSize) { // Very large numbers.
maxSize = minSize + 1;
}
} else {
minSize = 2;
maxSize = 1 + Math.abs(exp) + lmant;
}
}
if (val < 0) {
minSize++;
}
// Can the number fit?
if (minSize > len || minSize > buf.length - off) {
truncationFiller(buf, off, len);
return off + len;
}
// Now begin filling in the buffer.
if (val < 0) {
buf[off] = (byte) '-';
off++;
len--;
}
if (simple) {
return Math.abs(mantissa(mant, lmant, exp, simple, buf, off, len));
} else {
off = mantissa(mant, lmant, 0, simple, buf, off, len - lexp - 1);
if (off < 0) {
off = -off;
len -= off;
// Handle the expanded exponent by filling
if (exp == MAXIMUM_SINGLE_DIGIT_INTEGER || exp == MAXIMUM_TWO_DIGIT_INTEGER) {
// Cannot fit...
if (off + len == minSize) {
truncationFiller(buf, off, len);
return off + len;
} else {
// Steal a character from the mantissa.
off--;
}
}
exp++;
lexp = format(exp, this.tbuf2, 0, ByteFormatter.TEMP_BUFFER_SIZE);
}
buf[off] = (byte) 'E';
off++;
System.arraycopy(this.tbuf2, 0, buf, off, lexp);
return off + lexp;
}
}
/**
* Format a boolean into an existing array.
*
* @param val
* value to write
* @param array
* the array to fill
* @return Offset of next available character in buffer.
*/
public int format(boolean val, byte[] array) {
return format(val, array, 0, array.length);
}
/**
* Format a boolean into an existing array
*
* @param val
* The boolean to be formatted
* @param array
* The buffer in which to format the data.
* @param off
* The starting offset within the buffer.
* @param len
* The maximum number of characters to use use in formatting the
* number.
* @return Offset of next available character in buffer.
*/
public int format(boolean val, byte[] array, int off, int len) {
if (len > 0) {
if (val) {
array[off] = (byte) 'T';
} else {
array[off] = (byte) 'F';
}
off++;
}
return off;
}
/**
* Format a double into an array.
*
* @param val
* The double to be formatted.
* @param array
* The array in which to place the result.
* @return The number of characters used. @ * if the value was truncated
*/
public int format(double val, byte[] array) {
return format(val, array, 0, array.length);
}
/**
* Format a double into an existing character array.
*
* This is hard to do exactly right... The JDK code does stuff with rational
* arithmetic and so forth. We use a much simpler algorithm which may give
* an answer off in the lowest order bit. Since this is pure Java, it should
* still be consistent from machine to machine.
*
* Recall that the binary representation of the double is of the form
* d = 0.bbbbbbbb x 2n where there are up to 53 binary
* digits in the binary fraction (including the assumed leading 1 bit for
* normalized numbers). We find a value m such that
* 10m d is between 253 and
* 263 . This product will be exactly convertible to a
* long with no loss of precision. Getting the decimal representation for
* that is trivial (see formatLong). This is a decimal mantissa and we have
* an exponent (-m ). All we have to do is manipulate the decimal
* point to where we want to see it. Errors can arise due to roundoff in the
* scaling multiplication, but should be no more than a single bit.
*
* @param val
* Double to be formatted
* @param buf
* Buffer in which result is to be stored
* @param off
* Offset within buffer
* @param len
* Maximum length of integer
* @return offset of next unused character in input buffer. @ * if the value
* was truncated
*/
public int format(double val, byte[] buf, int off, int len) {
double pos = Math.abs(val);
// Special cases -- It is OK if these get truncated.
if (pos == 0.) {
return format("0.0", buf, off, len);
} else if (Double.isNaN(val)) {
return format(NOT_A_NUMBER, buf, off, len);
} else if (Double.isInfinite(val)) {
if (val > 0) {
return format(INFINITY, buf, off, len);
} else {
return format(NEGATIVE_INFINITY, buf, off, len);
}
}
int power = (int) (Math.log(pos) * ByteFormatter.I_LOG_10);
int shift = DOUBLE_SHIFT_BASE - power;
double scale;
double scale2 = 1;
// Scale the number so that we get a number ~ n x 10^17.
if (shift < DOUBLE_SHIFT_LIMIT) {
scale = ByteFormatter.NUMBER_BASE_POWERS[shift + ByteFormatter.ZERO_POW];
} else {
// Can get overflow if the original number is
// very small, so we break out the shift
// into two multipliers.
scale2 = ByteFormatter.NUMBER_BASE_POWERS[DOUBLE_SHIFT_LIMIT + ByteFormatter.ZERO_POW];
scale = ByteFormatter.NUMBER_BASE_POWERS[shift - DOUBLE_SHIFT_LIMIT + ByteFormatter.ZERO_POW];
}
pos = pos * scale * scale2;
// Parse the double bits.
long bits = Double.doubleToLongBits(pos);
// The exponent should be a little more than 52.
int exp = (int) (((bits & DOUBLE_EXPONENT_BIT_MASK) >> DOUBLE_EXPONENT_EXCESS) + DOUBLE_MIN_EXPONENT);
long numb = bits & DOUBLE_VALUE_BIT_MASK;
// this can never be false because the min exponent of a double is -1022
// but lets keep it if we need it for big decimals
if (exp > DOUBLE_MIN_EXPONENT) {
// Normalized....
numb |= DOUBLE_EXPONENT_NORMALIZE_BIT;
} else {
// Denormalized
exp++;
}
// Multiple this number by the excess of the exponent
// over 52. This completes the conversion of double to long.
numb = numb << exp - DOUBLE_EXPONENT_EXCESS;
// Get a decimal mantissa.
int ndig = format(numb, this.tbuf1, 0, ByteFormatter.TEMP_BUFFER_SIZE);
// Now format the double.
return combineReal(val, buf, off, len, this.tbuf1, ndig, shift);
}
/**
* Format a float into an array.
*
* @param val
* The float to be formatted.
* @param array
* The array in which to place the result.
* @return The number of characters used. @ * if the value was truncated
*/
public int format(float val, byte[] array) {
return format(val, array, 0, array.length);
}
/**
* Format a float into an existing byteacter array.
*
* This is hard to do exactly right... The JDK code does stuff with rational
* arithmetic and so forth. We use a much simpler algorithm which may give
* an answer off in the lowest order bit. Since this is pure Java, it should
* still be consistent from machine to machine.
*
* Recall that the binary representation of the float is of the form
* d = 0.bbbbbbbb x 2n where there are up to 24 binary
* digits in the binary fraction (including the assumed leading 1 bit for
* normalized numbers). We find a value m such that
* 10m d is between 224 and
* 232 . This product will be exactly convertible to an
* int with no loss of precision. Getting the decimal representation for
* that is trivial (see formatInteger). This is a decimal mantissa and we
* have an exponent ( -m ). All we have to do is manipulate the
* decimal point to where we want to see it. Errors can arise due to
* roundoff in the scaling multiplication, but should be very small.
*
* @param val
* Float to be formatted
* @param buf
* Buffer in which result is to be stored
* @param off
* Offset within buffer
* @param len
* Maximum length of field
* @return Offset of next character in buffer. @ * if the value was
* truncated
*/
public int format(float val, byte[] buf, int off, int len) {
float pos = Math.abs(val);
// Special cases
if (pos == 0.) {
return format("0.0", buf, off, len);
} else if (Float.isNaN(val)) {
return format(NOT_A_NUMBER, buf, off, len);
} else if (Float.isInfinite(val)) {
if (val > 0) {
return format("Infinity", buf, off, len);
} else {
return format("-Infinity", buf, off, len);
}
}
int power = (int) Math.floor(Math.log(pos) * ByteFormatter.I_LOG_10);
int shift = FLOAT_SHIFT_BASE - power;
float scale;
float scale2 = 1;
// Scale the number so that we get a number ~ n x 10^8.
if (shift < FLOAT_SHIFT_LIMIT) {
scale = (float) ByteFormatter.NUMBER_BASE_POWERS[shift + ByteFormatter.ZERO_POW];
} else {
// Can get overflow if the original number is
// very small, so we break out the shift
// into two multipliers.
scale2 = (float) ByteFormatter.NUMBER_BASE_POWERS[FLOAT_SHIFT_LIMIT + ByteFormatter.ZERO_POW];
scale = (float) ByteFormatter.NUMBER_BASE_POWERS[shift - FLOAT_SHIFT_LIMIT + ByteFormatter.ZERO_POW];
}
pos = pos * scale * scale2;
// Parse the float bits.
int bits = Float.floatToIntBits(pos);
// The exponent should be a little more than 23
int exp = ((bits & FLOAT_EXPONENT_BIT_MASK) >> FLOAT_EXPONENT_EXCESS) + FLOAT_MIN_EXPONENT;
int numb = bits & FLOAT_VALUE_BIT_MASK;
if (exp > FLOAT_MIN_EXPONENT) {
// Normalized....
numb |= FLOAT_EXPONENT_NORMALIZE_BIT;
} else {
// Denormalized
exp++;
}
// Multiple this number by the excess of the exponent
// over 24. This completes the conversion of float to int
// (<<= did not work on Alpha TruUnix)
numb = numb << exp - FLOAT_EXPONENT_EXCESS;
// Get a decimal mantissa.
int ndig = format(numb, this.tbuf1, 0, ByteFormatter.TEMP_BUFFER_SIZE);
// Now format the float.
return combineReal(val, buf, off, len, this.tbuf1, ndig, shift);
}
/**
* Format an int into an array.
*
* @param val
* The int to be formatted.
* @param array
* The array in which to place the result.
* @return The number of characters used. @ * if the value was truncated
*/
public int format(int val, byte[] array) {
return format(val, array, 0, array.length);
}
/**
* Format an int into an existing array.
*
* @param val
* Integer to be formatted
* @param buf
* Buffer in which result is to be stored
* @param off
* Offset within buffer
* @param len
* Maximum length of integer
* @return offset of next unused character in input buffer.
*/
public int format(int val, byte[] buf, int off, int len) {
// Special case
if (val == Integer.MIN_VALUE) {
if (len > ByteFormatter.NUMBER_BASE) {
return format("-2147483648", buf, off, len);
} else {
truncationFiller(buf, off, len);
return off + len;
}
}
int pos = Math.abs(val);
// First count the number of characters in the result.
// Otherwise we need to use an intermediary buffer.
int ndig = 1;
int dmax = ByteFormatter.NUMBER_BASE;
while (ndig < ByteFormatter.NUMBER_BASE && pos >= dmax) {
ndig++;
dmax *= ByteFormatter.NUMBER_BASE;
}
if (val < 0) {
ndig++;
}
// Truncate if necessary.
if (ndig > len || ndig > buf.length - off) {
truncationFiller(buf, off, len);
return off + len;
}
// Now insert the actual characters we want -- backwards
// We use a do{} while() to handle the caByteFormatterse of 0.
off += ndig;
int xoff = off - 1;
do {
buf[xoff] = ByteFormatter.DIGITS[pos % ByteFormatter.NUMBER_BASE];
xoff--;
pos /= ByteFormatter.NUMBER_BASE;
} while (pos > 0);
if (val < 0) {
buf[xoff] = (byte) '-';
}
return off;
}
/**
* Format a long into an array.
*
* @param val
* The long to be formatted.
* @param array
* The array in which to place the result.
* @return The number of characters used. @ * if the value was truncated
*/
public int format(long val, byte[] array) {
return format(val, array, 0, array.length);
}
/**
* Format a long into an existing array.
*
* @param val
* Long to be formatted
* @param buf
* Buffer in which result is to be stored
* @param off
* Offset within buffer
* @param len
* Maximum length of integer
* @return offset of next unused character in input buffer. @ * if the value
* was truncated
*/
public int format(long val, byte[] buf, int off, int len) {
// Special case
if (val == Long.MIN_VALUE) {
if (len > MAX_LONG_LENGTH) {
return format("-9223372036854775808", buf, off, len);
} else {
truncationFiller(buf, off, len);
return off + len;
}
}
long pos = Math.abs(val);
// First count the number of characters in the result.
// Otherwise we need to use an intermediary buffer.
int ndig = 1;
long dmax = ByteFormatter.NUMBER_BASE;
// Might be faster to try to do this partially in ints
while (ndig < MAX_LONG_LENGTH && pos >= dmax) {
ndig++;
dmax *= ByteFormatter.NUMBER_BASE;
}
if (val < 0) {
ndig++;
}
// Truncate if necessary.
if (ndig > len || ndig > buf.length - off) {
truncationFiller(buf, off, len);
return off + len;
}
// Now insert the actual characters we want -- backwards.
off += ndig;
int xoff = off - 1;
buf[xoff] = (byte) '0';
boolean last = pos == 0;
while (!last) {
// Work on ints rather than longs.
int giga = (int) (pos % LONG_TO_INT_MODULO);
pos /= LONG_TO_INT_MODULO;
last = pos == 0;
for (int i = 0; i < MAXIMUM_SINGLE_DIGIT_INTEGER; i++) {
buf[xoff] = ByteFormatter.DIGITS[giga % ByteFormatter.NUMBER_BASE];
xoff--;
giga /= ByteFormatter.NUMBER_BASE;
if (last && giga == 0) {
break;
}
}
}
if (val < 0) {
buf[xoff] = (byte) '-';
}
return off;
}
/**
* Insert a string at the beginning of an array. * @return Offset of next
* available character in buffer.
*
* @param val
* The string to be inserted. A null string will insert len
* spaces.
* @param array
* The buffer in which to insert the string.
* @return Offset of next available character in buffer.
*/
public int format(String val, byte[] array) {
return format(val, array, 0, array.length);
}
/**
* Insert a String into an existing character array. If the String is longer
* than len, then only the the initial len characters will be inserted.
*
* @param val
* The string to be inserted. A null string will insert len
* spaces.
* @param array
* The buffer in which to insert the string.
* @param off
* The starting offset to insert the string.
* @param len
* The maximum number of characters to insert.
* @return Offset of next available character in buffer.
*/
public int format(String val, byte[] array, int off, int len) {
if (val == null) {
for (int i = 0; i < len; i++) {
array[off + i] = (byte) ' ';
}
return off + len;
}
int slen = val.length();
if (slen > len || slen > array.length - off) {
val = val.substring(0, len);
slen = len;
}
System.arraycopy(AsciiFuncs.getBytes(val), 0, array, off, slen);
return off + slen;
}
/**
* Write the mantissa of the number. This method addresses the subtleties
* involved in rounding numbers.
*/
private int mantissa(byte[] mant, int lmant, int exp, boolean simple, byte[] buf, int off, int len) {
// Save in case we need to extend the number.
int off0 = off;
int pos = 0;
if (exp < 0) {
buf[off] = (byte) '0';
len--;
off++;
if (len > 0) {
buf[off] = (byte) '.';
off++;
len--;
}
// Leading 0s in small numbers.
int cexp = exp;
while (cexp < -1 && len > 0) {
buf[off] = (byte) '0';
cexp++;
off++;
len--;
}
} else {
// Print out all digits to the left of the decimal.
while (exp >= 0 && pos < lmant) {
buf[off] = mant[pos];
off++;
pos++;
len--;
exp--;
}
// Trust we have enough space for this.
for (int i = 0; i <= exp; i++) {
buf[off] = (byte) '0';
off++;
len--;
}
// Add in a decimal if we have space.
if (len > 0) {
buf[off] = (byte) '.';
len--;
off++;
}
}
// Now handle the digits to the right of the decimal.
while (len > 0 && pos < lmant) {
buf[off] = mant[pos];
off++;
exp--;
len--;
pos++;
}
// Now handle rounding.
if (pos < lmant && mant[pos] >= (byte) '5') {
int i;
// Increment to the left until we find a non-9
for (i = off - 1; i >= off0; i--) {
if (buf[i] == (byte) '.' || buf[i] == (byte) '-') {
continue;
}
if (buf[i] == (byte) '9') {
buf[i] = (byte) '0';
} else {
buf[i]++;
break;
}
}
// Now we handle 99.99 case. This can cause problems
// in two cases. If we are not using scientific notation
// then we may want to convert 99.9 to 100., i.e.,
// we need to move the decimal point. If there is no
// decimal point, then we must not be truncating on overflow
// but we should be allowed to write it to the
// next character (i.e., we are not at the end of buf).
//
// If we are printing in scientific notation, then we want
// to convert 9.99 to 1.00, i.e. we do not move the decimal.
// However we need to signal that the exponent should be
// incremented by one.
//
// We cannot have aligned the number, since that requires
// the full precision number to fit within the requested
// length, and we would have printed out the entire
// mantissa (i.e., pos >= lmant)
if (i < off0) {
buf[off0] = (byte) '1';
boolean foundDecimal = false;
for (i = off0 + 1; i < off; i++) {
if (buf[i] == (byte) '.') {
foundDecimal = true;
if (simple) {
buf[i] = (byte) '0';
i++;
if (i < off) {
buf[i] = (byte) '.';
}
}
break;
}
}
if (simple && !foundDecimal) {
buf[off + 1] = (byte) '0'; // 99 went to 100
off++;
}
off = -off; // Signal to change exponent if necessary.
}
}
return off;
}
/**
* Fill the buffer with truncation characters. After filling the buffer, a
* TruncationException will be thrown if the appropriate flag is set.
*/
private void truncationFiller(byte[] buffer, int offset, int length) {
for (int i = offset; i < offset + length; i++) {
buffer[i] = ByteFormatter.TRUNCATION_FILL;
}
}
}
nom/tam/util/ByteBufferInputStream.java 0000664 0000000 0000000 00000004105 12755570700 017211 0 ustar root root package nom.tam.util;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteBuffer;
public class ByteBufferInputStream extends InputStream {
private static final int BYTE_MASK = 0xFF;
private final ByteBuffer buf;
public ByteBufferInputStream(ByteBuffer buffer) {
super();
this.buf = buffer;
}
@Override
public int read() throws IOException {
if (!buf.hasRemaining()) {
return -1;
}
return buf.get() & BYTE_MASK;
}
@Override
public int read(byte[] bytes, int off, int len) throws IOException {
if (!buf.hasRemaining()) {
return -1;
}
int readLen = Math.min(len, buf.remaining());
buf.get(bytes, off, readLen);
return readLen;
}
}
nom/tam/util/FitsIO.java 0000664 0000000 0000000 00000010011 12755570700 014106 0 ustar root root package nom.tam.util;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.io.Closeable;
import java.io.IOException;
/**
* super closable interface for all fits reader/writers. It defines the
* necessary constants common for all reader and writers.
*
* @author ritchie
*/
public interface FitsIO extends Closeable {
/**
* default buffer size to use if none is specified.
*/
int DEFAULT_BUFFER_SIZE = 32768;
/**
* number of bits in one byte.
*/
int BITS_OF_1_BYTE = 8;
/**
* number of bits in two byte.
*/
int BITS_OF_2_BYTES = 16;
/**
* number of bits in three byte.
*/
int BITS_OF_3_BYTES = 24;
/**
* number of bits in four byte.
*/
int BITS_OF_4_BYTES = 32;
/**
* number of bits in five byte.
*/
int BITS_OF_5_BYTES = 40;
/**
* number of bits in six byte.
*/
int BITS_OF_6_BYTES = 48;
/**
* number of bits in seven byte.
*/
int BITS_OF_7_BYTES = 56;
/**
* number of bytes occupied by a boolean.
*/
int BYTES_IN_BOOLEAN = 1;
/**
* number of bytes occupied by a byte.
*/
int BYTES_IN_BYTE = 1;
/**
* number of bytes occupied by a char.
*/
int BYTES_IN_CHAR = 2;
/**
* number of bytes occupied by a short.
*/
int BYTES_IN_SHORT = 2;
/**
* number of bytes occupied by a integer.
*/
int BYTES_IN_INTEGER = 4;
/**
* number of bytes occupied by a long.
*/
int BYTES_IN_LONG = 8;
/**
* number of bytes occupied by a float.
*/
int BYTES_IN_FLOAT = 4;
/**
* number of bytes occupied by a double.
*/
int BYTES_IN_DOUBLE = 8;
/**
* bit mask to get the lowest byte from an integer. Or to get an unsigned
* integer from a byte.
*/
int BYTE_MASK = 0xFF;
/**
* bit mask to get the lowest short of a integer.
*/
int SHORT_MASK = 0xffff;
/**
* bit mask to get the lowest short of a long.
*/
long SHORT_OF_LONG_MASK = 0xffffL;
/**
* bit mask to get the lowest byte of a long.
*/
long BYTE_1_OF_LONG_MASK = 0xffL;
/**
* bit mask to get the second lowest byte of a long.
*/
long BYTE_2_OF_LONG_MASK = 0xff00L;
/**
* bit mask to get the third lowest byte of a long.
*/
long BYTE_3_OF_LONG_MASK = 0xff0000L;
/**
* bit mask to get the fourth lowest byte of a long.
*/
long BYTE_4_OF_LONG_MASK = 0xff000000L;
/**
* bit mask to get the lowest integer from an long.
*/
long INTEGER_MASK = 0x00000000ffffffffL;
/**
* bit mask to get the highest integer from an long.
*/
long HIGH_INTEGER_MASK = 0xFFFFFFFF00000000L;
@Override
void close() throws IOException;
}
nom/tam/util/ArrayDataInput.java 0000664 0000000 0000000 00000027440 12755570700 015657 0 ustar root root package nom.tam.util;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.io.IOException;
public interface ArrayDataInput extends java.io.DataInput, FitsIO {
/**
* See the general contract of the mark method of
* InputStream.
*
* @param readlimit
* the maximum limit of bytes that can be read before the mark
* position becomes invalid.
* @see java.io.BufferedInputStream#reset()
* @throws IOException
* if the operation failed
*/
void mark(int readlimit) throws IOException;
/**
* Read an array of byte's.
*
* @return number of bytes read.
* @see #readFully(byte[])
* @param buf
* array of byte's.
* @throws IOException
* if one of the underlying read operations failed
*/
int read(byte[] buf) throws IOException;
/**
* Read a segment of an array of byte's.
*
* @return number of bytes read.
* @see #readFully(byte[], int, int)
* @param buf
* array of byte's.
* @param offset
* start index in the array
* @param size
* number of array elements to read
* @throws IOException
* if one of the underlying read operations failed
*/
int read(byte[] buf, int offset, int size) throws IOException;
/**
* Read an array of boolean's.
*
* @return number of bytes read.
* @param buf
* array of boolean's.
* @throws IOException
* if one of the underlying read operations failed
*/
int read(boolean[] buf) throws IOException;
/**
* Read a segment of an array of boolean's.
*
* @return number of bytes read.
* @param buf
* array of boolean's.
* @param offset
* start index in the array
* @param size
* number of array elements to read
* @throws IOException
* if one of the underlying read operations failed
*/
int read(boolean[] buf, int offset, int size) throws IOException;
/**
* Read an array of char's.
*
* @return number of bytes read.
* @param buf
* array of char's.
* @throws IOException
* if one of the underlying read operations failed
*/
int read(char[] buf) throws IOException;
/**
* Read a segment of an array of char's.
*
* @return number of bytes read.
* @param buf
* array of char's.
* @param offset
* start index in the array
* @param size
* number of array elements to read
* @throws IOException
* if one of the underlying read operations failed
*/
int read(char[] buf, int offset, int size) throws IOException;
/**
* Read an array of double's.
*
* @return number of bytes read.
* @param buf
* array of double's.
* @throws IOException
* if one of the underlying read operations failed
*/
int read(double[] buf) throws IOException;
/**
* Read a segment of an array of double's.
*
* @return number of bytes read.
* @param buf
* array of double's.
* @param offset
* start index in the array
* @param size
* number of array elements to read
* @throws IOException
* if one of the underlying read operations failed
*/
int read(double[] buf, int offset, int size) throws IOException;
/**
* Read an array of float's.
*
* @return number of bytes read.
* @param buf
* array of float's.
* @throws IOException
* if one of the underlying read operations failed
*/
int read(float[] buf) throws IOException;
/**
* Read a segment of an array of float's.
*
* @return number of bytes read.
* @param buf
* array of float's.
* @param offset
* start index in the array
* @param size
* number of array elements to read
* @throws IOException
* if one of the underlying read operations failed
*/
int read(float[] buf, int offset, int size) throws IOException;
/**
* Read an array of int's.
*
* @return number of bytes read.
* @param buf
* array of int's.
* @throws IOException
* if one of the underlying read operations failed
*/
int read(int[] buf) throws IOException;
/**
* Read a segment of an array of int's.
*
* @return number of bytes read.
* @param buf
* array of int's.
* @param offset
* start index in the array
* @param size
* number of array elements to read
* @throws IOException
* if one of the underlying read operations failed
*/
int read(int[] buf, int offset, int size) throws IOException;
/**
* Read a segment of an array of long's.
*
* @return number of bytes read.
* @param buf
* array of long's.
* @throws IOException
* if one of the underlying read operations failed
*/
int read(long[] buf) throws IOException;
/**
* Read a segment of an array of long's.
*
* @return number of bytes read.
* @param buf
* array of long's.
* @param offset
* start index in the array
* @param size
* number of array elements to read
* @throws IOException
* if one of the underlying read operations failed
*/
int read(long[] buf, int offset, int size) throws IOException;
/**
* Read an array of short's.
*
* @return number of bytes read.
* @param buf
* array of short's.
* @throws IOException
* if one of the underlying read operations failed
*/
int read(short[] buf) throws IOException;
/**
* Read a segment of an array of short's.
*
* @return number of bytes read.
* @param buf
* array of short's.
* @param offset
* start index in the array
* @param size
* number of array elements to read
* @throws IOException
* if one of the underlying read operations failed
*/
int read(short[] buf, int offset, int size) throws IOException;
/**
* Read a generic (possibly multidimensional) primitive array. An Object[]
* array is also a legal argument if each element of the array is a legal.
*
* The ArrayDataInput classes do not support String input since it is
* unclear how one would read in an Array of strings.
*
* @return number of bytes read.
* @param o
* A [multidimensional] primitive (or Object) array.
* @deprecated use {@link ArrayDataInput#readLArray(Object)} instead.
* @return the number of bytes read
* @throws IOException
* if the underlying stream failed
*/
@Deprecated
int readArray(Object o) throws IOException;
/**
* Read an object. An EOF will be signaled if the object cannot be fully
* read. This version works even if the underlying data is more than 2
* Gigabytes.
*
* @return number of bytes read.
* @param o
* The object to be read. This object should be a primitive
* (possibly multi-dimensional) array.
* @return The number of bytes read.
* @throws IOException
* if the underlying stream failed
*/
long readLArray(Object o) throws IOException;
/**
* See the general contract of the reset method of
* InputStream.
*
* If markpos is -1 (no mark has been set or the
* mark has been invalidated), an IOException is thrown.
* Otherwise, pos is set equal to markpos.
*
* @exception IOException
* if this stream has not been marked or, if the mark has
* been invalidated, or the stream has been closed by
* invoking its {@link #close()} method, or an I/O error
* occurs.
* @see java.io.BufferedInputStream#mark(int)
*/
void reset() throws IOException;
/**
* Skip the number of bytes. This differs from the skip method in that it
* will throw an EOF if a forward skip cannot be fully accomplished...
* (However that isn't supposed to happen with a random access file, so
* there is probably no operational difference).
*
* @param distance
* the number of bytes to skip
* @return the number of bytes really skipped
* @throws IOException
* if the underlying stream failed
*/
long skip(long distance) throws IOException;
/**
* Skip the number of bytes. This differs from the skip method in that it
* will throw an EOF if a forward skip cannot be fully accomplished...
* (However that isn't supposed to happen with a random access file, so
* there is probably no operational difference).
*
* @param toSkip
* the number of bytes to skip
* @throws IOException
* if the underlying stream failed
*/
void skipAllBytes(long toSkip) throws IOException;
/**
* Skip the number of bytes. This differs from the skip method in that it
* will throw an EOF if a forward skip cannot be fully accomplished...
* (However that isn't supposed to happen with a random access file, so
* there is probably no operational difference).
*
* @param toSkip
* the number of bytes to skip
* @throws IOException
* if the underlying stream failed
*/
void skipAllBytes(int toSkip) throws IOException;
/**
* Read a buffer and signal an EOF if the requested elements cannot be read.
* This differs from read(b,off,len) since that call will not signal and end
* of file unless no bytes can be read. However both of these routines will
* attempt to fill their buffers completely.
*
* @param b
* The input buffer.
* @param off
* The requested offset into the buffer.
* @param len
* The number of bytes requested.
*/
@Override
void readFully(byte[] b, int off, int len) throws IOException;
}
nom/tam/util/BufferedDataInputStream.java 0000664 0000000 0000000 00000035015 12755570700 017474 0 ustar root root package nom.tam.util;
import static nom.tam.util.LoggerHelper.getLogger;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
// What do we use in here?
import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* This class is intended for high performance I/O in scientific applications.
* It combines the functionality of the BufferedInputStream and the
* DataInputStream as well as more efficient handling of arrays. This minimizes
* the number of method calls that are required to read data. Informal tests of
* this method show that it can be as much as 10 times faster than using a
* DataInputStream layered on a BufferedInputStream for writing large arrays.
* The performance gain on scalars or small arrays will be less but there should
* probably never be substantial degradation of performance.
*
* Many new read calls are added to allow efficient reading off array data. The
* read(Object o) call provides for reading a primitive array of arbitrary type
* or dimensionality. There are also reads for each type of one dimensional
* array.
*
* Note that there is substantial duplication of code to minimize method
* invocations. E.g., the floating point read routines read the data as integer
* values and then convert to float. However the integer code is duplicated
* rather than invoked. There has been considerable effort expended to ensure
* that these routines are efficient, but they could easily be superceded if an
* efficient underlying I/O package were ever delivered as part of the basic
* Java libraries. [This has subsequently happened with the NIO package and in
* an ideal universe these classes would be rewritten to take advantage of NIO.]
*
* Testing and timing routines are provided in the
* nom.tam.util.test.BufferedFileTester class. Version 1.1: October 12, 2000:
* Fixed handling of EOF to return partially read arrays when EOF is detected.
* Version 1.2: July 20, 2009: Added handling of very large Object arrays.
* Additional work is required to handle very large arrays generally.
*/
public class BufferedDataInputStream extends BufferedInputStream implements ArrayDataInput {
private static final Logger LOG = getLogger(BufferedDataInputStream.class);
/**
* size of the skip buffer (if it exists) {@link #skipBuf}.
*/
private static final int SKIP_BUFFER_SIZE = 8192;
private final BufferPointer sharedBuffer = new BufferPointer().init(FitsIO.BYTES_IN_LONG);
private final BufferDecoder bufferDecoder = new BufferDecoder(this.sharedBuffer) {
@Override
protected void checkBuffer(int needBytes) throws IOException {
if (needBytes > 0) {
readBytesIntoSharedBuffer(needBytes);
}
}
@Override
protected int eofCheck(EOFException e, int start, int index, int length) throws EOFException {
return BufferedDataInputStream.this.eofCheck(e, index, start, length);
}
@Override
protected int read(byte[] buf, int offset, int length) throws IOException {
return BufferedDataInputStream.this.read(buf, offset, length);
}
};
/**
* Skip the requested number of bytes. This differs from the skip call in
* that it takes an long argument and will throw an end of file if the full
* number of bytes cannot be skipped.
*
* @param toSkip
* The number of bytes to skip.
*/
private byte[] skipBuf = null;
/**
* Create a BufferedInputStream based on an input stream.
*
* @param o
* the input stream to use for reading.
*/
public BufferedDataInputStream(InputStream o) {
this(o, FitsIO.DEFAULT_BUFFER_SIZE);
}
/**
* Create a BufferedInputStream based on a input stream with a specified
* buffer size.
*
* @param o
* the input stream to use for reading.
* @param bufLength
* the buffer length to use.
*/
public BufferedDataInputStream(InputStream o, int bufLength) {
super(o, bufLength);
}
/**
* For array reads return an EOF if unable to read any data.
*
* @param e
* the eof exception that happened.
* @param i
* the current index
* @param start
* the start index
* @param length
* the element length
* @return the number of bytes read before the end of file exception.
* @throws EOFException
* if no extra bytes could be read
*/
private int eofCheck(EOFException e, int i, int start, int length) throws EOFException {
if (i == start) {
throw e;
} else {
return (i - start) * length;
}
}
@Override
public int read(boolean[] b) throws IOException {
return read(b, 0, b.length);
}
@Override
public int read(boolean[] b, int start, int length) throws IOException {
return this.bufferDecoder.read(b, start, length);
}
@Override
public int read(byte[] obuf, int offset, int length) throws IOException {
int total = 0;
int remainingToRead = length;
int currentOffset = offset;
while (remainingToRead > 0) {
// Use just the buffered I/O to get needed info.
int xlen = super.read(obuf, currentOffset, remainingToRead);
if (xlen <= 0) {
if (total == 0) {
throw new EOFException();
} else {
return total;
}
} else {
remainingToRead -= xlen;
total += xlen;
currentOffset += xlen;
}
}
return total;
}
@Override
public int read(char[] c) throws IOException {
return read(c, 0, c.length);
}
@Override
public int read(char[] c, int start, int length) throws IOException {
return this.bufferDecoder.read(c, start, length);
}
@Override
public int read(double[] d) throws IOException {
return read(d, 0, d.length);
}
@Override
public int read(double[] d, int start, int length) throws IOException {
return this.bufferDecoder.read(d, start, length);
}
@Override
public int read(float[] f) throws IOException {
return read(f, 0, f.length);
}
@Override
public int read(float[] f, int start, int length) throws IOException {
return this.bufferDecoder.read(f, start, length);
}
@Override
public int read(int[] i) throws IOException {
return read(i, 0, i.length);
}
@Override
public int read(int[] i, int start, int length) throws IOException {
return this.bufferDecoder.read(i, start, length);
}
@Override
public int read(long[] l) throws IOException {
return read(l, 0, l.length);
}
@Override
public int read(long[] l, int start, int length) throws IOException {
return this.bufferDecoder.read(l, start, length);
}
@Override
public int read(short[] s) throws IOException {
return read(s, 0, s.length);
}
@Override
public int read(short[] s, int start, int length) throws IOException {
return this.bufferDecoder.read(s, start, length);
}
@Deprecated
@Override
public int readArray(Object o) throws IOException {
return (int) readLArray(o);
}
@Override
public boolean readBoolean() throws IOException {
return read() == 1;
}
@Override
public byte readByte() throws IOException {
return (byte) read();
}
private void readBytesIntoSharedBuffer(int bytes) throws IOException, EOFException {
this.sharedBuffer.invalidate();
if (read(this.sharedBuffer.buffer, 0, bytes) < bytes) {
throw new EOFException();
}
}
@Override
public char readChar() throws IOException {
return this.bufferDecoder.readChar();
}
@Override
public double readDouble() throws IOException {
return this.bufferDecoder.readDouble();
}
@Override
public float readFloat() throws IOException {
return this.bufferDecoder.readFloat();
}
@Override
public void readFully(byte[] b) throws IOException {
this.bufferDecoder.readFully(b, 0, b.length);
}
@Override
public void readFully(byte[] b, int off, int len) throws IOException {
this.bufferDecoder.readFully(b, off, len);
}
@Override
public int readInt() throws IOException {
return this.bufferDecoder.readInt();
}
@Override
public long readLArray(Object o) throws IOException {
return this.bufferDecoder.readLArray(o);
}
/**
* Emulate the deprecated DataInputStream.readLine() method. Originally we
* used the method itself, but Alan Brighton suggested using a
* java.io.BufferedReader to eliminate the deprecation warning. This was
* used for a long time, but more recently we noted that this doesn't work.
* We now use a simple method that largely ignores character encodings and
* only uses the "\n" as the line separator. This method is slow regardless.
* In the current version
*
* @return The String read.
* @deprecated Use {@link java.io.BufferedReader} methods.
*/
@Deprecated
@Override
public String readLine() throws IOException {
// Punt on this and use BufferedReader routines.
StringBuilder b = new StringBuilder(0);
int chr;
while ((chr = read()) >= 0) {
if (chr != '\n') {
b.append((char) chr);
} else {
return b.toString();
}
}
return b.toString();
}
@Override
public long readLong() throws IOException {
return this.bufferDecoder.readLong();
}
/**
* This routine provides efficient reading of arrays of any primitive type.
* It is an error to invoke this method with an object that is not an array
* of some primitive type. Note that there is no corresponding capability to
* writePrimitiveArray in BufferedDataOutputStream to read in an array of
* Strings.
*
* @return number of bytes read.
* @param o
* The object to be read. It must be an array of a primitive
* type, or an array of Object's.
* @throws IOException
* if the underlying read operation fails
* @deprecated use {@link #readLArray(Object)} instead
*/
@Deprecated
public int readPrimitiveArray(Object o) throws IOException {
return (int) readLArray(o);
}
@Override
public short readShort() throws IOException {
return this.bufferDecoder.readShort();
}
@Override
public int readUnsignedByte() throws IOException {
return read() & FitsIO.BYTE_MASK;
}
@Override
public int readUnsignedShort() throws IOException {
return this.bufferDecoder.readShort() & FitsIO.SHORT_MASK;
}
@Override
public String readUTF() throws IOException {
return DataInputStream.readUTF(this);
}
@Override
public void skipAllBytes(int toSkip) throws IOException {
skipAllBytes((long) toSkip);
}
@Override
public void skipAllBytes(long toSkip) throws IOException {
long need = toSkip;
while (need > 0) {
try {
long got = skip(need);
if (got > 0) {
need -= got;
} else {
break;
}
} catch (IOException e) {
long lastNeed = need;
need = handleExceptionInSkip(need, e);
if (need >= lastNeed) {
break;
}
}
}
if (need > 0) {
throw new EOFException();
}
}
private long handleExceptionInSkip(long skip, IOException e) throws IOException {
LOG.log(Level.WARNING, "Error while skipping bytes", e);
// Some input streams (process outputs) don't allow
// skipping. The kludgy solution here is to
// try to do a read when we get an error in the skip....
// Real IO errors will presumably cause an error
// in these reads too.
if (this.skipBuf == null) {
this.skipBuf = new byte[BufferedDataInputStream.SKIP_BUFFER_SIZE];
}
long remainingToSkip = skip;
while (remainingToSkip > BufferedDataInputStream.SKIP_BUFFER_SIZE) {
int got = read(this.skipBuf, 0, BufferedDataInputStream.SKIP_BUFFER_SIZE);
if (got <= 0) {
break;
}
remainingToSkip -= got;
}
while (remainingToSkip > 0) {
int got = read(this.skipBuf, 0, (int) remainingToSkip);
if (got <= 0) {
break;
}
remainingToSkip -= got;
}
return remainingToSkip;
}
@Override
public int skipBytes(int toSkip) throws IOException {
skipAllBytes(toSkip);
return toSkip;
}
@Override
public String toString() {
return super.toString() + "[count=" + this.count + ",pos=" + this.pos + "]";
}
}
nom/tam/util/ColumnTable.java 0000664 0000000 0000000 00000106604 12755570700 015174 0 ustar root root package nom.tam.util;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.io.IOException;
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import nom.tam.util.type.PrimitiveType;
import nom.tam.util.type.PrimitiveTypeHandler;
import nom.tam.util.type.PrimitiveTypes;
/**
* A data table is conventionally considered to consist of rows and columns,
* where the structure within each column is constant, but different columns may
* have different structures. I.e., structurally columns may differ but rows are
* identical. Typically tabular data is usually stored in row order which can
* make it extremely difficult to access efficiently using Java. This class
* provides efficient access to data which is stored in row order and allows
* users to get and set the elements of the table. The table can consist only of
* arrays of primitive types. Data stored in column order can be efficiently
* read and written using the BufferedDataXputStream classes. The table is
* represented entirely as a set of one-dimensional primitive arrays. For a
* given column, a row consists of some number of contiguous elements of the
* array. Each column is required to have the same number of rows. Information
* regarding the dimensionality of columns and possible data pointers is
* retained for use by clients which can understand them.
*/
public class ColumnTable implements DataTable {
private static final int MAX_COLUMN_INDEXES = 256;
private static final int MAX_TYPE_VALUE = MAX_COLUMN_INDEXES;
private interface PointerAccess {
void set(ColumnTable table, X array);
X get(ColumnTable table);
void write(ColumnTable table, ArrayDataOutput os, int index, int arrOffset, int size) throws IOException;
void read(ColumnTable table, ArrayDataInput is, int index, int arrOffset, int size) throws IOException;
}
private static final Map, PointerAccess> POINTER_ACCESSORS;
private static final PointerAccess[] POINTER_ACCESSORS_BY_TYPE = new PointerAccess[MAX_TYPE_VALUE];
static {
POINTER_ACCESSORS_BY_TYPE[PrimitiveTypes.BYTE.type()] = new PointerAccess() {
@Override
public byte[][] get(ColumnTable table) {
return table.bytePointers;
}
@Override
public void set(ColumnTable table, byte[][] array) {
table.bytePointers = array;
}
@Override
public void write(ColumnTable table, ArrayDataOutput os, int index, int arrOffset, int size) throws IOException {
os.write(table.bytePointers[index], arrOffset, size);
}
@Override
@SuppressFBWarnings(value = "RR_NOT_CHECKED", justification = "this read will never return less than the requested length")
public void read(ColumnTable table, ArrayDataInput is, int index, int arrOffset, int size) throws IOException {
is.read(table.bytePointers[index], arrOffset, size);
}
};
POINTER_ACCESSORS_BY_TYPE[PrimitiveTypes.BOOLEAN.type()] = new PointerAccess() {
@Override
public boolean[][] get(ColumnTable table) {
return table.booleanPointers;
}
@Override
public void set(ColumnTable table, boolean[][] array) {
table.booleanPointers = array;
}
@Override
public void write(ColumnTable table, ArrayDataOutput os, int index, int arrOffset, int size) throws IOException {
os.write(table.booleanPointers[index], arrOffset, size);
}
@Override
public void read(ColumnTable table, ArrayDataInput is, int index, int arrOffset, int size) throws IOException {
is.read(table.booleanPointers[index], arrOffset, size);
}
};
POINTER_ACCESSORS_BY_TYPE[PrimitiveTypes.SHORT.type()] = new PointerAccess() {
@Override
public short[][] get(ColumnTable table) {
return table.shortPointers;
}
@Override
public void set(ColumnTable table, short[][] array) {
table.shortPointers = array;
}
@Override
public void write(ColumnTable table, ArrayDataOutput os, int index, int arrOffset, int size) throws IOException {
os.write(table.shortPointers[index], arrOffset, size);
}
@Override
public void read(ColumnTable table, ArrayDataInput is, int index, int arrOffset, int size) throws IOException {
is.read(table.shortPointers[index], arrOffset, size);
}
};
POINTER_ACCESSORS_BY_TYPE[PrimitiveTypes.CHAR.type()] = new PointerAccess() {
@Override
public char[][] get(ColumnTable table) {
return table.charPointers;
}
@Override
public void set(ColumnTable table, char[][] array) {
table.charPointers = array;
}
@Override
public void write(ColumnTable table, ArrayDataOutput os, int index, int arrOffset, int size) throws IOException {
os.write(table.charPointers[index], arrOffset, size);
}
@Override
@SuppressFBWarnings(value = "RR_NOT_CHECKED", justification = "this read will never return less than the requested length")
public void read(ColumnTable table, ArrayDataInput is, int index, int arrOffset, int size) throws IOException {
is.read(table.charPointers[index], arrOffset, size);
}
};
POINTER_ACCESSORS_BY_TYPE[PrimitiveTypes.INT.type()] = new PointerAccess() {
@Override
public int[][] get(ColumnTable table) {
return table.intPointers;
}
@Override
public void set(ColumnTable table, int[][] array) {
table.intPointers = array;
}
@Override
public void write(ColumnTable table, ArrayDataOutput os, int index, int arrOffset, int size) throws IOException {
os.write(table.intPointers[index], arrOffset, size);
}
@Override
public void read(ColumnTable table, ArrayDataInput is, int index, int arrOffset, int size) throws IOException {
is.read(table.intPointers[index], arrOffset, size);
}
};
POINTER_ACCESSORS_BY_TYPE[PrimitiveTypes.LONG.type()] = new PointerAccess() {
@Override
public long[][] get(ColumnTable table) {
return table.longPointers;
}
@Override
public void set(ColumnTable table, long[][] array) {
table.longPointers = array;
}
@Override
public void write(ColumnTable table, ArrayDataOutput os, int index, int arrOffset, int size) throws IOException {
os.write(table.longPointers[index], arrOffset, size);
}
@Override
public void read(ColumnTable table, ArrayDataInput is, int index, int arrOffset, int size) throws IOException {
is.read(table.longPointers[index], arrOffset, size);
}
};
POINTER_ACCESSORS_BY_TYPE[PrimitiveTypes.FLOAT.type()] = new PointerAccess() {
@Override
public float[][] get(ColumnTable table) {
return table.floatPointers;
}
@Override
public void set(ColumnTable table, float[][] array) {
table.floatPointers = array;
}
@Override
public void write(ColumnTable table, ArrayDataOutput os, int index, int arrOffset, int size) throws IOException {
os.write(table.floatPointers[index], arrOffset, size);
}
@Override
public void read(ColumnTable table, ArrayDataInput is, int index, int arrOffset, int size) throws IOException {
is.read(table.floatPointers[index], arrOffset, size);
}
};
POINTER_ACCESSORS_BY_TYPE[PrimitiveTypes.DOUBLE.type()] = new PointerAccess() {
@Override
public double[][] get(ColumnTable table) {
return table.doublePointers;
}
@Override
public void set(ColumnTable table, double[][] array) {
table.doublePointers = array;
}
@Override
public void write(ColumnTable table, ArrayDataOutput os, int index, int arrOffset, int size) throws IOException {
os.write(table.doublePointers[index], arrOffset, size);
}
@Override
public void read(ColumnTable table, ArrayDataInput is, int index, int arrOffset, int size) throws IOException {
is.read(table.doublePointers[index], arrOffset, size);
}
};
Map, PointerAccess> pointerAccess = new HashMap, PointerAccess>();
pointerAccess.put(PrimitiveTypes.BYTE, POINTER_ACCESSORS_BY_TYPE[PrimitiveTypes.BYTE.type()]);
pointerAccess.put(PrimitiveTypes.BOOLEAN, POINTER_ACCESSORS_BY_TYPE[PrimitiveTypes.BOOLEAN.type()]);
pointerAccess.put(PrimitiveTypes.CHAR, POINTER_ACCESSORS_BY_TYPE[PrimitiveTypes.CHAR.type()]);
pointerAccess.put(PrimitiveTypes.SHORT, POINTER_ACCESSORS_BY_TYPE[PrimitiveTypes.SHORT.type()]);
pointerAccess.put(PrimitiveTypes.INT, POINTER_ACCESSORS_BY_TYPE[PrimitiveTypes.INT.type()]);
pointerAccess.put(PrimitiveTypes.LONG, POINTER_ACCESSORS_BY_TYPE[PrimitiveTypes.LONG.type()]);
pointerAccess.put(PrimitiveTypes.FLOAT, POINTER_ACCESSORS_BY_TYPE[PrimitiveTypes.FLOAT.type()]);
pointerAccess.put(PrimitiveTypes.DOUBLE, POINTER_ACCESSORS_BY_TYPE[PrimitiveTypes.DOUBLE.type()]);
POINTER_ACCESSORS = Collections.unmodifiableMap(pointerAccess);
}
/** The columns to be read/written */
private Object[] arrays;
/** The number of elements in a row for each column */
private int[] sizes;
/** The number of rows */
private int nrow;
/**
* The base type of each row (using the second character of the [x class
* names of the arrays.
*/
private char[] types;
private Class[] bases;
// The following arrays are used to avoid having to check
// casts during the I/O loops.
// They point to elements of arrays.
private byte[][] bytePointers;
private short[][] shortPointers;
private int[][] intPointers;
private long[][] longPointers;
private float[][] floatPointers;
private double[][] doublePointers;
private char[][] charPointers;
private boolean[][] booleanPointers;
/**
* Allow the client to provide opaque data.
*/
private T extraState;
/**
* Create the object after checking consistency.
*
* @param arrays
* An array of one-d primitive arrays.
* @param sizes
* The number of elements in each row for the corresponding
* column
* @throws TableException
* if the structure of the columns is not consistent
*/
public ColumnTable(Object[] arrays, int[] sizes) throws TableException {
setup(arrays, sizes);
}
/**
* Add a column .
*
* @param newColumn
* the column to add.
* @param size
* size for the column
* @throws TableException
* if the structure of the new column does not fit the structure
* of the rows/columns
*/
public void addColumn(Object newColumn, int size) throws TableException {
String classname = newColumn.getClass().getName();
this.nrow = checkColumnConsistency(newColumn, classname, this.nrow, size);
int ncol = this.arrays.length;
Object[] newArrays = new Object[ncol + 1];
int[] newSizes = new int[ncol + 1];
Class[] newBases = new Class[ncol + 1];
char[] newTypes = new char[ncol + 1];
System.arraycopy(this.arrays, 0, newArrays, 0, ncol);
System.arraycopy(this.sizes, 0, newSizes, 0, ncol);
System.arraycopy(this.bases, 0, newBases, 0, ncol);
System.arraycopy(this.types, 0, newTypes, 0, ncol);
this.arrays = newArrays;
this.sizes = newSizes;
this.bases = newBases;
this.types = newTypes;
this.arrays[ncol] = newColumn;
this.sizes[ncol] = size;
this.bases[ncol] = ArrayFuncs.getBaseClass(newColumn);
this.types[ncol] = classname.charAt(1);
addPointer(newColumn);
}
/**
* Add a pointer in the pointer lists.
*
* @param data
* data pointer to add
* @throws TableException
* if the structure of the specified array does not fit the
* structure of the rows/columns
*/
protected void addPointer(Object data) throws TableException {
PointerAccess accessor = selectPointerAccessor(data);
if (accessor == null) {
throw new TableException("Invalid type for added column:" + data.getClass().getComponentType());
} else {
accessor.set(this, extendArray(accessor.get(this), data));
}
}
@SuppressWarnings("unchecked")
private PointerAccess selectPointerAccessor(Object data) {
return (PointerAccess) POINTER_ACCESSORS.get(PrimitiveTypeHandler.valueOf(data.getClass().getComponentType()));
}
@SuppressWarnings("unchecked")
private ArrayType extendArray(ArrayType originalArray, Object data) {
int length = Array.getLength(originalArray);
Object xb = Array.newInstance(originalArray.getClass().getComponentType(), length + 1);
System.arraycopy(originalArray, 0, xb, 0, length);
Array.set(xb, length, data);
return (ArrayType) xb;
}
/**
* Add a row to the table. This method is very inefficient for adding
* multiple rows and should be avoided if possible.
*
* @param row
* the row to add
* @throws TableException
* if the structure of the specified array does not fit the
* structure of the rows/columns
*/
public void addRow(Object[] row) throws TableException {
if (this.arrays.length == 0) {
for (Object element : row) {
addColumn(element, Array.getLength(element));
}
} else {
if (row.length != this.arrays.length) {
throw new TableException("Row length mismatch");
}
for (int i = 0; i < row.length; i += 1) {
if (row[i].getClass() != this.arrays[i].getClass() || Array.getLength(row[i]) != this.sizes[i]) {
throw new TableException("Row column mismatch at column:" + i);
}
Object xarray = ArrayFuncs.newInstance(this.bases[i], (this.nrow + 1) * this.sizes[i]);
System.arraycopy(this.arrays[i], 0, xarray, 0, this.nrow * this.sizes[i]);
System.arraycopy(row[i], 0, xarray, this.nrow * this.sizes[i], this.sizes[i]);
this.arrays[i] = xarray;
}
initializePointers();
this.nrow += 1;
}
}
/**
* Check that the columns and sizes are consistent. Inconsistencies include:
*
* arrays and sizes have different lengths.
* an element of arrays is not a primitive array.
* the size of an array is not divisible by the sizes entry.
* the number of rows differs for the columns.
*
*
* @param newArrays
* The arrays defining the columns.
* @param newSizes
* The number of elements in each row for the column.
* @throws TableException
* if the table was inconsistent
*/
protected void checkArrayConsistency(Object[] newArrays, int[] newSizes) throws TableException {
// This routine throws an error if it detects an inconsistency
// between the arrays being read in.
// First check that the lengths of the two arrays are the same.
if (newArrays.length != newSizes.length) {
throw new TableException("readArraysAsColumns: Incompatible arrays and sizes.");
}
// Now check that that we fill up all of the arrays exactly.
int ratio = 0;
int newRowSize = 0;
this.types = new char[newArrays.length];
this.bases = new Class[newArrays.length];
for (int i = 0; i < newArrays.length; i += 1) {
String classname = newArrays[i].getClass().getName();
ratio = checkColumnConsistency(newArrays[i], classname, ratio, newSizes[i]);
newRowSize += newSizes[i] * ArrayFuncs.getBaseLength(newArrays[i]);
this.types[i] = classname.charAt(1);
this.bases[i] = ArrayFuncs.getBaseClass(newArrays[i]);
}
this.nrow = ratio;
this.arrays = newArrays;
this.sizes = newSizes;
}
private int checkColumnConsistency(Object data, String classname, int ratio, int size) throws TableException {
if (classname.charAt(0) != '[' || classname.length() != 2) {
throw new TableException("Non-primitive array for column");
}
int thisSize = Array.getLength(data);
if (thisSize == 0 && size != 0 && ratio != 0 || thisSize != 0 && size == 0) {
throw new TableException("Size mismatch in column: " + thisSize + " != " + size);
}
// The row size must evenly divide the size of the array.
if (size != 0 && thisSize % size != 0) {
throw new TableException("Row size does not divide array for column");
}
// Finally the ratio of sizes must be the same for all columns -- this
// is the number of rows in the table.
int thisRatio = 0;
if (size > 0) {
thisRatio = thisSize / size;
if (ratio != 0 && thisRatio != ratio) {
throw new TableException("Different number of rows in different columns");
}
}
if (thisRatio > 0) {
return thisRatio;
} else {
return ratio;
}
}
public ColumnTable copy() throws TableException {
return new ColumnTable((Object[]) ArrayFuncs.deepClone(this.arrays), this.sizes.clone());
}
/**
* Delete a contiguous set of columns from the table.
*
* @param start
* The first column (0-indexed) to be deleted.
* @param len
* The number of columns to be deleted.
* @throws TableException
* if the request goes outside the boundaries of the table or if
* the length is negative.
*/
public void deleteColumns(int start, int len) throws TableException {
int ncol = this.arrays.length;
if (start < 0 || len < 0 || start + len > ncol) {
throw new TableException("Invalid request to delete columns start: " + start + " length:" + len + " for table with " + ncol + " columns.");
}
if (len == 0) {
return;
}
int ocol = ncol;
ncol -= len;
Object[] newArrays = new Object[ncol];
int[] newSizes = new int[ncol];
Class[] newBases = new Class[ncol];
char[] newTypes = new char[ncol];
System.arraycopy(this.arrays, 0, newArrays, 0, start);
System.arraycopy(this.sizes, 0, newSizes, 0, start);
System.arraycopy(this.bases, 0, newBases, 0, start);
System.arraycopy(this.types, 0, newTypes, 0, start);
int rem = ocol - (start + len);
System.arraycopy(this.arrays, start + len, newArrays, start, rem);
System.arraycopy(this.sizes, start + len, newSizes, start, rem);
System.arraycopy(this.bases, start + len, newBases, start, rem);
System.arraycopy(this.types, start + len, newTypes, start, rem);
this.arrays = newArrays;
this.sizes = newSizes;
this.bases = newBases;
this.types = newTypes;
initializePointers();
}
/**
* Delete a row from the table.
*
* @param row
* The row (0-indexed) to be deleted.
* @throws TableException
* if the request goes outside the boundaries of the table or if
* the length is negative.
*/
public void deleteRow(int row) throws TableException {
deleteRows(row, 1);
}
/**
* Delete a contiguous set of rows from the table.
*
* @param row
* The row (0-indexed) to be deleted.
* @param length
* The number of rows to be deleted.
* @throws TableException
* if the request goes outside the boundaries of the table or if
* the length is negative.
*/
public void deleteRows(int row, int length) throws TableException {
if (row < 0 || length < 0 || row + length > this.nrow) {
throw new TableException("Invalid request to delete rows start: " + row + " length:" + length + " for table with " + this.nrow + " rows.");
}
if (length == 0) {
return;
}
for (int col = 0; col < this.arrays.length; col += 1) {
int sz = this.sizes[col];
int newSize = sz * (this.nrow - length);
Object newArr = ArrayFuncs.newInstance(this.bases[col], newSize);
// Copy whatever comes before the deletion
System.arraycopy(this.arrays[col], 0, newArr, 0, row * sz);
// Copy whatever comes after the deletion
System.arraycopy(this.arrays[col], (row + length) * sz, newArr, row * sz, (this.nrow - row - length) * sz);
this.arrays[col] = newArr;
}
this.nrow -= length;
initializePointers();
}
/**
* Get the base classes of the columns.
*
* @return An array of Class objects, one for each column.
*/
@SuppressFBWarnings(value = "EI_EXPOSE_REP", justification = "intended exposure of mutable data")
public Class[] getBases() {
return this.bases;
}
/**
* Get a particular column.
*
* @param col
* The column desired.
* @return an object containing the column data desired. This will be an
* instance of a 1-d primitive array.
*/
@Override
public Object getColumn(int col) {
return this.arrays[col];
}
/**
* @return the actual data arrays
*/
@SuppressFBWarnings(value = "EI_EXPOSE_REP", justification = "intended exposure of mutable data")
public Object[] getColumns() {
return this.arrays;
}
/**
* Get a element of the table.
*
* @param row
* The row desired.
* @param col
* The column desired.
* @return A primitive array containing the information. Note that an array
* will be returned even if the element is a scalar.
*/
@Override
public Object getElement(int row, int col) {
Object x = ArrayFuncs.newInstance(this.bases[col], this.sizes[col]);
System.arraycopy(this.arrays[col], this.sizes[col] * row, x, 0, this.sizes[col]);
return x;
}
/**
* @return the pointer state
*/
public T getExtraState() {
return this.extraState;
}
/**
* Get the number of columns in the table.
*/
@Override
public int getNCols() {
return this.arrays.length;
}
/**
* Get the number of rows in the table.
*/
@Override
public int getNRows() {
return this.nrow;
}
/**
* Get a row of data.
*
* @param row
* The row desired.
* @return An array of objects each containing a primitive array.
*/
@Override
public Object getRow(int row) {
Object[] x = new Object[this.arrays.length];
for (int col = 0; col < this.arrays.length; col += 1) {
x[col] = getElement(row, col);
}
return x;
}
@SuppressFBWarnings(value = "EI_EXPOSE_REP", justification = "intended exposure of mutable data")
public int[] getSizes() {
return this.sizes;
}
/**
* Get the characters describing the base classes of the columns.
*
* @return An array of char's, one for each column.
*/
@SuppressFBWarnings(value = "EI_EXPOSE_REP", justification = "intended exposure of mutable data")
public char[] getTypes() {
return this.types;
}
/**
* Set the pointer arrays for the eight primitive types to point to the
* appropriate elements of arrays.
*/
protected void initializePointers() {
int[] columnIndex = new int[MAX_COLUMN_INDEXES];
for (int col = 0; col < this.arrays.length; col += 1) {
columnIndex[this.types[col]]++;
}
// Allocate the pointer arrays. Note that many will be
// zero-length.
this.bytePointers = new byte[columnIndex[PrimitiveTypes.BYTE.type()]][];
this.shortPointers = new short[columnIndex[PrimitiveTypes.SHORT.type()]][];
this.intPointers = new int[columnIndex[PrimitiveTypes.INT.type()]][];
this.longPointers = new long[columnIndex[PrimitiveTypes.LONG.type()]][];
this.floatPointers = new float[columnIndex[PrimitiveTypes.FLOAT.type()]][];
this.doublePointers = new double[columnIndex[PrimitiveTypes.DOUBLE.type()]][];
this.charPointers = new char[columnIndex[PrimitiveTypes.CHAR.type()]][];
this.booleanPointers = new boolean[columnIndex[PrimitiveTypes.BOOLEAN.type()]][];
// Now set the pointers.
Arrays.fill(columnIndex, 0);
for (int col = 0; col < this.arrays.length; col += 1) {
char colType = this.types[col];
PointerAccess accessor = POINTER_ACCESSORS_BY_TYPE[colType];
Array.set(accessor.get(this), columnIndex[colType], this.arrays[col]);
columnIndex[colType]++;
}
}
/**
* Read a table.
*
* @param is
* The input stream to read from.
* @throws IOException
* if the reading failed
*/
public void read(ArrayDataInput is) throws IOException {
int[] columnIndex = new int[MAX_COLUMN_INDEXES];
// While we have not finished reading the table..
for (int row = 0; row < this.nrow; row += 1) {
Arrays.fill(columnIndex, 0);
// Loop over the columns within the row.
for (int col = 0; col < this.arrays.length; col += 1) {
int arrOffset = this.sizes[col] * row;
int size = this.sizes[col];
char colType = this.types[col];
PointerAccess accessor = POINTER_ACCESSORS_BY_TYPE[colType];
accessor.read(this, is, columnIndex[colType], arrOffset, size);
columnIndex[colType] += 1;
}
}
}
/**
* Set the values in a particular column. The new values must match the old
* in length but not necessarily in type.
*
* @param col
* The column to modify.
* @param newColumn
* The new column data. This should be a primitive array.
* @exception TableException
* Thrown when the new data is not commenserable with
* information in the table.
*/
@Override
public void setColumn(int col, Object newColumn) throws TableException {
boolean reset = newColumn.getClass() != this.arrays[col].getClass() || Array.getLength(newColumn) != Array.getLength(this.arrays[col]);
this.arrays[col] = newColumn;
if (reset) {
setup(this.arrays, this.sizes);
} else {
// This is required, because otherwise the typed pointer may point
// to the old
// array, which has been replaced by newColumn. Added by Jeroen de
// Jong, 1 Aug 2006
initializePointers();
}
}
/**
* Modify an element of the table.
*
* @param row
* The row containing the element.
* @param col
* The column containing the element.
* @param x
* The new datum. This should be 1-d primitive array.
* @exception TableException
* Thrown when the new data is not of the same type as the
* data it replaces.
*/
@Override
public void setElement(int row, int col, Object x) throws TableException {
String classname = x.getClass().getName();
if (!classname.equals("[" + this.types[col])) {
throw new TableException("setElement: Incompatible element type");
}
if (Array.getLength(x) != this.sizes[col]) {
throw new TableException("setElement: Incompatible element size");
}
System.arraycopy(x, 0, this.arrays[col], this.sizes[col] * row, this.sizes[col]);
}
/**
* Store additional information that may be needed by the client to
* regenerate initial arrays.
*
* @param opaque
* the extra state to set.
*/
public void setExtraState(T opaque) {
this.extraState = opaque;
}
/**
* Modify a row of data.
*
* @param row
* The row to be modified.
* @param x
* The data to be modified. This should be an array of objects.
* It is described as an Object here since other table
* implementations may use other methods to store the data (e.g., @see
* nom.tam.util.ColumnTable)
*/
@Override
public void setRow(int row, Object x) throws TableException {
if (!(x instanceof Object[])) {
throw new TableException("setRow: Incompatible row");
}
for (int col = 0; col < this.arrays.length; col += 1) {
setElement(row, col, ((Object[]) x)[col]);
}
}
/**
* Actually perform the initialization.
*
* @param newArrays
* An array of one-d primitive arrays.
* @param newSizes
* The number of elements in each row for the corresponding
* column
* @throws TableException
* if the structure of the columns is not consistent
*/
private void setup(Object[] newArrays, int[] newSizes) throws TableException {
checkArrayConsistency(newArrays, newSizes);
initializePointers();
}
/**
* Write a table.
*
* @param os
* the output stream to write to.
* @throws IOException
* if the write operation failed
*/
public void write(ArrayDataOutput os) throws IOException {
int[] columnIndex = new int[MAX_COLUMN_INDEXES];
for (int row = 0; row < this.nrow; row += 1) {
Arrays.fill(columnIndex, 0);
// Loop over the columns within the row.
for (int col = 0; col < this.arrays.length; col += 1) {
int arrOffset = this.sizes[col] * row;
int size = this.sizes[col];
char colType = this.types[col];
POINTER_ACCESSORS_BY_TYPE[colType].write(this, os, columnIndex[colType], arrOffset, size);
columnIndex[colType] += 1;
}
}
}
/**
* Write a column of a table.
*
* @param os
* the output stream to write to.
* @param rowStart
* first row to write
* @param rowEnd
* row number that should not be written anymore
* @param columnNr
* zero based column number to write.
* @throws IOException
* if the write operation failed
*/
public void write(ArrayDataOutput os, int rowStart, int rowEnd, int columnNr) throws IOException {
int[] columnIndex = new int[MAX_COLUMN_INDEXES];
for (int row = 0; row < this.nrow; row += 1) {
if (row >= rowStart && row < rowEnd) {
Arrays.fill(columnIndex, 0);
// Loop over the columns within the row.
for (int col = 0; col < this.arrays.length; col += 1) {
int arrOffset = this.sizes[col] * row;
int size = this.sizes[col];
char colType = this.types[col];
if (columnNr == col) {
POINTER_ACCESSORS_BY_TYPE[colType].write(this, os, columnIndex[colType], arrOffset, size);
}
columnIndex[colType] += 1;
}
}
}
}
/**
* Read a column of a table.
*
* @param is
* The input stream to read from.
* @param rowStart
* first row to read
* @param rowEnd
* row number that should not be read anymore
* @param columnNr
* the columnNumber to read.
* @throws IOException
* if the reading failed
*/
public void read(ArrayDataInput is, int rowStart, int rowEnd, int columnNr) throws IOException {
int[] columnIndex = new int[MAX_COLUMN_INDEXES];
// While we have not finished reading the table..
for (int row = 0; row < this.nrow; row += 1) {
if (row >= rowStart && row < rowEnd) {
Arrays.fill(columnIndex, 0);
// Loop over the columns within the row.
for (int col = 0; col < this.arrays.length; col += 1) {
int arrOffset = this.sizes[col] * row;
int size = this.sizes[col];
char colType = this.types[col];
if (col == columnNr) {
POINTER_ACCESSORS_BY_TYPE[colType].read(this, is, columnIndex[colType], arrOffset, size);
}
columnIndex[colType] += 1;
}
}
}
}
}
nom/tam/util/HashedList.java 0000664 0000000 0000000 00000031664 12755570700 015022 0 ustar root root package nom.tam.util;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
/**
* This class implements a structure which can
* be accessed either through a hash or
* as linear list. Only some elements may have
* a hash key.
*
* This class is motivated by the FITS header
* structure where a user may wish to go through
* the header element by element, or jump directly
* to a given keyword. It assumes that all
* keys are unique. However, all elements in the
* structure need not have a key.
*
* This class does only the search structure
* and knows nothing of the semantics of the
* referenced objects.
*
*/
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;
/**
* a ordered hash map implementation.
*
* @param
* value of the map
*/
public class HashedList> implements Collection {
private static final class EntryComparator> implements Comparator {
private final Comparator comp;
private EntryComparator(Comparator comp) {
this.comp = comp;
}
@Override
public int compare(VALUE o1, VALUE o2) {
return this.comp.compare(o1.getKey(), o2.getKey());
}
}
private class HashedListIterator implements Cursor {
/**
* This index points to the value that would be returned in the next
* 'next' call.
*/
private int current;
HashedListIterator(int start) {
this.current = start;
}
@Override
public void add(String key, VALUE ref) {
add(ref);
}
@Override
public void add(VALUE reference) {
HashedList.this.add(this.current++, reference);
}
@Override
public VALUE end() {
this.current = Math.max(0, HashedList.this.ordered.size() - 1);
return next();
}
@Override
public boolean hasNext() {
return this.current >= 0 && this.current < HashedList.this.ordered.size();
}
@Override
public boolean hasPrev() {
return this.current > 0;
}
@Override
public VALUE next() {
if (this.current < 0 || this.current >= HashedList.this.ordered.size()) {
throw new NoSuchElementException("Outside list");
} else {
VALUE entry = HashedList.this.ordered.get(this.current);
this.current++;
return entry;
}
}
@Override
public VALUE next(int count) {
for (int index = 1; index < count; index++) {
next();
}
return next();
}
@Override
public VALUE prev() {
if (this.current <= 0) {
throw new NoSuchElementException("Before beginning of list");
}
return HashedList.this.ordered.get(--this.current);
}
@Override
public void remove() {
if (this.current > 0 && this.current <= HashedList.this.ordered.size()) {
HashedList.this.remove(--this.current);
}
}
@Override
public void setKey(String key) {
VALUE entry = HashedList.this.keyed.get(key);
if (entry != null) {
this.current = indexOf(entry);
} else {
this.current = HashedList.this.ordered.size();
}
}
}
/** An ordered list of the keys */
private final ArrayList ordered = new ArrayList();
/** The key value pairs */
private final HashMap keyed = new HashMap();
/**
* Add an element to the list at a specified position. If that element was
* already in the list, it is first removed from the list then added again
* - if it was removed from a position before the position where it was to
* be added, that position is decremented by one.
*
* @param pos
* The position at which the specified element is to be added.
* If pos is bigger than the size of the list the element is
* put at the end of the list.
* @param reference
* The element to add to the list.
*/
private void add(int pos, VALUE reference) {
VALUE entry = reference;
String key = entry.getKey();
if (this.keyed.containsKey(key) && !unkeyedKey(key)) {
int oldPos = indexOf(entry);
this.keyed.remove(key);
this.ordered.remove(oldPos);
if (oldPos < pos) {
pos--;
}
}
this.keyed.put(key, entry);
if (pos >= this.ordered.size()) {
this.ordered.add(entry);
} else {
this.ordered.add(pos, entry);
}
}
private static boolean unkeyedKey(String key) {
return "COMMENT".equals(key) || "HISTORY".equals(key) || key.trim().isEmpty();
}
@Override
public boolean add(VALUE e) {
add(this.ordered.size(), e);
return true;
}
@Override
public boolean addAll(Collection c) {
for (VALUE element : c) {
add(element);
}
return true;
}
@Override
public void clear() {
this.keyed.clear();
this.ordered.clear();
}
@Override
public boolean contains(Object o) {
for (VALUE entry : this.ordered) {
if (o.equals(entry)) {
return true;
}
}
return false;
}
@Override
public boolean containsAll(Collection c) {
List values = new ArrayList(c);
for (VALUE entry : this.ordered) {
values.remove(entry);
}
return values.isEmpty();
}
/**
* @return true if the key is included in the list.
* @param key
* the key to search
*/
public boolean containsKey(Object key) {
return this.keyed.containsKey(key);
}
/**
* @return the n'th entry from the beginning.
* @param n
* the index to get
*/
public VALUE get(int n) {
return this.ordered.get(n);
}
/**
* @return the value of a keyed entry. Non-keyed entries may be returned by
* requesting an iterator.
* @param key
* the key to search for
*/
public VALUE get(Object key) {
return this.keyed.get(key);
}
// Note that, if the entry is not found, a NoSuchElementException is
// thrown instead of returning -1 (as is usual in indexOf methods) because
// the method is used internally in situations where the entry must be
// there.
int indexOf(VALUE entry) {
for (int index = 0; index < this.ordered.size(); index++) {
String searchKey = entry.getKey();
if (searchKey.equals(this.ordered.get(index).getKey())) {
return index;
}
}
throw new NoSuchElementException("Internal error: " + entry + " should have been found in " + ordered);
}
@Override
public boolean isEmpty() {
return this.ordered.isEmpty();
}
/**
* @return a HashedListIterator over the entire list.
*/
@Override
public HashedListIterator iterator() {
return new HashedListIterator(0);
}
/**
* @return an iterator starting with the n'th entry.
* @param n
* the index to start the iterator
*/
public Cursor iterator(int n) {
if (n >= 0 && n <= this.ordered.size()) {
return new HashedListIterator(n);
} else {
throw new NoSuchElementException("Invalid index for iterator:" + n);
}
}
/**
* @return an iterator over the list starting with the entry with a given
* key.
* @param key
* the key to use as a start point
*/
public HashedListIterator iterator(String key) {
VALUE entry = this.keyed.get(key);
if (entry != null) {
return new HashedListIterator(indexOf(entry));
} else {
throw new NoSuchElementException("Unknown key for iterator:" + key);
}
}
/**
* Remove an object from the list giving the object index..
*
* @param index
* the index to remove
* @return true if the index was in range
*/
public boolean remove(int index) {
if (index >= 0 && index < this.ordered.size()) {
return internalRemove(index, this.ordered.get(index));
}
return false;
}
private boolean internalRemove(int index, VALUE entry) {
this.keyed.remove(entry.getKey());
this.ordered.remove(index);
return true;
}
@Override
public boolean remove(Object o) {
for (int i = 0; i < this.ordered.size(); i++) {
VALUE entry = this.ordered.get(i);
if (o.equals(entry)) {
return internalRemove(i, entry);
}
}
return false;
}
@Override
public boolean removeAll(Collection c) {
boolean result = false;
for (Object element : c.toArray()) {
result = remove(element) || result;
}
return result;
}
/**
* Remove a keyed object from the list. Unkeyed objects can be removed from
* the list using a HashedListIterator or using the remove(Object) method.
*
* @param key
* the key to remove
* @return true if the key was removed
*/
public boolean removeKey(Object key) {
VALUE entry = this.keyed.get(key);
if (entry != null) {
int index = indexOf(entry);
this.keyed.remove(key);
this.ordered.remove(index);
return true;
}
return false;
}
/**
* Replace the key of a given element.
*
* @param oldKey
* The previous key. This key must be present in the hash.
* @param newKey
* The new key. This key must not be present in the hash.
* @return if the replacement was successful.
*/
public boolean replaceKey(String oldKey, String newKey) {
if (!this.keyed.containsKey(oldKey) || this.keyed.containsKey(newKey)) {
return false;
}
VALUE oldVal = this.keyed.get(oldKey);
// same entry in hashmap and ordered so only one change.
this.keyed.remove(oldKey);
this.keyed.put(newKey, oldVal);
return true;
}
@Override
public boolean retainAll(Collection c) {
Iterator iter = iterator();
boolean result = false;
while (iter.hasNext()) {
Object o = iter.next();
if (!c.contains(o)) {
iter.remove();
result = true;
}
}
return result;
}
@Override
public int size() {
return this.ordered.size();
}
/**
* Sort the keys into some desired order.
*
* @param comp
* the comparator to use for the sorting
*/
public void sort(final Comparator comp) {
java.util.Collections.sort(this.ordered, new EntryComparator(comp));
}
@Override
public Object[] toArray() {
return ordered.toArray();
}
@Override
public T[] toArray(T[] o) {
return ordered.toArray(o);
}
@Override
public String toString() {
return this.ordered.toString();
}
}
nom/tam/util/ArrayDataOutput.java 0000664 0000000 0000000 00000017676 12755570700 016072 0 ustar root root package nom.tam.util;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.io.IOException;
/**
* Special high performance scientific extension of the DataOutput interface.
*/
public interface ArrayDataOutput extends java.io.DataOutput, FitsIO {
/**
* Flush the output buffer
*
* @throws IOException
* if the flush of the underlying stream failed
*/
void flush() throws IOException;
/**
* Write an array of boolean's.
*
* @param buf
* array of boolean's.
* @throws IOException
* if one of the underlying write operations failed
*/
void write(boolean[] buf) throws IOException;
/**
* Write a segment of an array of boolean's.
*
* @param buf
* array of boolean's.
* @param offset
* start index in the array
* @param size
* number of array elements to write
* @throws IOException
* if one of the underlying write operations failed
*/
void write(boolean[] buf, int offset, int size) throws IOException;
/**
* Write an array of char's.
*
* @param buf
* array of char's.
* @throws IOException
* if one of the underlying write operations failed
*/
void write(char[] buf) throws IOException;
/**
* Write a segment of an array of char's.
*
* @param buf
* array of char's.
* @param offset
* start index in the array
* @param size
* number of array elements to write
* @throws IOException
* if one of the underlying write operations failed
*/
void write(char[] buf, int offset, int size) throws IOException;
/**
* Write an array of double's.
*
* @param buf
* array of double's.
* @throws IOException
* if one of the underlying write operations failed
*/
void write(double[] buf) throws IOException;
/**
* Write a segment of an array of double's.
*
* @param buf
* array of double's.
* @param offset
* start index in the array
* @param size
* number of array elements to write
* @throws IOException
* if one of the underlying write operations failed
*/
void write(double[] buf, int offset, int size) throws IOException;
/**
* Write an array of float's.
*
* @param buf
* array of float's.
* @throws IOException
* if one of the underlying write operations failed
*/
void write(float[] buf) throws IOException;
/**
* Write a segment of an array of float's.
*
* @param buf
* array of float's.
* @param offset
* start index in the array
* @param size
* number of array elements to write
* @throws IOException
* if one of the underlying write operations failed
*/
void write(float[] buf, int offset, int size) throws IOException;
/**
* Write an array of int's.
*
* @param buf
* array of int's
* @throws IOException
* if one of the underlying write operations failed
*/
void write(int[] buf) throws IOException;
/**
* Write a segment of an array of int's.
*
* @param buf
* array of int's
* @param offset
* start index in the array
* @param size
* number of array elements to write
* @throws IOException
* if one of the underlying write operations failed
*/
void write(int[] buf, int offset, int size) throws IOException;
/**
* Write an array of longs.
*
* @param buf
* array of longs
* @throws IOException
* if one of the underlying write operations failed
*/
void write(long[] buf) throws IOException;
/**
* Write a segment of an array of longs.
*
* @param buf
* array of longs
* @param offset
* start index in the array
* @param size
* number of array elements to write
* @throws IOException
* if one of the underlying write operations failed
*/
void write(long[] buf, int offset, int size) throws IOException;
/**
* Write an array of shorts.
*
* @param buf
* the value to write
* @throws IOException
* if one of the underlying write operations failed
*/
void write(short[] buf) throws IOException;
/**
* Write a segment of an array of shorts.
*
* @param buf
* the value to write
* @param offset
* start index in the array
* @param size
* number of array elements to write
* @throws IOException
* if one of the underlying write operations failed
*/
void write(short[] buf, int offset, int size) throws IOException;
/**
* Write an array of Strings. Equivalent to calling writeBytes for the
* selected elements.
*
* @param buf
* the array to write
* @throws IOException
* if one of the underlying write operations failed
*/
void write(String[] buf) throws IOException;
/**
* Write a segment of an array of Strings. Equivalent to calling writeBytes
* for the selected elements.
*
* @param buf
* the array to write
* @param offset
* start index in the array
* @param size
* number of array elements to write
* @throws IOException
* if one of the underlying write operations failed
*/
void write(String[] buf, int offset, int size) throws IOException;
/**
* This routine provides efficient writing of arrays of any primitive type.
* The String class is also handled but it is an error to invoke this method
* with an object that is not an array of these types. If the array is
* multidimensional, then it calls itself recursively to write the entire
* array. Strings are written using the standard 1 byte format (i.e., as in
* writeBytes). If the array is an array of objects, then
* writePrimitiveArray will be called for each element of the array.
*
* @param o
* The object to be written. It must be an array of a primitive
* type, Object, or String.
* @throws IOException
* if one of the underlying write operations failed
*/
void writeArray(Object o) throws IOException;
}
nom/tam/util/BufferedDataOutputStream.java 0000664 0000000 0000000 00000021334 12755570700 017674 0 ustar root root package nom.tam.util;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
// What do we use in here?
import java.io.BufferedOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.OutputStream;
/**
* This class is intended for high performance I/O in scientific applications.
* It combines the functionality of the BufferedOutputStream and the
* DataOutputStream as well as more efficient handling of arrays. This minimizes
* the number of method calls that are required to write data. Informal tests of
* this method show that it can be as much as 10 times faster than using a
* DataOutputStream layered on a BufferedOutputStream for writing large arrays.
* The performance gain on scalars or small arrays will be less but there should
* probably never be substantial degradation of performance.
*
* Note that there is substantial duplication of code to minimize method
* invocations. However simple output methods were used where empirical tests
* seemed to indicate that the simpler method did not cost any time. It seems
* likely that most of these variations will be washed out across different
* compilers and users who wish to tune the method for their particular system
* may wish to compare the the implementation of write(int[], int, int) with
* write(float[], int, int).
*
* Testing and timing for this class is performed in the
* nom.tam.util.test.BufferedFileTester class.
*/
public class BufferedDataOutputStream extends BufferedOutputStream implements ArrayDataOutput {
private final BufferPointer bufferPointer = new BufferPointer(this.buf);
private final BufferEncoder bufferEncoder = new BufferEncoder(this.bufferPointer) {
@Override
protected void needBuffer(int need) throws IOException {
BufferedDataOutputStream.this.checkBuf(need);
BufferedDataOutputStream.this.bufferPointer.bufferLength = BufferedDataOutputStream.this.count;
BufferedDataOutputStream.this.bufferPointer.bufferOffset = BufferedDataOutputStream.this.count;
BufferedDataOutputStream.this.count += need;
}
@Override
protected void write(byte[] buf, int offset, int length) throws IOException {
BufferedDataOutputStream.this.write(buf, offset, length);
}
};
/**
* Use the BufferedOutputStream constructor
*
* @param o
* An open output stream.
*/
public BufferedDataOutputStream(OutputStream o) {
super(o, FitsIO.DEFAULT_BUFFER_SIZE);
}
/**
* Use the BufferedOutputStream constructor
*
* @param o
* An open output stream.
* @param bufLength
* The buffer size.
*/
public BufferedDataOutputStream(OutputStream o, int bufLength) {
super(o, bufLength);
}
/**
* See if there is enough space to add something to the buffer.
*
* @param need
* the number of bytes that should be available in the buffer.
* @throws IOException
* if the underlying write operation fails
*/
protected void checkBuf(int need) throws IOException {
if (this.count + need > this.buf.length) {
this.out.write(this.buf, 0, this.count);
this.count = 0;
}
}
@Override
public void write(boolean[] b) throws IOException {
write(b, 0, b.length);
}
@Override
public void write(boolean[] b, int start, int length) throws IOException {
this.bufferEncoder.write(b, start, length);
}
@Override
public void write(char[] c) throws IOException {
write(c, 0, c.length);
}
@Override
public void write(char[] c, int start, int length) throws IOException {
this.bufferEncoder.write(c, start, length);
}
@Override
public void write(double[] d) throws IOException {
write(d, 0, d.length);
}
@Override
public void write(double[] d, int start, int length) throws IOException {
this.bufferEncoder.write(d, start, length);
}
@Override
public void write(float[] f) throws IOException {
write(f, 0, f.length);
}
@Override
public void write(float[] f, int start, int length) throws IOException {
this.bufferEncoder.write(f, start, length);
}
@Override
public void write(int[] i) throws IOException {
write(i, 0, i.length);
}
@Override
public void write(int[] i, int start, int length) throws IOException {
this.bufferEncoder.write(i, start, length);
}
@Override
public void write(long[] l) throws IOException {
write(l, 0, l.length);
}
@Override
public void write(long[] l, int start, int length) throws IOException {
this.bufferEncoder.write(l, start, length);
}
@Override
public void write(short[] s) throws IOException {
write(s, 0, s.length);
}
@Override
public void write(short[] s, int start, int length) throws IOException {
this.bufferEncoder.write(s, start, length);
}
@Override
public void write(String[] s) throws IOException {
write(s, 0, s.length);
}
@Override
public void write(String[] s, int start, int len) throws IOException {
// Do not worry about buffering this specially since the
// strings may be of differing lengths.
for (String element : s) {
writeBytes(element);
}
}
@Override
public void writeArray(Object o) throws IOException {
this.bufferEncoder.writeArray(o);
}
@Override
public void writeBoolean(boolean b) throws IOException {
this.bufferEncoder.writeBoolean(b);
}
@Override
public void writeByte(int b) throws IOException {
this.bufferEncoder.writeByte(b);
}
@Override
public void writeBytes(String s) throws IOException {
write(AsciiFuncs.getBytes(s), 0, s.length());
}
@Override
public void writeChar(int c) throws IOException {
this.bufferEncoder.writeChar(c);
}
@Override
public void writeChars(String s) throws IOException {
this.bufferEncoder.writeChars(s);
}
@Override
public void writeDouble(double d) throws IOException {
this.bufferEncoder.writeDouble(d);
}
@Override
public void writeFloat(float f) throws IOException {
this.bufferEncoder.writeFloat(f);
}
@Override
public void writeInt(int i) throws IOException {
this.bufferEncoder.writeInt(i);
}
@Override
public void writeLong(long l) throws IOException {
this.bufferEncoder.writeLong(l);
}
/**
* Deprecated use {@link #writeArray(Object)}.
*
* @param o
* The object to be written.
* @throws IOException
* if one of the underlying write operations failed
* @deprecated use {@link #writeArray(Object)} instead
*/
@Deprecated
public void writePrimitiveArray(Object o) throws IOException {
writeArray(o);
}
/**
* Write a short value.
*/
@Override
public void writeShort(int s) throws IOException {
this.bufferEncoder.writeShort(s);
}
@Override
public void writeUTF(String s) throws IOException {
// Punt on this one and use standard routines.
DataOutputStream d = new DataOutputStream(this) {
@Override
public void close() throws IOException {
flush();
}
};
d.writeUTF(s);
d.close();
}
}
nom/tam/util/BufferEncoder.java 0000664 0000000 0000000 00000017202 12755570700 015473 0 ustar root root package nom.tam.util;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.io.IOException;
import java.lang.reflect.Array;
public abstract class BufferEncoder {
private final BufferPointer sharedBuffer;
protected BufferEncoder(BufferPointer sharedBuffer) {
this.sharedBuffer = sharedBuffer;
}
protected abstract void needBuffer(int need) throws IOException;
protected void write(boolean[] b, int start, int length) throws IOException {
for (int i = start; i < start + length; i++) {
writeBoolean(b[i]);
}
}
protected abstract void write(byte[] buf, int offset, int length) throws IOException;
protected void write(char[] c, int start, int length) throws IOException {
for (int i = start; i < start + length; i++) {
writeChar(c[i]);
}
}
protected void write(double[] d, int start, int length) throws IOException {
for (int i = start; i < start + length; i++) {
writeLong(Double.doubleToLongBits(d[i]));
}
}
protected void write(float[] f, int start, int length) throws IOException {
for (int i = start; i < start + length; i++) {
writeInt(Float.floatToIntBits(f[i]));
}
}
protected void write(int[] i, int start, int length) throws IOException {
for (int ii = start; ii < start + length; ii++) {
writeInt(i[ii]);
}
}
protected void write(long[] l, int start, int length) throws IOException {
for (int i = start; i < start + length; i++) {
writeLong(l[i]);
}
}
protected void write(short[] s, int start, int length) throws IOException {
for (int i = start; i < start + length; i++) {
writeShort(s[i]);
}
}
protected void write(String[] s, int start, int length) throws IOException {
for (int i = start; i < start + length; i++) {
write(AsciiFuncs.getBytes(s[i]), 0, s[i].length());
}
}
protected void writeArray(Object o) throws IOException {
if (!o.getClass().isArray()) {
throw new IOException("Invalid object passed to BufferedDataOutputStream.write" + o.getClass().getName());
}
int length = Array.getLength(o);
// Is this a multidimensional array? If so process recursiv
if (o.getClass().getComponentType().isArray()) {
for (int i = 0; i < length; i++) {
writeArray(Array.get(o, i));
}
} else {
if (o instanceof boolean[]) {
write((boolean[]) o, 0, length);
} else if (o instanceof byte[]) {
write((byte[]) o, 0, length);
} else if (o instanceof char[]) {
write((char[]) o, 0, length);
} else if (o instanceof short[]) {
write((short[]) o, 0, length);
} else if (o instanceof int[]) {
write((int[]) o, 0, length);
} else if (o instanceof long[]) {
write((long[]) o, 0, length);
} else if (o instanceof float[]) {
write((float[]) o, 0, length);
} else if (o instanceof double[]) {
write((double[]) o, 0, length);
} else if (o instanceof String[]) {
write((String[]) o, 0, length);
} else {
for (int i = 0; i < length; i++) {
writeArray(Array.get(o, i));
}
}
}
}
protected void writeBoolean(boolean b) throws IOException {
needBuffer(FitsIO.BYTES_IN_BOOLEAN);
if (b) {
this.sharedBuffer.buffer[this.sharedBuffer.bufferOffset] = (byte) 1;
} else {
this.sharedBuffer.buffer[this.sharedBuffer.bufferOffset] = (byte) 0;
}
this.sharedBuffer.bufferOffset++;
}
protected void writeByte(int b) throws IOException {
needBuffer(FitsIO.BYTES_IN_BYTE);
this.sharedBuffer.buffer[this.sharedBuffer.bufferOffset++] = (byte) b;
}
protected void writeChar(int c) throws IOException {
needBuffer(FitsIO.BYTES_IN_CHAR);
this.sharedBuffer.buffer[this.sharedBuffer.bufferOffset++] = (byte) (c >>> FitsIO.BITS_OF_1_BYTE);
this.sharedBuffer.buffer[this.sharedBuffer.bufferOffset++] = (byte) c;
}
protected void writeChars(String s) throws IOException {
int len = s.length();
for (int i = 0; i < len; i++) {
writeChar(s.charAt(i));
}
}
protected void writeDouble(double d) throws IOException {
writeLong(Double.doubleToLongBits(d));
}
protected void writeFloat(float f) throws IOException {
writeInt(Float.floatToIntBits(f));
}
protected void writeInt(int i) throws IOException {
needBuffer(FitsIO.BYTES_IN_INTEGER);
this.sharedBuffer.buffer[this.sharedBuffer.bufferOffset++] = (byte) (i >>> FitsIO.BITS_OF_3_BYTES);
this.sharedBuffer.buffer[this.sharedBuffer.bufferOffset++] = (byte) (i >>> FitsIO.BITS_OF_2_BYTES);
this.sharedBuffer.buffer[this.sharedBuffer.bufferOffset++] = (byte) (i >>> FitsIO.BITS_OF_1_BYTE);
this.sharedBuffer.buffer[this.sharedBuffer.bufferOffset++] = (byte) i;
}
protected void writeLong(long l) throws IOException {
needBuffer(FitsIO.BYTES_IN_LONG);
this.sharedBuffer.buffer[this.sharedBuffer.bufferOffset++] = (byte) (l >>> FitsIO.BITS_OF_7_BYTES);
this.sharedBuffer.buffer[this.sharedBuffer.bufferOffset++] = (byte) (l >>> FitsIO.BITS_OF_6_BYTES);
this.sharedBuffer.buffer[this.sharedBuffer.bufferOffset++] = (byte) (l >>> FitsIO.BITS_OF_5_BYTES);
this.sharedBuffer.buffer[this.sharedBuffer.bufferOffset++] = (byte) (l >>> FitsIO.BITS_OF_4_BYTES);
this.sharedBuffer.buffer[this.sharedBuffer.bufferOffset++] = (byte) (l >>> FitsIO.BITS_OF_3_BYTES);
this.sharedBuffer.buffer[this.sharedBuffer.bufferOffset++] = (byte) (l >>> FitsIO.BITS_OF_2_BYTES);
this.sharedBuffer.buffer[this.sharedBuffer.bufferOffset++] = (byte) (l >>> FitsIO.BITS_OF_1_BYTE);
this.sharedBuffer.buffer[this.sharedBuffer.bufferOffset++] = (byte) l;
}
protected void writeShort(int s) throws IOException {
needBuffer(FitsIO.BYTES_IN_SHORT);
this.sharedBuffer.buffer[this.sharedBuffer.bufferOffset++] = (byte) (s >>> FitsIO.BITS_OF_1_BYTE);
this.sharedBuffer.buffer[this.sharedBuffer.bufferOffset++] = (byte) s;
}
}
nom/tam/util/DataTable.java 0000664 0000000 0000000 00000003431 12755570700 014602 0 ustar root root package nom.tam.util;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
/**
* This interface defines the properties that a generic table should have.
*/
public interface DataTable {
Object getColumn(int column);
Object getElement(int row, int col);
int getNCols();
int getNRows();
Object getRow(int row);
void setColumn(int column, Object newColumn) throws TableException;
void setElement(int row, int col, Object newElement) throws TableException;
void setRow(int row, Object newRow) throws TableException;
}
nom/tam/util/BufferedFile.java 0000664 0000000 0000000 00000062203 12755570700 015305 0 ustar root root package nom.tam.util;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
/**
* This class is intended for high performance I/O in scientific applications.
* It adds buffering to the RandomAccessFile and also
* provides efficient handling of arrays. Primitive arrays
* may be written using a single method call. Large buffers
* are used to minimize synchronization overheads since methods
* of this class are not synchronized.
*
* Note that although this class supports most of the contract of
* RandomAccessFile it does not (and can not) extend that class since many of
* the methods of RandomAccessFile are final. In practice this method works much
* like the StreamFilter classes. All methods are implemented in this class but
* some are simply delegated to an underlying RandomAccessFile member.
*
* Testing and timing routines are available in the
* nom.tam.util.test.BufferedFileTester class.
*
* Version 1.1 October 12, 2000: Fixed handling of EOF in array reads so that a
* partial array will be returned when an EOF is detected. Excess bytes that
* cannot be used to construct array elements will be discarded (e.g., if there
* are 2 bytes left and the user is reading an int array). BOOLEAN = new BooleanType();
public static final PrimitiveType BYTE = new ByteType();
public static final PrimitiveType CHAR = new CharType();
public static final PrimitiveType DOUBLE = new DoubleType();
public static final PrimitiveType FLOAT = new FloatType();
public static final PrimitiveType INT = new IntType();
public static final PrimitiveType LONG = new LongType();
public static final PrimitiveType SHORT = new ShortType();
public static final PrimitiveType STRING = new StringType();
public static final PrimitiveType UNKNOWN = new UnknownType();
private PrimitiveTypes() {
// TODO Auto-generated constructor stub
}
}
nom/tam/util/type/DoubleType.java 0000664 0000000 0000000 00000005430 12755570700 016017 0 ustar root root package nom.tam.util.type;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.nio.ByteBuffer;
import java.nio.DoubleBuffer;
class DoubleType extends PrimitiveTypeBase {
private static final int BIT_PIX = -64;
private static final int SIZE = 8;
protected DoubleType() {
super(SIZE, false, double.class, Double.class, DoubleBuffer.class, 'D', BIT_PIX);
}
@Override
public void appendBuffer(DoubleBuffer buffer, DoubleBuffer dataToAppend) {
double[] temp = new double[Math.min(COPY_BLOCK_SIZE, dataToAppend.remaining())];
while (dataToAppend.hasRemaining()) {
int nrObBytes = Math.min(temp.length, dataToAppend.remaining());
dataToAppend.get(temp, 0, nrObBytes);
buffer.put(temp, 0, nrObBytes);
}
}
@Override
public DoubleBuffer asTypedBuffer(ByteBuffer buffer) {
return buffer.asDoubleBuffer();
}
@Override
public void getArray(DoubleBuffer buffer, Object array, int offset, int length) {
buffer.get((double[]) array, offset, length);
}
@Override
public Object newArray(int length) {
return new double[length];
}
@Override
public void putArray(DoubleBuffer buffer, Object array, int length) {
buffer.put((double[]) array, 0, length);
}
@Override
public DoubleBuffer sliceBuffer(DoubleBuffer buffer) {
return buffer.slice();
}
@Override
public DoubleBuffer wrap(Object array) {
return DoubleBuffer.wrap((double[]) array);
}
}
nom/tam/util/type/PrimitiveTypeBase.java 0000664 0000000 0000000 00000013244 12755570700 017352 0 ustar root root package nom.tam.util.type;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.lang.reflect.Array;
import java.nio.Buffer;
import java.nio.ByteBuffer;
abstract class PrimitiveTypeBase implements PrimitiveType {
public static final int COPY_BLOCK_SIZE = 1024;
private final int bitPix;
private final Class bufferClass;
private final boolean individualSize;
private final Class primitiveClass;
private final int size;
private final char type;
private final Class wrapperClass;
protected PrimitiveTypeBase(int size, boolean individualSize, Class primitiveClass, Class wrapperClass, Class bufferClass, char type, int bitPix) {
this.size = size;
this.individualSize = individualSize;
this.primitiveClass = primitiveClass;
this.wrapperClass = wrapperClass;
this.bufferClass = bufferClass;
this.type = type;
this.bitPix = bitPix;
}
@Override
public void appendBuffer(B buffer, B dataToAppend) {
throw new UnsupportedOperationException("no primitive type");
}
@Override
public void appendToByteBuffer(ByteBuffer byteBuffer, B dataToAppend) {
byte[] temp = new byte[Math.min(COPY_BLOCK_SIZE * this.size, dataToAppend.remaining() * this.size)];
B typedBuffer = asTypedBuffer(ByteBuffer.wrap(temp));
Object array = newArray(Math.min(COPY_BLOCK_SIZE, dataToAppend.remaining()));
while (dataToAppend.hasRemaining()) {
int part = Math.min(COPY_BLOCK_SIZE, dataToAppend.remaining());
getArray(dataToAppend, array, part);
putArray(typedBuffer, array, part);
byteBuffer.put(temp, 0, part * this.size);
}
}
@Override
public B asTypedBuffer(ByteBuffer buffer) {
throw new UnsupportedOperationException("no primitive buffer available");
}
@Override
public int bitPix() {
return this.bitPix;
}
@Override
public Class bufferClass() {
return this.bufferClass;
}
@Override
public ByteBuffer convertToByteBuffer(Object array) {
ByteBuffer buffer = ByteBuffer.wrap(new byte[Array.getLength(array) * this.size]);
putArray(asTypedBuffer(buffer), array);
buffer.rewind();
return buffer;
}
@Override
public final void getArray(B buffer, Object array) {
getArray(buffer, array, Array.getLength(array));
}
@Override
public final void getArray(B buffer, Object array, int length) {
getArray(buffer, array, 0, length);
}
@Override
public void getArray(B buffer, Object array, int offset, int length) {
throw new UnsupportedOperationException("no primitive type");
}
@Override
public boolean individualSize() {
return this.individualSize;
}
@Override
public boolean is(PrimitiveType other) {
return this.bitPix == other.bitPix();
}
@Override
public Object newArray(int length) {
return null;
}
@Override
public final B newBuffer(int length) {
return wrap(newArray(length));
}
@Override
public final B newBuffer(long length) {
// TODO handle big arrays differently by using memory mapped files.
return wrap(newArray((int) length));
}
@Override
public Class primitiveClass() {
return this.primitiveClass;
}
@Override
public final void putArray(B buffer, Object array) {
putArray(buffer, array, Array.getLength(array));
}
@Override
public void putArray(B buffer, Object array, int length) {
throw new UnsupportedOperationException("no primitive type");
}
@Override
public int size() {
return this.size;
}
/**
* currently the only individual size primitive so, keep it simple
*
* @param instance
* the object to calculate the size
* @return the size in bytes of the object instance
*/
@Override
public int size(Object instance) {
if (instance == null) {
return 0;
}
return this.size;
}
@Override
public B sliceBuffer(B buffer) {
return null;
}
@Override
public char type() {
return this.type;
}
@Override
public B wrap(Object array) {
return null;
}
@Override
public Class wrapperClass() {
return this.wrapperClass;
}
}
nom/tam/util/type/ShortType.java 0000664 0000000 0000000 00000005325 12755570700 015707 0 ustar root root package nom.tam.util.type;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.nio.ByteBuffer;
import java.nio.ShortBuffer;
class ShortType extends PrimitiveTypeBase {
private static final int BIT_PIX = 16;
protected ShortType() {
super(2, false, short.class, Short.class, ShortBuffer.class, 'S', BIT_PIX);
}
@Override
public void appendBuffer(ShortBuffer buffer, ShortBuffer dataToAppend) {
short[] temp = new short[Math.min(COPY_BLOCK_SIZE, dataToAppend.remaining())];
while (dataToAppend.hasRemaining()) {
int nrObBytes = Math.min(temp.length, dataToAppend.remaining());
dataToAppend.get(temp, 0, nrObBytes);
buffer.put(temp, 0, nrObBytes);
}
}
@Override
public ShortBuffer asTypedBuffer(ByteBuffer buffer) {
return buffer.asShortBuffer();
}
@Override
public void getArray(ShortBuffer buffer, Object array, int offset, int length) {
buffer.get((short[]) array, offset, length);
}
@Override
public Object newArray(int length) {
return new short[length];
}
@Override
public void putArray(ShortBuffer buffer, Object array, int length) {
buffer.put((short[]) array, 0, length);
}
@Override
public ShortBuffer sliceBuffer(ShortBuffer buffer) {
return buffer.slice();
}
@Override
public ShortBuffer wrap(Object array) {
return ShortBuffer.wrap((short[]) array);
}
}
nom/tam/util/type/LongType.java 0000664 0000000 0000000 00000005351 12755570700 015506 0 ustar root root package nom.tam.util.type;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.nio.ByteBuffer;
import java.nio.LongBuffer;
class LongType extends PrimitiveTypeBase {
private static final int BIT_PIX = 64;
private static final int SIZE = 8;
protected LongType() {
super(SIZE, false, long.class, Long.class, LongBuffer.class, 'J', BIT_PIX);
}
@Override
public void appendBuffer(LongBuffer buffer, LongBuffer dataToAppend) {
long[] temp = new long[Math.min(COPY_BLOCK_SIZE, dataToAppend.remaining())];
while (dataToAppend.hasRemaining()) {
int nrObBytes = Math.min(temp.length, dataToAppend.remaining());
dataToAppend.get(temp, 0, nrObBytes);
buffer.put(temp, 0, nrObBytes);
}
}
@Override
public LongBuffer asTypedBuffer(ByteBuffer buffer) {
return buffer.asLongBuffer();
}
@Override
public void getArray(LongBuffer buffer, Object array, int offset, int length) {
buffer.get((long[]) array, offset, length);
}
@Override
public Object newArray(int length) {
return new long[length];
}
@Override
public void putArray(LongBuffer buffer, Object array, int length) {
buffer.put((long[]) array, 0, length);
}
@Override
public LongBuffer sliceBuffer(LongBuffer buffer) {
return buffer.slice();
}
@Override
public LongBuffer wrap(Object array) {
return LongBuffer.wrap((long[]) array);
}
}
nom/tam/util/type/FloatType.java 0000664 0000000 0000000 00000005401 12755570700 015650 0 ustar root root package nom.tam.util.type;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.nio.ByteBuffer;
import java.nio.FloatBuffer;
class FloatType extends PrimitiveTypeBase {
private static final int BIT_PIX = -32;
private static final int SIZE = 4;
protected FloatType() {
super(SIZE, false, float.class, Float.class, FloatBuffer.class, 'F', BIT_PIX);
}
@Override
public void appendBuffer(FloatBuffer buffer, FloatBuffer dataToAppend) {
float[] temp = new float[Math.min(COPY_BLOCK_SIZE, dataToAppend.remaining())];
while (dataToAppend.hasRemaining()) {
int nrObBytes = Math.min(temp.length, dataToAppend.remaining());
dataToAppend.get(temp, 0, nrObBytes);
buffer.put(temp, 0, nrObBytes);
}
}
@Override
public FloatBuffer asTypedBuffer(ByteBuffer buffer) {
return buffer.asFloatBuffer();
}
@Override
public void getArray(FloatBuffer buffer, Object array, int offset, int length) {
buffer.get((float[]) array, offset, length);
}
@Override
public Object newArray(int length) {
return new float[length];
}
@Override
public void putArray(FloatBuffer buffer, Object array, int length) {
buffer.put((float[]) array, 0, length);
}
@Override
public FloatBuffer sliceBuffer(FloatBuffer buffer) {
return buffer.slice();
}
@Override
public FloatBuffer wrap(Object array) {
return FloatBuffer.wrap((float[]) array);
}
}
nom/tam/util/type/PrimitiveTypeHandler.java 0000664 0000000 0000000 00000007543 12755570700 020062 0 ustar root root package nom.tam.util.type;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.nio.Buffer;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
public final class PrimitiveTypeHandler {
private static final int MAX_TYPE_VALUE = 256;
private static final int BIT_PIX_OFFSET = 64;
private static PrimitiveType[] byBitPix;
private static PrimitiveType[] byType;
private static Map, PrimitiveType> byClass;
@SuppressWarnings("unchecked")
private static PrimitiveType cast(PrimitiveType primitiveType) {
return (PrimitiveType) primitiveType;
}
static {
byBitPix = new PrimitiveType[BIT_PIX_OFFSET * 2 + 1];
byType = new PrimitiveType[MAX_TYPE_VALUE];
Map, PrimitiveType> initialByClass = new HashMap, PrimitiveType>();
for (PrimitiveType type : values()) {
if (type.bitPix() != 0) {
byBitPix[type.bitPix() + BIT_PIX_OFFSET] = type;
}
byType[type.type()] = type;
initialByClass.put(type.primitiveClass(), type);
initialByClass.put(type.wrapperClass(), type);
if (type.bufferClass() != null) {
initialByClass.put(type.bufferClass(), type);
}
}
byClass = Collections.unmodifiableMap(initialByClass);
}
public static PrimitiveType valueOf(Class clazz) {
PrimitiveType primitiveType = byClass.get(clazz);
if (primitiveType == null) {
for (Class interf : clazz.getInterfaces()) {
primitiveType = byClass.get(interf);
if (primitiveType != null) {
return cast(primitiveType);
}
}
return valueOf(clazz.getSuperclass());
}
return cast(primitiveType);
}
private static PrimitiveType[] values() {
return new PrimitiveType[]{
PrimitiveTypes.BOOLEAN,
PrimitiveTypes.BYTE,
PrimitiveTypes.CHAR,
PrimitiveTypes.DOUBLE,
PrimitiveTypes.FLOAT,
PrimitiveTypes.INT,
PrimitiveTypes.LONG,
PrimitiveTypes.SHORT,
PrimitiveTypes.STRING,
PrimitiveTypes.UNKNOWN
};
}
private PrimitiveTypeHandler() {
}
public static PrimitiveType valueOf(int bitPix) {
return cast(byBitPix[bitPix + BIT_PIX_OFFSET]);
}
public static PrimitiveType valueOf(char type) {
return cast(byType[type]);
}
}
nom/tam/util/type/StringType.java 0000664 0000000 0000000 00000003251 12755570700 016052 0 ustar root root package nom.tam.util.type;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.nio.Buffer;
class StringType extends PrimitiveTypeBase {
protected StringType() {
super(0, true, CharSequence.class, String.class, null, 'L', 0);
}
@Override
public int size(Object instance) {
if (instance == null) {
return 0;
}
return ((CharSequence) instance).length();
}
}
nom/tam/util/type/ByteType.java 0000664 0000000 0000000 00000005222 12755570700 015507 0 ustar root root package nom.tam.util.type;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.nio.ByteBuffer;
class ByteType extends PrimitiveTypeBase {
private static final int BIT_PIX = 8;
protected ByteType() {
super(1, false, byte.class, Byte.class, ByteBuffer.class, 'B', BIT_PIX);
}
@Override
public void appendBuffer(ByteBuffer buffer, ByteBuffer dataToAppend) {
byte[] temp = new byte[Math.min(COPY_BLOCK_SIZE, dataToAppend.remaining())];
while (dataToAppend.hasRemaining()) {
int nrObBytes = Math.min(temp.length, dataToAppend.remaining());
dataToAppend.get(temp, 0, nrObBytes);
buffer.put(temp, 0, nrObBytes);
}
}
@Override
public ByteBuffer asTypedBuffer(ByteBuffer buffer) {
return buffer;
}
@Override
public void getArray(ByteBuffer buffer, Object array, int offset, int length) {
buffer.get((byte[]) array, offset, length);
}
@Override
public Object newArray(int length) {
return new byte[length];
}
@Override
public void putArray(ByteBuffer buffer, Object array, int length) {
buffer.put((byte[]) array, 0, length);
}
@Override
public ByteBuffer sliceBuffer(ByteBuffer buffer) {
return buffer.slice();
}
@Override
public ByteBuffer wrap(Object array) {
return ByteBuffer.wrap((byte[]) array);
}
}
nom/tam/util/type/BooleanType.java 0000664 0000000 0000000 00000002771 12755570700 016171 0 ustar root root package nom.tam.util.type;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.nio.Buffer;
class BooleanType extends PrimitiveTypeBase {
protected BooleanType() {
super(1, false, boolean.class, Boolean.class, null, 'Z', 0);
}
}
nom/tam/util/type/UnknownType.java 0000664 0000000 0000000 00000003104 12755570700 016240 0 ustar root root package nom.tam.util.type;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.nio.Buffer;
class UnknownType extends PrimitiveTypeBase {
protected UnknownType() {
super(0, true, Object.class, Object.class, null, 'L', 0);
}
@Override
public int size(Object instance) {
return 0;
}
}
nom/tam/util/type/CharType.java 0000664 0000000 0000000 00000003006 12755570700 015457 0 ustar root root package nom.tam.util.type;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.nio.CharBuffer;
class CharType extends PrimitiveTypeBase {
protected CharType() {
super(2, false, char.class, Character.class, CharBuffer.class, 'C', 0);
}
}
nom/tam/util/type/IntType.java 0000664 0000000 0000000 00000005326 12755570700 015343 0 ustar root root package nom.tam.util.type;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.nio.ByteBuffer;
import java.nio.IntBuffer;
class IntType extends PrimitiveTypeBase {
private static final int BIT_PIX = 32;
private static final int SIZE = 4;
protected IntType() {
super(SIZE, false, int.class, Integer.class, IntBuffer.class, 'I', BIT_PIX);
}
@Override
public void appendBuffer(IntBuffer buffer, IntBuffer dataToAppend) {
int[] temp = new int[Math.min(COPY_BLOCK_SIZE, dataToAppend.remaining())];
while (dataToAppend.hasRemaining()) {
int nrObBytes = Math.min(temp.length, dataToAppend.remaining());
dataToAppend.get(temp, 0, nrObBytes);
buffer.put(temp, 0, nrObBytes);
}
}
@Override
public IntBuffer asTypedBuffer(ByteBuffer buffer) {
return buffer.asIntBuffer();
}
@Override
public void getArray(IntBuffer buffer, Object array, int offset, int length) {
buffer.get((int[]) array, offset, length);
}
@Override
public Object newArray(int length) {
return new int[length];
}
@Override
public void putArray(IntBuffer buffer, Object array, int length) {
buffer.put((int[]) array, 0, length);
}
@Override
public IntBuffer sliceBuffer(IntBuffer buffer) {
return buffer.slice();
}
@Override
public IntBuffer wrap(Object array) {
return IntBuffer.wrap((int[]) array);
}
}
nom/tam/util/type/PrimitiveType.java 0000664 0000000 0000000 00000004455 12755570700 016563 0 ustar root root package nom.tam.util.type;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.nio.Buffer;
import java.nio.ByteBuffer;
public interface PrimitiveType {
void appendBuffer(B buffer, B dataToAppend);
void appendToByteBuffer(ByteBuffer byteBuffer, B dataToAppend);
B asTypedBuffer(ByteBuffer buffer);
int bitPix();
Class bufferClass();
ByteBuffer convertToByteBuffer(Object array);
void getArray(B buffer, Object array);
void getArray(B buffer, Object array, int length);
void getArray(B buffer, Object array, int offset, int length);
boolean individualSize();
boolean is(PrimitiveType d);
Object newArray(int length);
B newBuffer(int length);
B newBuffer(long length);
Class primitiveClass();
void putArray(B buffer, Object array);
void putArray(B buffer, Object array, int length);
int size();
int size(Object instance);
B sliceBuffer(B buffer);
char type();
B wrap(Object array);
Class wrapperClass();
}
nom/tam/util/BufferDecoder.java 0000664 0000000 0000000 00000030014 12755570700 015455 0 ustar root root package nom.tam.util;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.io.EOFException;
import java.io.IOException;
import java.lang.reflect.Array;
import nom.tam.util.type.PrimitiveType;
import nom.tam.util.type.PrimitiveTypeHandler;
import nom.tam.util.type.PrimitiveTypes;
public abstract class BufferDecoder {
private class PrimitiveArrayRecurse {
/**
* Counter used in reading arrays
*/
private long primitiveArrayCount;
protected long primitiveArrayRecurse(Object o) throws IOException {
if (o == null) {
return this.primitiveArrayCount;
}
if (!o.getClass().isArray()) {
throw new IOException("Invalid object passed to BufferedDataInputStream.readArray:" + o.getClass().getName());
}
int length = Array.getLength(o);
// Is this a multidimensional array? If so process recursively.
if (o.getClass().getComponentType().isArray()) {
for (int i = 0; i < length; i++) {
primitiveArrayRecurse(Array.get(o, i));
}
} else {
// This is a one-d array. Process it using our special
// functions.
PrimitiveType type = PrimitiveTypeHandler.valueOf(o.getClass().getComponentType());
if (type == PrimitiveTypes.BOOLEAN) {
this.primitiveArrayCount += read((boolean[]) o, 0, length);
} else if (type == PrimitiveTypes.BYTE) {
int len = read((byte[]) o, 0, length);
this.primitiveArrayCount += len;
if (len < length) {
throw new EOFException();
}
} else if (type == PrimitiveTypes.CHAR) {
this.primitiveArrayCount += read((char[]) o, 0, length);
} else if (type == PrimitiveTypes.SHORT) {
this.primitiveArrayCount += read((short[]) o, 0, length);
} else if (type == PrimitiveTypes.INT) {
this.primitiveArrayCount += read((int[]) o, 0, length);
} else if (type == PrimitiveTypes.LONG) {
this.primitiveArrayCount += read((long[]) o, 0, length);
} else if (type == PrimitiveTypes.FLOAT) {
this.primitiveArrayCount += read((float[]) o, 0, length);
} else if (type == PrimitiveTypes.DOUBLE) {
this.primitiveArrayCount += read((double[]) o, 0, length);
} else if (type == PrimitiveTypes.STRING || type == PrimitiveTypes.UNKNOWN) {
for (int i = 0; i < length; i++) {
primitiveArrayRecurse(Array.get(o, i));
}
}
}
return this.primitiveArrayCount;
}
}
private final BufferPointer sharedBuffer;
public BufferDecoder(BufferPointer sharedBuffer) {
this.sharedBuffer = sharedBuffer;
}
/**
* This should only be used when a small number of bytes is required
* (substantially smaller than bufferSize.
*
* @param needBytes
* the number of bytes needed for the next operation.
* @throws IOException
* if the buffer could not be filled
*/
protected abstract void checkBuffer(int needBytes) throws IOException;
protected abstract int eofCheck(EOFException e, int start, int index, int length) throws EOFException;
protected int read(boolean[] b, int start, int length) throws IOException {
int i = start;
try {
for (; i < start + length; i++) {
b[i] = readBoolean();
}
return length;
} catch (EOFException e) {
return eofCheck(e, start, i, 1);
}
}
protected int read(byte[] buf, int offset, int len) throws IOException {
checkBuffer(-1);
int total = 0;
// Ensure that the entire dataBuffer.buffer is read.
while (len > 0) {
if (this.sharedBuffer.bufferOffset < this.sharedBuffer.bufferLength) {
int get = len;
if (this.sharedBuffer.bufferOffset + get > this.sharedBuffer.bufferLength) {
get = this.sharedBuffer.bufferLength - this.sharedBuffer.bufferOffset;
}
System.arraycopy(this.sharedBuffer.buffer, this.sharedBuffer.bufferOffset, buf, offset, get);
len -= get;
this.sharedBuffer.bufferOffset += get;
offset += get;
total += get;
continue;
} else {
// This might be pretty long, but we know that the
// old dataBuffer.buffer is exhausted.
try {
if (len > this.sharedBuffer.buffer.length) {
checkBuffer(this.sharedBuffer.buffer.length);
} else {
checkBuffer(len);
}
} catch (EOFException e) {
if (this.sharedBuffer.bufferLength > 0) {
System.arraycopy(this.sharedBuffer.buffer, 0, buf, offset, this.sharedBuffer.bufferLength);
total += this.sharedBuffer.bufferLength;
this.sharedBuffer.bufferLength = 0;
}
if (total == 0) {
throw e;
} else {
return total;
}
}
}
}
return total;
}
protected int read(char[] c, int start, int length) throws IOException {
int i = start;
try {
for (; i < start + length; i++) {
c[i] = readChar();
}
return length * FitsIO.BYTES_IN_CHAR;
} catch (EOFException e) {
return eofCheck(e, start, i, FitsIO.BYTES_IN_CHAR);
}
}
protected int read(double[] d, int start, int length) throws IOException {
int i = start;
try {
for (; i < start + length; i++) {
d[i] = Double.longBitsToDouble(readLong());
}
return length * FitsIO.BYTES_IN_DOUBLE;
} catch (EOFException e) {
return eofCheck(e, start, i, FitsIO.BYTES_IN_DOUBLE);
}
}
protected int read(float[] f, int start, int length) throws IOException {
int i = start;
try {
for (; i < start + length; i++) {
f[i] = Float.intBitsToFloat(readInt());
}
return length * FitsIO.BYTES_IN_FLOAT;
} catch (EOFException e) {
return eofCheck(e, start, i, FitsIO.BYTES_IN_FLOAT);
}
}
protected int read(int[] i, int start, int length) throws IOException {
int ii = start;
try {
for (; ii < start + length; ii++) {
i[ii] = readInt();
}
return length * FitsIO.BYTES_IN_INTEGER;
} catch (EOFException e) {
return eofCheck(e, start, ii, FitsIO.BYTES_IN_INTEGER);
}
}
protected int read(long[] l, int start, int length) throws IOException {
int i = start;
try {
for (; i < start + length; i++) {
l[i] = readLong();
}
return length * FitsIO.BYTES_IN_LONG;
} catch (EOFException e) {
return eofCheck(e, start, i, FitsIO.BYTES_IN_LONG);
}
}
protected int read(short[] s, int start, int length) throws IOException {
int i = start;
try {
for (; i < start + length; i++) {
s[i] = readShort();
}
return length * FitsIO.BYTES_IN_SHORT;
} catch (EOFException e) {
return eofCheck(e, start, i, FitsIO.BYTES_IN_SHORT);
}
}
/**
* @return a boolean from the buffer
* @throws IOException
* if the underlying operation fails
*/
protected boolean readBoolean() throws IOException {
checkBuffer(FitsIO.BYTES_IN_BOOLEAN);
return this.sharedBuffer.buffer[this.sharedBuffer.bufferOffset++] == 1;
}
/**
* @return a char from the buffer
* @throws IOException
* if the underlying operation fails
*/
protected char readChar() throws IOException {
checkBuffer(FitsIO.BYTES_IN_CHAR);
return (char) readUncheckedShort();
}
/**
* @return an integer value from the buffer
* @throws IOException
* if the underlying operation fails
*/
protected int readInt() throws IOException {
checkBuffer(FitsIO.BYTES_IN_INTEGER);
return readUncheckedInt();
}
protected long readLArray(Object o) throws IOException {
return new PrimitiveArrayRecurse().primitiveArrayRecurse(o);
}
/**
* @return a long value from the buffer
* @throws IOException
* if the underlying operation fails
*/
protected long readLong() throws IOException {
checkBuffer(FitsIO.BYTES_IN_LONG);
int i1 = readUncheckedInt();
int i2 = readUncheckedInt();
return (long) i1 << FitsIO.BITS_OF_4_BYTES | i2 & FitsIO.INTEGER_MASK;
}
protected double readDouble() throws IOException {
return Double.longBitsToDouble(readLong());
}
protected float readFloat() throws IOException {
return Float.intBitsToFloat(readInt());
}
protected void readFully(byte[] b, int off, int len) throws IOException {
if (off < 0 || len < 0 || off + len > b.length) {
throw new IOException("Attempt to read outside byte array");
}
if (read(b, off, len) < len) {
throw new EOFException();
}
}
/**
* @return a short from the buffer
* @throws IOException
* if the underlying operation fails
*/
protected short readShort() throws IOException {
checkBuffer(FitsIO.BYTES_IN_SHORT);
return (short) readUncheckedShort();
}
private int readUncheckedInt() {
return this.sharedBuffer.buffer[this.sharedBuffer.bufferOffset++] << FitsIO.BITS_OF_3_BYTES | //
(this.sharedBuffer.buffer[this.sharedBuffer.bufferOffset++] & FitsIO.BYTE_MASK) << FitsIO.BITS_OF_2_BYTES | //
(this.sharedBuffer.buffer[this.sharedBuffer.bufferOffset++] & FitsIO.BYTE_MASK) << FitsIO.BITS_OF_1_BYTE | //
this.sharedBuffer.buffer[this.sharedBuffer.bufferOffset++] & FitsIO.BYTE_MASK;
}
private int readUncheckedShort() {
return this.sharedBuffer.buffer[this.sharedBuffer.bufferOffset++] << FitsIO.BITS_OF_1_BYTE | //
this.sharedBuffer.buffer[this.sharedBuffer.bufferOffset++] & FitsIO.BYTE_MASK;
}
}
nom/tam/util/CursorValue.java 0000664 0000000 0000000 00000002556 12755570700 015242 0 ustar root root package nom.tam.util;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
public interface CursorValue {
T getKey();
}
nom/tam/util/ArrayFuncs.java 0000664 0000000 0000000 00000045060 12755570700 015042 0 ustar root root package nom.tam.util;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.logging.Level;
import java.util.logging.Logger;
import nom.tam.util.array.MultiArrayCopier;
import nom.tam.util.array.MultiArrayIterator;
import nom.tam.util.type.PrimitiveType;
import nom.tam.util.type.PrimitiveTypeHandler;
/**
* This is a package of static functions which perform computations on arrays.
* Generally these routines attempt to complete without throwing errors by
* ignoring data they cannot understand.
*/
public final class ArrayFuncs {
private static final Logger LOG = Logger.getLogger(ArrayFuncs.class.getName());
private ArrayFuncs() {
}
/**
* @return a description of an array (presumed rectangular).
* @param o
* The array to be described.
*/
public static String arrayDescription(Object o) {
Class base = getBaseClass(o);
if (base == Void.TYPE) {
return "NULL";
}
return new StringBuffer(base.getSimpleName())//
.append(Arrays.toString(getDimensions(o)))//
.toString();
}
public static long computeLSize(Object o) {
if (o == null) {
return 0;
}
if (o.getClass().isArray()) {
long size = 0;
MultiArrayIterator iter = new MultiArrayIterator(o);
Object array;
while ((array = iter.next()) != null) {
long length = Array.getLength(array);
if (length > 0) {
Class componentType = array.getClass().getComponentType();
PrimitiveType primType = PrimitiveTypeHandler.valueOf(componentType);
if (componentType.isPrimitive()) {
size += length * primType.size();
} else {
for (int index = 0; index < length; index++) {
size += primType.size(Array.get(array, index));
}
}
}
}
return size;
} else {
PrimitiveType primType = PrimitiveTypeHandler.valueOf(o.getClass());
if (primType.individualSize()) {
return primType.size(o);
} else {
return primType.size();
}
}
}
/**
* @return Compute the size of an object. Note that this only handles arrays
* or scalars of the primitive objects and Strings. It returns 0 for
* any object array element it does not understand.
* @param o
* The object whose size is desired.
* @deprecated May silently underestimate the size if the size > 2 GB.
*/
@Deprecated
public static int computeSize(Object o) {
return (int) computeLSize(o);
}
/**
* @return Convert an array to a specified type. This method supports
* conversions only among the primitive numeric types.
* @param array
* A possibly multidimensional array to be converted.
* @param newType
* The desired output type. This should be one of the class
* descriptors for primitive numeric data, e.g., double.type.
*/
public static Object convertArray(Object array, Class newType) {
/*
* We break this up into two steps so that users can reuse an array many
* times and only allocate a new array when needed.
*/
/* First create the full new array. */
Object mimic = mimicArray(array, newType);
/* Now copy the info into the new array */
copyInto(array, mimic);
return mimic;
}
/**
* @return Convert an array to a specified type. This method supports
* conversions only among the primitive numeric types.
* @param array
* A possibly multidimensional array to be converted.
* @param newType
* The desired output type. This should be one of the class
* descriptors for primitive numeric data, e.g., double.type.
* @param reuse
* If set, and the requested type is the same as the original,
* then the original is returned.
*/
public static Object convertArray(Object array, Class newType, boolean reuse) {
if (getBaseClass(array) == newType && reuse) {
return array;
} else {
return convertArray(array, newType);
}
}
/**
* Copy one array into another. This function copies the contents of one
* array into a previously allocated array. The arrays must agree in type
* and size.
*
* @param original
* The array to be copied.
* @param copy
* The array to be copied into. This array must already be fully
* allocated.
*/
public static void copyArray(Object original, Object copy) {
Class originalClass = original.getClass();
if (!originalClass.isArray()) {
return;
}
int length = Array.getLength(original);
if (originalClass.getComponentType().isArray()) {
if (length != Array.getLength(copy)) {
return;
}
for (int index = 0; index < length; index++) {
copyArray(Array.get(original, index), Array.get(copy, index));
}
}
System.arraycopy(original, 0, copy, 0, length);
}
/**
* Copy an array into an array of a different type. The dimensions and
* dimensionalities of the two arrays should be the same.
*
* @param array
* The original array.
* @param mimic
* The array mimicking the original.
*/
public static void copyInto(Object array, Object mimic) {
MultiArrayCopier.copyInto(array, mimic);
}
/**
* Curl an input array up into a multi-dimensional array.
*
* @param input
* The one dimensional array to be curled.
* @param dimens
* The desired dimensions
* @return The curled array.
*/
public static Object curl(Object input, int[] dimens) {
if (input == null) {
return null;
}
if (!input.getClass().isArray() || input.getClass().getComponentType().isArray()) {
throw new RuntimeException("Attempt to curl non-1D array");
}
int size = Array.getLength(input);
int test = 1;
for (int dimen : dimens) {
test *= dimen;
}
if (test != size) {
throw new RuntimeException("Curled array does not fit desired dimensions");
}
Object newArray = ArrayFuncs.newInstance(getBaseClass(input), dimens);
MultiArrayCopier.copyInto(input, newArray);
return newArray;
}
/**
* @return a deep clone of an Array or a standard clone of a scalar. The
* object may comprise arrays of any primitive type or any Object
* type which implements Cloneable. However, if the Object is some
* kind of collection, e.g., a Vector then only a shallow copy of
* that object is made. I.e., deep refers only to arrays.
* @param o
* The object to be copied.
*/
public static Object deepClone(Object o) {
if (o == null) {
return null;
}
if (!o.getClass().isArray()) {
return genericClone(o);
}
// Check if this is a 1D primitive array.
if (o.getClass().getComponentType().isPrimitive()) {
int length = Array.getLength(o);
Object result = Array.newInstance(o.getClass().getComponentType(), length);
System.arraycopy(o, 0, result, 0, length);
return result;
} else {
// Get the base type.
Class baseClass = getBaseClass(o);
// Allocate the array but make all but the first dimension 0.
int[] dims = getDimensions(o);
Arrays.fill(dims, 1, dims.length, 0);
Object copy = ArrayFuncs.newInstance(baseClass, dims);
// Now fill in the next level down by recursion.
for (int i = 0; i < dims[0]; i++) {
Array.set(copy, i, deepClone(Array.get(o, i)));
}
return copy;
}
}
/**
* Given an array of arbitrary dimensionality .
*
* @return the array flattened into a single dimension.
* @param input
* The input array.
*/
public static Object flatten(Object input) {
int[] dimens = getDimensions(input);
if (dimens.length <= 1) {
return input;
}
int size = 1;
for (int dimen : dimens) {
size *= dimen;
}
Object flat = ArrayFuncs.newInstance(getBaseClass(input), size);
MultiArrayCopier.copyInto(input, flat);
return flat;
}
/**
* Clone an Object if possible. This method returns an Object which is a
* clone of the input object. It checks if the method implements the
* Cloneable interface and then uses reflection to invoke the clone method.
* This can't be done directly since as far as the compiler is concerned the
* clone method for Object is protected and someone could implement
* Cloneable but leave the clone method protected. The cloning can fail in a
* variety of ways which are trapped so that it returns null instead. This
* method will generally create a shallow clone. If you wish a deep copy of
* an array the method deepClone should be used.
*
* @param o
* The object to be cloned.
* @return the clone
*/
public static Object genericClone(Object o) {
if (o.getClass().isArray()) {
return deepClone(o);
}
if (!(o instanceof Cloneable)) {
LOG.log(Level.SEVERE, "generic clone called on a non clonable type");
return null;
}
try {
return o.getClass().getMethod("clone").invoke(o);
} catch (Exception e) {
LOG.log(Level.WARNING, "Implements cloneable, but does not apparently make clone public.", e);
return null;
}
}
/**
* This routine returns the base array of a multi-dimensional array. I.e., a
* one-d array of whatever the array is composed of. Note that arrays are
* not guaranteed to be rectangular, so this returns o[0][0]....
*
* @param o
* the multi-dimensional array
* @return base array of a multi-dimensional array.
*/
public static Object getBaseArray(Object o) {
if (o.getClass().getComponentType().isArray()) {
return getBaseArray(Array.get(o, 0));
} else {
return o;
}
}
/**
* This routine returns the base class of an object. This is just the class
* of the object for non-arrays.
*
* @param o
* array to get the base class from
* @return the base class of an array
*/
public static Class getBaseClass(Object o) {
if (o == null) {
return Void.TYPE;
}
Class clazz = o.getClass();
while (clazz.isArray()) {
clazz = clazz.getComponentType();
}
return clazz;
}
/**
* This routine returns the size of the base element of an array.
*
* @param o
* The array object whose base length is desired.
* @return the size of the object in bytes, 0 if null, or -1 if not a
* primitive array.
*/
public static int getBaseLength(Object o) {
if (o == null) {
return 0;
}
PrimitiveType type = PrimitiveTypeHandler.valueOf(getBaseClass(o));
if (type != null && type.size() != 0) {
return type.size();
}
return -1;
}
/**
* Find the dimensions of an object. This method returns an integer array
* with the dimensions of the object o which should usually be an array. It
* returns an array of dimension 0 for scalar objects and it returns -1 for
* dimension which have not been allocated, e.g., int[][][] x = new
* int[100][][]; should return [100,-1,-1].
*
* @param o
* The object to get the dimensions of.
* @return the dimensions of an object
*/
public static int[] getDimensions(Object o) {
if (o == null) {
return null;
}
Object object = o;
Class clazz = o.getClass();
int ndim = 0;
while (clazz.isArray()) {
clazz = clazz.getComponentType();
ndim++;
}
clazz = o.getClass();
int[] dimens = new int[ndim];
ndim = 0;
while (clazz.isArray()) {
dimens[ndim] = -1;
if (object != null) {
int length = Array.getLength(object);
if (length > 0) {
dimens[ndim] = length;
object = Array.get(object, 0);
} else {
dimens[ndim] = 0;
object = null;
}
}
clazz = clazz.getComponentType();
ndim++;
}
return dimens;
}
/**
* Create an array of a type given by new type with the dimensionality given
* in array.
*
* @return the new array with same dimensions
* @param array
* A possibly multidimensional array to be converted.
* @param newType
* The desired output type. This should be one of the class
* descriptors for primitive numeric data, e.g., double.type.
*/
public static Object mimicArray(Object array, Class newType) {
int dims = 0;
Class arrayClass = array.getClass();
while (arrayClass != null && arrayClass.isArray()) {
arrayClass = arrayClass.getComponentType();
dims += 1;
}
Object mimic;
if (dims > 1) {
Object[] xarray = (Object[]) array;
int[] dimens = new int[dims];
dimens[0] = xarray.length; // Leave other dimensions at 0.
mimic = ArrayFuncs.newInstance(newType, dimens);
for (int i = 0; i < xarray.length; i += 1) {
Object temp = mimicArray(xarray[i], newType);
((Object[]) mimic)[i] = temp;
}
} else {
mimic = ArrayFuncs.newInstance(newType, Array.getLength(array));
}
return mimic;
}
/**
* @return Count the number of elements in an array.
* @param o
* the array to count the elements
* @deprecated May silently underestimate size if number is > 2 G.
*/
@Deprecated
public static int nElements(Object o) {
return (int) nLElements(o);
}
/**
* Allocate an array dynamically. The Array.newInstance method does not
* throw an error when there is insufficient memory and silently returns a
* null.throws an OutOfMemoryError if insufficient space is available.
*
* @param cl
* The class of the array.
* @param dim
* The dimension of the array.
* @return The allocated array.
*/
public static Object newInstance(Class cl, int dim) {
return Array.newInstance(cl, dim);
}
/**
* Allocate an array dynamically. The Array.newInstance method does not
* throw an error and silently returns a null.throws an OutOfMemoryError if
* insufficient space is available.
*
* @param cl
* The class of the array.
* @param dims
* The dimensions of the array.
* @return The allocated array.
*/
public static Object newInstance(Class cl, int[] dims) {
if (dims.length == 0) {
// Treat a scalar as a 1-d array of length 1
dims = new int[]{
1
};
}
return Array.newInstance(cl, dims);
}
/**
* @return Count the number of elements in an array.
* @param o
* the array to count elements in
* @deprecated May silently underestimate size if number is > 2 G.
*/
@Deprecated
public static long nLElements(Object o) {
if (o == null) {
return 0;
}
String classname = o.getClass().getName();
if (classname.charAt(1) == '[') {
int count = 0;
for (int i = 0; i < ((Object[]) o).length; i += 1) {
count += nLElements(((Object[]) o)[i]);
}
return count;
} else if (classname.charAt(0) == '[') {
return Array.getLength(o);
} else {
return 1;
}
}
/**
* Reverse an integer array. This can be especially useful when dealing with
* an array of indices in FITS order that you wish to have in Java order.
*
* @return the reversed array.
* @param indices
* the array to reverse
*/
public static int[] reverseIndices(int[] indices) {
int[] result = new int[indices.length];
int len = indices.length;
for (int i = 0; i < indices.length; i += 1) {
result[len - i - 1] = indices[i];
}
return result;
}
}
nom/tam/util/Cursor.java 0000664 0000000 0000000 00000006467 12755570700 014252 0 ustar root root package nom.tam.util;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
/**
* This interface extends the Iterator interface to allow insertion of data and
* move to previous entries in a collection.
*/
public interface Cursor extends java.util.Iterator {
/**
* Add a keyed entry at the current location. The new entry is inserted
* before the entry that would be returned in the next invocation of 'next'.
* The new element is placed such that it will be called by a prev() call,
* but not a next() call.The return value for that call is unaffected. Note:
* this method is not in the Iterator interface.
*
* @param key
* the key of the value to add
* @param reference
* the value to add
* @deprecated use key parameter can be omitted, so use {@link #add(Object)}
* instead
*/
@Deprecated
void add(KEY key, VALUE reference);
/**
* Add an unkeyed element to the collection. The new element is placed such
* that it will be called by a prev() call, but not a next() call.
*
* @param reference
* the value to add
*/
void add(VALUE reference);
/**
* move to the last element and return that.
*
* @return the last element.
*/
VALUE end();
/**
* @return Is there a previous element in the collection?
*/
boolean hasPrev();
/**
* Returns the count next element in the iteration.
*
* @param count
* the offset
* @return the n'th next element in the iteration
* @throws java.util.NoSuchElementException
* if the iteration has no more elements
*/
VALUE next(int count);
/**
* @return the previous element.
*/
VALUE prev();
/**
* Point the iterator to a particular keyed entry. Point to the end of the
* list if the key is not found.This method is not in the Iterator
* interface.
*
* @param key
* the key to search for
*/
void setKey(KEY key);
}
nom/tam/util/ByteBufferOutputStream.java 0000664 0000000 0000000 00000003461 12755570700 017416 0 ustar root root package nom.tam.util;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.io.IOException;
import java.io.OutputStream;
import java.nio.ByteBuffer;
public class ByteBufferOutputStream extends OutputStream {
private final ByteBuffer buffer;
public ByteBufferOutputStream(ByteBuffer buffer) {
this.buffer = buffer;
}
@Override
public void write(int b) throws IOException {
buffer.put((byte) b);
}
@Override
public void write(byte[] b, int off, int len) throws IOException {
buffer.put(b, off, len);
}
}
nom/tam/util/RandomAccess.java 0000664 0000000 0000000 00000003762 12755570700 015332 0 ustar root root package nom.tam.util;
import java.io.IOException;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
/**
* These packages define the methods which indicate that an i/o stream may be
* accessed in arbitrary order. The method signatures are taken from
* RandomAccessFile though that class does not implement this interface.
*/
public interface RandomAccess extends ArrayDataInput {
/**
* @return the current position in the stream.
*/
long getFilePointer();
/**
* Move to a specified location in the stream.
*
* @param offsetFromStart
* set the offset messured from the start
* @throws IOException
* if the operation fails
*/
void seek(long offsetFromStart) throws IOException;
}
nom/tam/util/LoggerHelper.java 0000664 0000000 0000000 00000003420 12755570700 015336 0 ustar root root package nom.tam.util;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2016 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.util.logging.Logger;
/**
* Utility class offering simplifying methods related to {@code Logger}.
*/
public final class LoggerHelper {
private LoggerHelper() {
// Not needed
}
/**
* @param aClass
* the class to get the logger for.
* @return a Java {@code Logger} for the specified class.
*/
public static Logger getLogger(Class aClass) {
return Logger.getLogger(aClass.getName());
}
}
nom/tam/util/BufferPointer.java 0000664 0000000 0000000 00000004223 12755570700 015533 0 ustar root root package nom.tam.util;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
public class BufferPointer {
/**
* The data buffer.
*/
protected byte[] buffer;
/**
* The number of valid characters in the buffer
*/
protected int bufferLength;
/**
* The current offset into the buffer
*/
protected int bufferOffset;
public BufferPointer() {
}
@SuppressFBWarnings(value = "EI_EXPOSE_REP", justification = "intended exposure of mutable data")
public BufferPointer(byte[] buffer) {
this.buffer = buffer;
}
protected BufferPointer init(int bufferSize) {
this.buffer = new byte[bufferSize];
this.bufferOffset = 0;
this.bufferLength = 0;
return this;
}
protected void invalidate() {
this.bufferLength = 0;
this.bufferOffset = 0;
}
}
nom/tam/util/array/ 0000775 0000000 0000000 00000000000 12755570710 013234 5 ustar root root nom/tam/util/array/MultiArrayIterator.java 0000664 0000000 0000000 00000005636 12755570700 017713 0 ustar root root package nom.tam.util.array;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.lang.reflect.Array;
public class MultiArrayIterator {
private final Object baseArray;
private final boolean baseIsNoSubArray;
private boolean baseNextCalled = false;
private final MultiArrayPointer pointer;
public MultiArrayIterator(Object baseArray) {
this.baseArray = baseArray;
this.baseIsNoSubArray = !MultiArrayPointer.isSubArray(this.baseArray);
this.pointer = new MultiArrayPointer(this.baseArray);
}
public Class deepComponentType() {
Class clazz = this.baseArray.getClass();
while (clazz.isArray()) {
clazz = clazz.getComponentType();
}
return clazz;
}
public Object next() {
if (this.baseIsNoSubArray) {
if (this.baseNextCalled) {
return null;
} else {
this.baseNextCalled = true;
return this.baseArray;
}
} else {
Object result = null;
while (result == null || Array.getLength(result) == 0) {
result = this.pointer.next();
if (result == MultiArrayPointer.END) {
return null;
}
}
return result;
}
}
public void reset() {
if (this.baseIsNoSubArray) {
this.baseNextCalled = false;
} else {
this.pointer.reset();
}
}
public int size() {
int size = 0;
Object next;
while ((next = next()) != null) {
size += Array.getLength(next);
}
return size;
}
}
nom/tam/util/array/MultiArrayCopyFactory.java 0000664 0000000 0000000 00000057423 12755570700 020365 0 ustar root root package nom.tam.util.array;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
public class MultiArrayCopyFactory {
private static class ByteToChar extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
byte[] src = (byte[]) srcO;
char[] dest = (char[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = (char) src[index + srcPos];
}
}
}
private static class ByteToDouble extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
byte[] src = (byte[]) srcO;
double[] dest = (double[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = src[index + srcPos];
}
}
}
private static class ByteToFloat extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
byte[] src = (byte[]) srcO;
float[] dest = (float[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = src[index + srcPos];
}
}
}
private static class ByteToInt extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
byte[] src = (byte[]) srcO;
int[] dest = (int[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = src[index + srcPos];
}
}
}
private static class ByteToLong extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
byte[] src = (byte[]) srcO;
long[] dest = (long[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = src[index + srcPos];
}
}
}
private static class ByteToShort extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
byte[] src = (byte[]) srcO;
short[] dest = (short[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = src[index + srcPos];
}
}
}
private static class CharToByte extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
char[] src = (char[]) srcO;
byte[] dest = (byte[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = (byte) src[index + srcPos];
}
}
}
private static class CharToDouble extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
char[] src = (char[]) srcO;
double[] dest = (double[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = src[index + srcPos];
}
}
}
private static class CharToFloat extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
char[] src = (char[]) srcO;
float[] dest = (float[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = src[index + srcPos];
}
}
}
private static class CharToInt extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
char[] src = (char[]) srcO;
int[] dest = (int[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = src[index + srcPos];
}
}
}
private static class CharToLong extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
char[] src = (char[]) srcO;
long[] dest = (long[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = src[index + srcPos];
}
}
}
private static class CharToShort extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
char[] src = (char[]) srcO;
short[] dest = (short[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = (short) src[index + srcPos];
}
}
}
private static class DoubleToByte extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
double[] src = (double[]) srcO;
byte[] dest = (byte[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = (byte) src[index + srcPos];
}
}
}
private static class DoubleToChar extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
double[] src = (double[]) srcO;
char[] dest = (char[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = (char) src[index + srcPos];
}
}
}
private static class DoubleToFloat extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
double[] src = (double[]) srcO;
float[] dest = (float[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = (float) src[index + srcPos];
}
}
}
private static class DoubleToInt extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
double[] src = (double[]) srcO;
int[] dest = (int[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = (int) src[index + srcPos];
}
}
}
private static class DoubleToLong extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
double[] src = (double[]) srcO;
long[] dest = (long[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = (long) src[index + srcPos];
}
}
}
private static class DoubleToShort extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
double[] src = (double[]) srcO;
short[] dest = (short[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = (short) src[index + srcPos];
}
}
}
private static class FloatToByte extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
float[] src = (float[]) srcO;
byte[] dest = (byte[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = (byte) src[index + srcPos];
}
}
}
private static class FloatToChar extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
float[] src = (float[]) srcO;
char[] dest = (char[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = (char) src[index + srcPos];
}
}
}
private static class FloatToDouble extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
float[] src = (float[]) srcO;
double[] dest = (double[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = src[index + srcPos];
}
}
}
private static class FloatToInt extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
float[] src = (float[]) srcO;
int[] dest = (int[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = (int) src[index + srcPos];
}
}
}
private static class FloatToLong extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
float[] src = (float[]) srcO;
long[] dest = (long[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = (long) src[index + srcPos];
}
}
}
private static class FloatToShort extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
float[] src = (float[]) srcO;
short[] dest = (short[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = (short) src[index + srcPos];
}
}
}
private static class Generic extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
System.arraycopy(srcO, srcPos, destO, destPos, length);
}
}
private static class IntToByte extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
int[] src = (int[]) srcO;
byte[] dest = (byte[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = (byte) src[index + srcPos];
}
}
}
private static class IntToChar extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
int[] src = (int[]) srcO;
char[] dest = (char[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = (char) src[index + srcPos];
}
}
}
private static class IntToDouble extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
int[] src = (int[]) srcO;
double[] dest = (double[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = src[index + srcPos];
}
}
}
private static class IntToFloat extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
int[] src = (int[]) srcO;
float[] dest = (float[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = src[index + srcPos];
}
}
}
private static class IntToLong extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
int[] src = (int[]) srcO;
long[] dest = (long[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = src[index + srcPos];
}
}
}
private static class IntToShort extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
int[] src = (int[]) srcO;
short[] dest = (short[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = (short) src[index + srcPos];
}
}
}
private static class LongToByte extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
long[] src = (long[]) srcO;
byte[] dest = (byte[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = (byte) src[index + srcPos];
}
}
}
private static class LongToChar extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
long[] src = (long[]) srcO;
char[] dest = (char[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = (char) src[index + srcPos];
}
}
}
private static class LongToDouble extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
long[] src = (long[]) srcO;
double[] dest = (double[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = src[index + srcPos];
}
}
}
private static class LongToFloat extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
long[] src = (long[]) srcO;
float[] dest = (float[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = src[index + srcPos];
}
}
}
private static class LongToInt extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
long[] src = (long[]) srcO;
int[] dest = (int[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = (int) src[index + srcPos];
}
}
}
private static class LongToShort extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
long[] src = (long[]) srcO;
short[] dest = (short[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = (short) src[index + srcPos];
}
}
}
private static class ShortToByte extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
short[] src = (short[]) srcO;
byte[] dest = (byte[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = (byte) src[index + srcPos];
}
}
}
private static class ShortToChar extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
short[] src = (short[]) srcO;
char[] dest = (char[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = (char) src[index + srcPos];
}
}
}
private static class ShortToDouble extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
short[] src = (short[]) srcO;
double[] dest = (double[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = src[index + srcPos];
}
}
}
private static class ShortToFloat extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
short[] src = (short[]) srcO;
float[] dest = (float[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = src[index + srcPos];
}
}
}
private static class ShortToInt extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
short[] src = (short[]) srcO;
int[] dest = (int[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = src[index + srcPos];
}
}
}
private static class ShortToLong extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
short[] src = (short[]) srcO;
long[] dest = (long[]) destO;
for (int index = 0; index < length; index++) {
dest[index + destPos] = src[index + srcPos];
}
}
}
private static final Map, Map, MultiArrayCopyFactory>> FACTORIES;
private static final MultiArrayCopyFactory GENERIC = new Generic();
static {
Map, Map, MultiArrayCopyFactory>> factories = new HashMap, Map, MultiArrayCopyFactory>>();
Map, MultiArrayCopyFactory> byteMap = new HashMap, MultiArrayCopyFactory>();
byteMap.put(byte.class, new MultiArrayCopyFactory());
byteMap.put(char.class, new ByteToChar());
byteMap.put(short.class, new ByteToShort());
byteMap.put(int.class, new ByteToInt());
byteMap.put(long.class, new ByteToLong());
byteMap.put(float.class, new ByteToFloat());
byteMap.put(double.class, new ByteToDouble());
factories.put(byte.class, Collections.unmodifiableMap(byteMap));
Map, MultiArrayCopyFactory> charMap = new HashMap, MultiArrayCopyFactory>();
charMap.put(byte.class, new CharToByte());
charMap.put(char.class, new MultiArrayCopyFactory());
charMap.put(short.class, new CharToShort());
charMap.put(int.class, new CharToInt());
charMap.put(long.class, new CharToLong());
charMap.put(float.class, new CharToFloat());
charMap.put(double.class, new CharToDouble());
factories.put(char.class, Collections.unmodifiableMap(charMap));
Map, MultiArrayCopyFactory> shortMap = new HashMap, MultiArrayCopyFactory>();
shortMap.put(byte.class, new ShortToByte());
shortMap.put(char.class, new ShortToChar());
shortMap.put(short.class, new MultiArrayCopyFactory());
shortMap.put(int.class, new ShortToInt());
shortMap.put(long.class, new ShortToLong());
shortMap.put(float.class, new ShortToFloat());
shortMap.put(double.class, new ShortToDouble());
factories.put(short.class, Collections.unmodifiableMap(shortMap));
Map, MultiArrayCopyFactory> intMap = new HashMap, MultiArrayCopyFactory>();
intMap.put(byte.class, new IntToByte());
intMap.put(char.class, new IntToChar());
intMap.put(short.class, new IntToShort());
intMap.put(int.class, new MultiArrayCopyFactory());
intMap.put(long.class, new IntToLong());
intMap.put(float.class, new IntToFloat());
intMap.put(double.class, new IntToDouble());
factories.put(int.class, Collections.unmodifiableMap(intMap));
Map, MultiArrayCopyFactory> longMap = new HashMap, MultiArrayCopyFactory>();
longMap.put(byte.class, new LongToByte());
longMap.put(char.class, new LongToChar());
longMap.put(short.class, new LongToShort());
longMap.put(int.class, new LongToInt());
longMap.put(long.class, new MultiArrayCopyFactory());
longMap.put(float.class, new LongToFloat());
longMap.put(double.class, new LongToDouble());
factories.put(long.class, Collections.unmodifiableMap(longMap));
Map, MultiArrayCopyFactory> floatMap = new HashMap, MultiArrayCopyFactory>();
floatMap.put(byte.class, new FloatToByte());
floatMap.put(char.class, new FloatToChar());
floatMap.put(short.class, new FloatToShort());
floatMap.put(int.class, new FloatToInt());
floatMap.put(long.class, new FloatToLong());
floatMap.put(float.class, new MultiArrayCopyFactory());
floatMap.put(double.class, new FloatToDouble());
factories.put(float.class, Collections.unmodifiableMap(floatMap));
Map, MultiArrayCopyFactory> doubleMap = new HashMap, MultiArrayCopyFactory>();
doubleMap.put(byte.class, new DoubleToByte());
doubleMap.put(char.class, new DoubleToChar());
doubleMap.put(short.class, new DoubleToShort());
doubleMap.put(int.class, new DoubleToInt());
doubleMap.put(long.class, new DoubleToLong());
doubleMap.put(float.class, new DoubleToFloat());
doubleMap.put(double.class, new MultiArrayCopyFactory());
factories.put(double.class, Collections.unmodifiableMap(doubleMap));
FACTORIES = Collections.unmodifiableMap(factories);
}
public static MultiArrayCopyFactory select(Class primitiveType, Class primitiveType2) {
Map, MultiArrayCopyFactory> from = MultiArrayCopyFactory.FACTORIES.get(primitiveType);
if (from != null) {
MultiArrayCopyFactory to = from.get(primitiveType2);
if (to != null) {
return to;
}
}
return MultiArrayCopyFactory.GENERIC;
}
public void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) {
System.arraycopy(src, srcPos, dest, destPos, length);
}
}
nom/tam/util/array/MultiArrayPointer.java 0000664 0000000 0000000 00000007113 12755570700 017532 0 ustar root root package nom.tam.util.array;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.lang.reflect.Array;
public class MultiArrayPointer {
public static final Object END = new Object();
public static boolean isSubArray(Object element) {
Class elementClazz = element.getClass();
boolean isArray = elementClazz.isArray();
if (isArray && Object.class.equals(elementClazz.getComponentType())) {
// ok object array lets check it the elements are arrays.
int length = Array.getLength(element);
for (int index = 0; index < length; index++) {
Object subElement = Array.get(element, index);
if (subElement != null) {
return subElement.getClass().isArray();
}
}
return false;
}
return isArray && elementClazz.getComponentType().isArray();
}
private Object array;
private int index;
private int length;
private MultiArrayPointer sub;
private MultiArrayPointer backup;
public MultiArrayPointer() {
}
public MultiArrayPointer(Object baseArray) {
set(baseArray);
}
private void activateSub(Object element) {
if (this.backup == null) {
this.backup = new MultiArrayPointer();
}
this.sub = this.backup;
this.sub.set(element);
}
private void deactivateSub() {
this.sub = null;
}
public Object next() {
while (true) {
if (this.sub != null) {
Object subNext = this.sub.next();
if (subNext != MultiArrayPointer.END) {
return subNext;
}
deactivateSub();
}
if (this.index >= this.length) {
return MultiArrayPointer.END;
}
Object element = Array.get(this.array, this.index++);
if (element != null && isSubArray(element)) {
activateSub(element);
} else {
return element;
}
}
}
public void reset() {
this.index = 0;
deactivateSub();
}
private void set(Object newArray) {
this.array = newArray;
this.length = Array.getLength(this.array);
this.sub = null;
this.index = 0;
}
}
nom/tam/util/array/MultiArrayCopier.java 0000664 0000000 0000000 00000006223 12755570700 017334 0 ustar root root package nom.tam.util.array;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.lang.reflect.Array;
public final class MultiArrayCopier {
public static void copyInto(Object fromArray, Object toArray) {
new MultiArrayCopier(fromArray, toArray).copyInto();
}
private final MultiArrayIterator from;
private final MultiArrayIterator to;
private Object currentToArray;
private int currentToArrayOffset;
private int currentToArrayLength;
private final MultiArrayCopyFactory copyFactory;
private MultiArrayCopier(Object fromArray, Object toArray) {
this.from = new MultiArrayIterator(fromArray);
this.to = new MultiArrayIterator(toArray);
this.copyFactory = MultiArrayCopyFactory.select(this.from.deepComponentType(), this.to.deepComponentType());
}
private void copyInto() {
Object current = this.from.next();
while (current != null) {
copyInto(current);
current = this.from.next();
}
}
private void copyInto(Object currentFromArray) {
int currentFromArrayOffset = 0;
int currentFromArrayLength = Array.getLength(currentFromArray);
while (currentFromArrayOffset < currentFromArrayLength) {
if (this.currentToArray == null || this.currentToArrayOffset >= this.currentToArrayLength) {
this.currentToArray = this.to.next();
this.currentToArrayOffset = 0;
this.currentToArrayLength = Array.getLength(this.currentToArray);
}
int length = Math.min(this.currentToArrayLength - this.currentToArrayOffset, currentFromArrayLength - currentFromArrayOffset);
this.copyFactory.arraycopy(currentFromArray, currentFromArrayOffset, this.currentToArray, this.currentToArrayOffset, length);
currentFromArrayOffset += length;
this.currentToArrayOffset += length;
}
}
}
nom/tam/util/FormatException.java 0000664 0000000 0000000 00000003035 12755570700 016070 0 ustar root root package nom.tam.util;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
public class FormatException extends java.lang.Exception {
/**
* serial version id.
*/
private static final long serialVersionUID = 1L;
protected FormatException(String msg) {
super(msg);
}
}
nom/tam/util/AsciiFuncs.java 0000664 0000000 0000000 00000005724 12755570700 015017 0 ustar root root /*
* This class provides conversions to ASCII strings without breaking
* compatibility with Java 1.5.
*/
package nom.tam.util;
import java.nio.charset.Charset;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
/**
* @author tmcglynn
*/
public final class AsciiFuncs {
private static final Charset US_ASCII = Charset.forName("US-ASCII");
/**
* utility class not to be instantiated.
*/
private AsciiFuncs() {
}
/**
* Convert to ASCII or return null if not compatible.
*
* @return the String represented by the bytes
* @param buf
* the bytes representing a string
*/
public static String asciiString(byte[] buf) {
return asciiString(buf, 0, buf.length);
}
/**
* Convert to ASCII or return null if not compatible.
*
* @param buf
* buffer to get the string bytes from
* @param start
* the position where the string starts
* @param len
* the length of the string
* @return the extracted string
*/
public static String asciiString(byte[] buf, int start, int len) {
return new String(buf, start, len, US_ASCII);
}
/**
* Convert an ASCII string to bytes.
*
* @return the string converted to bytes
* @param in
* the string to convert
*/
public static byte[] getBytes(String in) {
return in.getBytes(US_ASCII);
}
/**
* @param character
* the charater to check
* @return true is the character is a whitespace.
*/
public static boolean isWhitespace(char character) {
return character == ' ' || character == '\t' || character == '\n' || character == '\r';
}
}
nom/tam/fits/ 0000775 0000000 0000000 00000000000 12755570710 012106 5 ustar root root nom/tam/fits/TableData.java 0000664 0000000 0000000 00000007574 12755570700 014606 0 ustar root root package nom.tam.fits;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
/**
* This class allows FITS binary and ASCII tables to be accessed via a common
* interface.
*/
public interface TableData {
/**
* Add a column to the table without any associated header information.
* Users should be cautious of calling this routine directly rather than the
* corresponding routine in AsciiTableHDU since this routine knows nothing
* of the FITS header modifications required.
*
* @param newCol
* the new column information. the newCol should be an Object[]
* where type of all of the constituents is identical. The length
* of data should match the other columns. Note: It is
* valid for data to be a 2 or higher dimensionality primitive
* array. In this case the column index is the first (in Java
* speak) index of the array. E.g., if called with
* int[30][20][10], the number of rows in the table should be 30
* and this column will have elements which are 2-d integer
* arrays with TDIM = (10,20).
* @return the number of columns in the adapted table
* @throws FitsException
* if the operation failed
*/
int addColumn(Object newCol) throws FitsException;
/**
* Add a row at the end of the table. Given the way the table is structured
* this will normally not be very efficient.Users should be cautious of
* calling this routine directly rather than the corresponding routine in
* AsciiTableHDU since this routine knows nothing of the FITS header
* modifications required.
*
* @param newRow
* An array of elements to be added. Each element of o should be
* an array of primitives or a String.
* @throws FitsException
* if the operation failed
* @return the number of rows in the adapted table
*/
int addRow(Object[] newRow) throws FitsException;
void deleteColumns(int row, int len) throws FitsException;
void deleteRows(int row, int len) throws FitsException;
Object getColumn(int col) throws FitsException;
Object getElement(int row, int col) throws FitsException;
int getNCols();
int getNRows();
Object[] getRow(int row) throws FitsException;
void setColumn(int col, Object newCol) throws FitsException;
void setElement(int row, int col, Object element) throws FitsException;
void setRow(int row, Object[] newRow) throws FitsException;
void updateAfterDelete(int oldNcol, Header hdr) throws FitsException;
}
nom/tam/fits/FitsUtil.java 0000664 0000000 0000000 00000027027 12755570700 014523 0 ustar root root package nom.tam.fits;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.io.Closeable;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.ProtocolException;
import java.net.URL;
import java.net.URLConnection;
import java.util.Arrays;
import java.util.logging.Level;
import java.util.logging.Logger;
import nom.tam.util.ArrayDataOutput;
import nom.tam.util.AsciiFuncs;
import nom.tam.util.RandomAccess;
/**
* This class comprises static utility functions used throughout the FITS
* classes.
*/
public final class FitsUtil {
private static final int BYTE_REPRESENTING_BLANK = 32;
private static final int BYTE_REPRESENTING_MAX_ASCII_VALUE = 126;
/**
* the logger to log to.
*/
private static final Logger LOG = Logger.getLogger(FitsUtil.class.getName());
private static boolean wroteCheckingError = false;
/**
* Utility class, do not instantiate it.
*/
private FitsUtil() {
}
/**
* @return Total size of blocked FITS element, using e.v. padding to fits
* block size.
* @param size
* the current size.
*/
public static int addPadding(int size) {
return size + padding(size);
}
/**
* @return Total size of blocked FITS element, using e.v. padding to fits
* block size.
* @param size
* the current size.
*/
public static long addPadding(long size) {
return size + padding(size);
}
/**
* @return Convert an array of booleans to bytes.
* @param bool
* array of booleans
*/
static byte[] booleanToByte(boolean[] bool) {
byte[] byt = new byte[bool.length];
for (int i = 0; i < bool.length; i += 1) {
byt[i] = bool[i] ? (byte) 'T' : (byte) 'F';
}
return byt;
}
/**
* @return Convert bytes to Strings.
* @param bytes
* byte array to convert
* @param maxLen
* the max string length
*/
public static String[] byteArrayToStrings(byte[] bytes, int maxLen) {
boolean checking = FitsFactory.getCheckAsciiStrings();
// Note that if a String in a binary table contains an internal 0,
// the FITS standard says that it is to be considered as terminating
// the string at that point, so that software reading the
// data back may not include subsequent characters.
// No warning of this truncation is given.
String[] res = new String[bytes.length / maxLen];
for (int i = 0; i < res.length; i += 1) {
int start = i * maxLen;
int end = start + maxLen;
// Pre-trim the string to avoid keeping memory
// hanging around. (Suggested by J.C. Segovia, ESA).
// Note that the FITS standard does not mandate
// that we should be trimming the string at all, but
// this seems to best meet the desires of the community.
for (; start < end; start += 1) {
if (bytes[start] != BYTE_REPRESENTING_BLANK) {
break; // Skip only spaces.
}
}
for (; end > start; end -= 1) {
if (bytes[end - 1] != BYTE_REPRESENTING_BLANK) {
break;
}
}
// For FITS binary tables, 0 values are supposed
// to terminate strings, a la C. [They shouldn't appear in
// any other context.]
// Other non-printing ASCII characters
// should always be an error which we can check for
// if the user requests.
// The lack of handling of null bytes was noted by Laurent Bourges.
boolean errFound = false;
for (int j = start; j < end; j += 1) {
if (bytes[j] == 0) {
end = j;
break;
}
if (checking && (bytes[j] < BYTE_REPRESENTING_BLANK || bytes[j] > BYTE_REPRESENTING_MAX_ASCII_VALUE)) {
errFound = true;
bytes[j] = BYTE_REPRESENTING_BLANK;
}
}
res[i] = AsciiFuncs.asciiString(bytes, start, end - start);
if (errFound && !FitsUtil.wroteCheckingError) {
LOG.log(Level.SEVERE, "Warning: Invalid ASCII character[s] detected in string: " + res[i]
+ " Converted to space[s]. Any subsequent invalid characters will be converted silently");
FitsUtil.wroteCheckingError = true;
}
}
return res;
}
/**
* @return Convert an array of bytes to booleans.
* @param bytes
* the array of bytes to get the booleans from.
*/
static boolean[] byteToBoolean(byte[] bytes) {
boolean[] bool = new boolean[bytes.length];
for (int i = 0; i < bytes.length; i += 1) {
bool[i] = bytes[i] == 'T';
}
return bool;
}
/**
* @return Find out where we are in a random access file .
* @param o
* the stream to get the position
*/
public static long findOffset(Closeable o) {
if (o instanceof RandomAccess) {
return ((RandomAccess) o).getFilePointer();
} else {
return -1;
}
}
/**
* @return Get a stream to a URL accommodating possible redirections. Note
* that if a redirection request points to a different protocol than
* the original request, then the redirection is not handled
* automatically.
* @param url
* the url to get the stream from
* @param level
* max levels of redirection
* @throws IOException
* if the operation failed
*/
public static InputStream getURLStream(URL url, int level) throws IOException {
URLConnection conn = null;
int code = -1;
try {
conn = url.openConnection();
if (conn instanceof HttpURLConnection) {
code = ((HttpURLConnection) conn).getResponseCode();
}
return conn.getInputStream();
} catch (ProtocolException e) {
LOG.log(Level.WARNING, "could not connect to " + url + (code >= 0 ? " got responce-code" + code : ""), e);
throw e;
}
}
/**
* @return Get the maximum length of a String in a String array.
* @param strings
* array of strings to check
* @throws FitsException
* if the operation failed
*/
public static int maxLength(String[] strings) throws FitsException {
int max = 0;
for (String element : strings) {
if (element != null && element.length() > max) {
max = element.length();
}
}
return max;
}
/**
* Add padding to an output stream.
*
* @param stream
* stream to pad
* @param size
* the current size
* @throws FitsException
* if the operation failed
*/
public static void pad(ArrayDataOutput stream, long size) throws FitsException {
pad(stream, size, (byte) 0);
}
/**
* Add padding to an output stream.
*
* @param stream
* stream to pad
* @param size
* the current size
* @param fill
* the fill byte to use
* @throws FitsException
* if the operation failed
*/
public static void pad(ArrayDataOutput stream, long size, byte fill) throws FitsException {
int len = padding(size);
if (len > 0) {
byte[] buf = new byte[len];
Arrays.fill(buf, fill);
try {
stream.write(buf);
stream.flush();
} catch (Exception e) {
throw new FitsException("Unable to write padding", e);
}
}
}
/**
* @return How many bytes are needed to fill a 2880 block?
* @param size
* the size without padding
*/
public static int padding(int size) {
return padding((long) size);
}
public static int padding(long size) {
int mod = (int) (size % FitsFactory.FITS_BLOCK_SIZE);
if (mod > 0) {
mod = FitsFactory.FITS_BLOCK_SIZE - mod;
}
return mod;
}
/**
* Reposition a random access stream to a requested offset.
*
* @param o
* the closable to reposition
* @param offset
* the offset to position it to.
* @throws FitsException
* if the operation was failed or not possible
*/
public static void reposition(Closeable o, long offset) throws FitsException {
if (o == null) {
throw new FitsException("Attempt to reposition null stream");
} else if (!(o instanceof RandomAccess) || offset < 0) {
throw new FitsException("Invalid attempt to reposition stream " + o + " of type " + o.getClass().getName() + " to " + offset);
}
try {
((RandomAccess) o).seek(offset);
} catch (IOException e) {
throw new FitsException("Unable to repostion stream " + o + " of type " + o.getClass().getName() + " to " + offset + " Exception:" + e.getMessage(), e);
}
}
/**
* Convert an array of Strings to bytes.
*
* @return the resulting bytes
* @param stringArray
* the array with Strings
* @param maxLen
* the max length (in bytes) of every String
*/
public static byte[] stringsToByteArray(String[] stringArray, int maxLen) {
byte[] res = new byte[stringArray.length * maxLen];
for (int i = 0; i < stringArray.length; i += 1) {
byte[] bstr;
if (stringArray[i] == null) {
bstr = new byte[0];
} else {
bstr = AsciiFuncs.getBytes(stringArray[i]);
}
int cnt = bstr.length;
if (cnt > maxLen) {
cnt = maxLen;
}
System.arraycopy(bstr, 0, res, i * maxLen, cnt);
for (int j = cnt; j < maxLen; j += 1) {
res[i * maxLen + j] = (byte) ' ';
}
}
return res;
}
}
nom/tam/fits/comments.txt 0000664 0000000 0000000 00000003150 12755570700 014472 0 ustar root root # This file contains comment values for standard keywords.
# The first token on each non-comment line is a keyword that
# identifies the comment of the form class_keyword_n
# where class is the class in which the data is written
# keyword is the key value for the comment being written
# and n is an integer (usually 1) used to distinguish multiple
# entries.
header_simple_1 Null Image Header
header_bitpix_1 BITPIX for null image
header_naxis_1 NAXIS for null image
header_extend_1 Extensions are permitted
header_simple_2 Java FITS: $DATE
header_xtension_1 Java FITS: $DATE
header_bitpix_2
header_naxis_2 Dimensionality
header_naxisN_1
header_end_1
randomgroupsdata_naxis1_1
randomgroupsdata_naxisN_1
randomgroupsdata_groups_1
randomgroupsdata_gcount_1
randomgroupsdata_pcount_1
binarytablehdu_pcount_1
binarytablehdu_theap_1
binarytablehdu_tformN_1
binarytablehdu_tdimN_1
asciitable_pcount_1 No group data
asciitable_gcount_1 One group
asciitable_tfields_1 Number of fields in table
asciitable_tbcolN_1 Column Offset
asciitable_naxis1_1 Size of row in bytes
asciitablehdu_tnullN_1
asciitablehdu_tfields_1
binarytable_pcount_1
binarytable_gcount_1
binarytable_naxis1_1 Bytes per row
binarytable_tfields
basichdu_extend_1 Allow extensions
basichdu_pcount_1 Required value
basichdu_gcount_1 Required value
imagedata_extend_1 Extension permitted
imagedata_pcount_1 No extra parameters
imagedata_gcount_1 One group
tablehdu_naxis2_1
tablehdu_tfields_1 Number of table fields
undefineddata_naxis1_1 Number of bytes in unknown structure
undefineddata_pcount_1
undefineddata_gcount_1
undefineddata_extend_1 Extensions are permitted nom/tam/fits/FitsDate.java 0000664 0000000 0000000 00000025157 12755570700 014465 0 ustar root root package nom.tam.fits;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.text.DecimalFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.TimeZone;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
/**
* Fits date object parsed from the different type of date combinations
*/
public class FitsDate {
/**
* logger to log to.
*/
private static final Logger LOG = Logger.getLogger(FitsDate.class.getName());
private static final int FIRST_THREE_CHARACTER_VALUE = 100;
private static final int FIRST_TWO_CHARACTER_VALUE = 10;
private static final int FITS_DATE_STRING_SIZE = 23;
private static final TimeZone GMT = TimeZone.getTimeZone("GMT");
private static final int NEW_FORMAT_DAY_OF_MONTH_GROUP = 4;
private static final int NEW_FORMAT_HOUR_GROUP = 6;
private static final int NEW_FORMAT_MILLISECOND_GROUP = 10;
private static final int NEW_FORMAT_MINUTE_GROUP = 7;
private static final int NEW_FORMAT_MONTH_GROUP = 3;
private static final int NEW_FORMAT_SECOND_GROUP = 8;
private static final int NEW_FORMAT_YEAR_GROUP = 2;
private static final Pattern NORMAL_REGEX = Pattern
.compile("\\s*(([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9]))(T([0-9][0-9]):([0-9][0-9]):([0-9][0-9])(\\.([0-9][0-9][0-9]|[0-9][0-9]))?)?\\s*");
private static final int OLD_FORMAT_DAY_OF_MONTH_GROUP = 1;
private static final int OLD_FORMAT_MONTH_GROUP = 2;
private static final int OLD_FORMAT_YEAR_GROUP = 3;
private static final Pattern OLD_REGEX = Pattern.compile("\\s*([0-9][0-9])/([0-9][0-9])/([0-9][0-9])\\s*");
private static final int TWO_DIGIT_MILISECONDS_FACTOR = 10;
private static final int YEAR_OFFSET = 1900;
/**
* @return the current date in FITS date format
*/
public static String getFitsDateString() {
return getFitsDateString(new Date(), true);
}
/**
* @return a created FITS format date string Java Date object.
* @param epoch
* The epoch to be converted to FITS format.
*/
public static String getFitsDateString(Date epoch) {
return getFitsDateString(epoch, true);
}
/**
* @return a created FITS format date string. Note that the date is not
* rounded.
* @param epoch
* The epoch to be converted to FITS format.
* @param timeOfDay
* Should time of day information be included?
*/
public static String getFitsDateString(Date epoch, boolean timeOfDay) {
Calendar cal = Calendar.getInstance(FitsDate.GMT);
cal.setTime(epoch);
StringBuilder fitsDate = new StringBuilder();
DecimalFormat df = new DecimalFormat("0000");
fitsDate.append(df.format(cal.get(Calendar.YEAR)));
fitsDate.append("-");
df = new DecimalFormat("00");
fitsDate.append(df.format(cal.get(Calendar.MONTH) + 1));
fitsDate.append("-");
fitsDate.append(df.format(cal.get(Calendar.DAY_OF_MONTH)));
if (timeOfDay) {
fitsDate.append("T");
fitsDate.append(df.format(cal.get(Calendar.HOUR_OF_DAY)));
fitsDate.append(":");
fitsDate.append(df.format(cal.get(Calendar.MINUTE)));
fitsDate.append(":");
fitsDate.append(df.format(cal.get(Calendar.SECOND)));
fitsDate.append(".");
df = new DecimalFormat("000");
fitsDate.append(df.format(cal.get(Calendar.MILLISECOND)));
}
return fitsDate.toString();
}
private Date date = null;
private int hour = -1;
private int mday = -1;
private int millisecond = -1;
private int minute = -1;
private int month = -1;
private int second = -1;
private int year = -1;
/**
* Convert a FITS date string to a Java Date object.
*
* @param dStr
* the FITS date
* @throws FitsException
* if dStr does not contain a valid FITS date.
*/
public FitsDate(String dStr) throws FitsException {
// if the date string is null, we are done
if (dStr == null || dStr.isEmpty()) {
return;
}
Matcher match = FitsDate.NORMAL_REGEX.matcher(dStr);
if (match.matches()) {
this.year = getInt(match, FitsDate.NEW_FORMAT_YEAR_GROUP);
this.month = getInt(match, FitsDate.NEW_FORMAT_MONTH_GROUP);
this.mday = getInt(match, FitsDate.NEW_FORMAT_DAY_OF_MONTH_GROUP);
this.hour = getInt(match, FitsDate.NEW_FORMAT_HOUR_GROUP);
this.minute = getInt(match, FitsDate.NEW_FORMAT_MINUTE_GROUP);
this.second = getInt(match, FitsDate.NEW_FORMAT_SECOND_GROUP);
this.millisecond = getMilliseconds(match, FitsDate.NEW_FORMAT_MILLISECOND_GROUP);
} else {
match = FitsDate.OLD_REGEX.matcher(dStr);
if (match.matches()) {
this.year = getInt(match, FitsDate.OLD_FORMAT_YEAR_GROUP) + FitsDate.YEAR_OFFSET;
this.month = getInt(match, FitsDate.OLD_FORMAT_MONTH_GROUP);
this.mday = getInt(match, FitsDate.OLD_FORMAT_DAY_OF_MONTH_GROUP);
} else {
if (dStr.trim().isEmpty()) {
return;
}
throw new FitsException("Bad FITS date string \"" + dStr + '"');
}
}
}
private static int getInt(Matcher match, int groupIndex) {
String value = match.group(groupIndex);
if (value != null) {
return Integer.parseInt(value);
}
return -1;
}
private static int getMilliseconds(Matcher match, int groupIndex) {
String value = match.group(groupIndex);
if (value != null) {
int result = Integer.parseInt(value);
if (value.length() == 2) {
result = result * FitsDate.TWO_DIGIT_MILISECONDS_FACTOR;
}
return result;
}
return -1;
}
/**
* Get a Java Date object corresponding to this FITS date.
*
* @return The Java Date object.
*/
@SuppressFBWarnings(value = "EI_EXPOSE_REP", justification = "intended exposure of mutable data")
public Date toDate() {
if (this.date == null && this.year != -1) {
Calendar cal = Calendar.getInstance(FitsDate.GMT);
cal.set(Calendar.YEAR, this.year);
cal.set(Calendar.MONTH, this.month - 1);
cal.set(Calendar.DAY_OF_MONTH, this.mday);
if (FitsDate.LOG.isLoggable(Level.FINEST)) {
FitsDate.LOG.log(Level.FINEST, "At this point:" + cal.getTime());
}
if (this.hour == -1) {
cal.set(Calendar.HOUR_OF_DAY, 0);
cal.set(Calendar.MINUTE, 0);
cal.set(Calendar.SECOND, 0);
cal.set(Calendar.MILLISECOND, 0);
if (FitsDate.LOG.isLoggable(Level.FINEST)) {
FitsDate.LOG.log(Level.FINEST, "2At this point:" + cal.getTime());
}
} else {
cal.set(Calendar.HOUR_OF_DAY, this.hour);
cal.set(Calendar.MINUTE, this.minute);
cal.set(Calendar.SECOND, this.second);
if (this.millisecond == -1) {
cal.set(Calendar.MILLISECOND, 0);
} else {
cal.set(Calendar.MILLISECOND, this.millisecond);
}
if (FitsDate.LOG.isLoggable(Level.FINEST)) {
FitsDate.LOG.log(Level.FINEST, "3At this point:" + cal.getTime());
}
}
this.date = cal.getTime();
}
if (FitsDate.LOG.isLoggable(Level.FINEST)) {
FitsDate.LOG.log(Level.FINEST, " date:" + this.date);
FitsDate.LOG.log(Level.FINEST, " year:" + this.year);
FitsDate.LOG.log(Level.FINEST, " month:" + this.month);
FitsDate.LOG.log(Level.FINEST, " mday:" + this.mday);
FitsDate.LOG.log(Level.FINEST, " hour:" + this.hour);
}
return this.date;
}
@Override
public String toString() {
if (this.year == -1) {
return "";
}
StringBuilder buf = new StringBuilder(FitsDate.FITS_DATE_STRING_SIZE);
buf.append(this.year);
buf.append('-');
appendTwoDigitValue(buf, this.month);
buf.append('-');
appendTwoDigitValue(buf, mday);
if (this.hour != -1) {
buf.append('T');
appendTwoDigitValue(buf, this.hour);
buf.append(':');
appendTwoDigitValue(buf, this.minute);
buf.append(':');
appendTwoDigitValue(buf, this.second);
if (this.millisecond != -1) {
buf.append('.');
appendThreeDigitValue(buf, this.millisecond);
}
}
return buf.toString();
}
private void appendThreeDigitValue(StringBuilder buf, int value) {
if (value < FitsDate.FIRST_THREE_CHARACTER_VALUE) {
buf.append('0');
}
appendTwoDigitValue(buf, value);
}
private void appendTwoDigitValue(StringBuilder buf, int value) {
if (value < FitsDate.FIRST_TWO_CHARACTER_VALUE) {
buf.append('0');
}
buf.append(value);
}
}
nom/tam/fits/BinaryTableHDU.java 0000664 0000000 0000000 00000025751 12755570700 015517 0 ustar root root package nom.tam.fits;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import static nom.tam.fits.header.Standard.NAXIS1;
import static nom.tam.fits.header.Standard.NAXIS2;
import static nom.tam.fits.header.Standard.PCOUNT;
import static nom.tam.fits.header.Standard.TDIMn;
import static nom.tam.fits.header.Standard.TDISPn;
import static nom.tam.fits.header.Standard.TFIELDS;
import static nom.tam.fits.header.Standard.TFORMn;
import static nom.tam.fits.header.Standard.THEAP;
import static nom.tam.fits.header.Standard.TNULLn;
import static nom.tam.fits.header.Standard.TSCALn;
import static nom.tam.fits.header.Standard.TTYPEn;
import static nom.tam.fits.header.Standard.TUNITn;
import static nom.tam.fits.header.Standard.TZEROn;
import static nom.tam.fits.header.Standard.XTENSION;
import static nom.tam.fits.header.Standard.XTENSION_BINTABLE;
import java.io.PrintStream;
import nom.tam.fits.header.IFitsHeader;
import nom.tam.fits.header.Standard;
import nom.tam.util.ArrayDataOutput;
import nom.tam.util.ArrayFuncs;
/** FITS binary table header/data unit */
public class BinaryTableHDU extends TableHDU {
/** The standard column keywords for a binary table. */
private static final IFitsHeader[] KEY_STEMS = {
TTYPEn,
TFORMn,
TUNITn,
TNULLn,
TSCALn,
TZEROn,
TDISPn,
TDIMn
};
public BinaryTableHDU(Header hdr, BinaryTable datum) {
super(hdr, datum);
}
/**
* @return Encapsulate data in a BinaryTable data type
* @param o
* data to encapsulate
* @throws FitsException
* if the type of the data is not usable as data
*/
public static BinaryTable encapsulate(Object o) throws FitsException {
if (o instanceof nom.tam.util.ColumnTable) {
return new BinaryTable((nom.tam.util.ColumnTable) o);
} else if (o instanceof Object[][]) {
return new BinaryTable((Object[][]) o);
} else if (o instanceof Object[]) {
return new BinaryTable((Object[]) o);
} else {
throw new FitsException("Unable to encapsulate object of type:" + o.getClass().getName() + " as BinaryTable");
}
}
/*
* Check if this data object is consistent with a binary table. There are
* three options: a column table object, an Object[][], or an Object[]. This
* routine doesn't check that the dimensions of arrays are properly
* consistent.
*/
public static boolean isData(Object o) {
return o instanceof nom.tam.util.ColumnTable || o instanceof Object[][] || o instanceof Object[];
}
/**
* Check that this is a valid binary table header.
*
* @param header
* to validate.
* @return true if this is a binary table header.
*/
public static boolean isHeader(Header header) {
String xten = header.getStringValue(XTENSION);
if (xten == null) {
return false;
}
xten = xten.trim();
return xten.equals(XTENSION_BINTABLE) || xten.equals("A3DTABLE");
}
/**
* @return a new created data from a binary table header.
* @param header
* the template specifying the binary table.
* @throws FitsException
* if there was a problem with the header.
*/
public static BinaryTable manufactureData(Header header) throws FitsException {
return new BinaryTable(header);
}
/**
* @return a newly created binary table HDU from the supplied data.
* @param data
* the data used to build the binary table. This is typically
* some kind of array of objects.
* @throws FitsException
* if there was a problem with the data.
*/
public static Header manufactureHeader(Data data) throws FitsException {
Header hdr = new Header();
data.fillHeader(hdr);
return hdr;
}
@Override
public int addColumn(Object data) throws FitsException {
this.myData.addColumn(data);
this.myData.pointToColumn(getNCols() - 1, this.myHeader);
return super.addColumn(data);
}
/**
* What are the standard column stems for a binary table?
*/
@Override
protected IFitsHeader[] columnKeyStems() {
return BinaryTableHDU.KEY_STEMS;
}
/**
* Print out some information about this HDU.
*/
@Override
public void info(PrintStream stream) {
BinaryTable myData = this.myData;
stream.println(" Binary Table");
stream.println(" Header Information:");
int nhcol = this.myHeader.getIntValue(TFIELDS, -1);
int nrow = this.myHeader.getIntValue(NAXIS2, -1);
int rowsize = this.myHeader.getIntValue(NAXIS1, -1);
stream.print(" " + nhcol + " fields");
stream.println(", " + nrow + " rows of length " + rowsize);
for (int i = 1; i <= nhcol; i += 1) {
stream.print(" " + i + ":");
prtField(stream, "Name", TTYPEn.n(i).key());
prtField(stream, "Format", TFORMn.n(i).key());
prtField(stream, "Dimens", TDIMn.n(i).key());
stream.println("");
}
stream.println(" Data Information:");
if (myData == null || this.myData.getNRows() == 0 || this.myData.getNCols() == 0) {
stream.println(" No data present");
if (this.myData.getHeapSize() > 0) {
stream.println(" Heap size is: " + this.myData.getHeapSize() + " bytes");
}
} else {
stream.println(" Number of rows=" + this.myData.getNRows());
stream.println(" Number of columns=" + this.myData.getNCols());
if (this.myData.getHeapSize() > 0) {
stream.println(" Heap size is: " + this.myData.getHeapSize() + " bytes");
}
Object[] cols = this.myData.getFlatColumns();
for (int i = 0; i < cols.length; i += 1) {
stream.println(" " + i + ":" + ArrayFuncs.arrayDescription(cols[i]));
}
}
}
/**
* Check that this HDU has a valid header.
*
* @return true if this HDU has a valid header.
*/
public boolean isHeader() {
return isHeader(this.myHeader);
}
private void prtField(PrintStream stream, String type, String field) {
String val = this.myHeader.getStringValue(field);
if (val != null) {
stream.print(type + '=' + val + "; ");
}
}
/**
* Convert a column in the table to complex. Only tables with appropriate
* types and dimensionalities can be converted. It is legal to call this on
* a column that is already complex.
*
* @param index
* The 0-based index of the column to be converted.
* @return Whether the column can be converted
* @throws FitsException
* if the header could not be adapted
*/
public boolean setComplexColumn(int index) throws FitsException {
Standard.context(BinaryTable.class);
boolean status = false;
if (this.myData.setComplexColumn(index)) {
// No problem with the data. Make sure the header
// is right.
BinaryTable.ColumnDesc colDesc = this.myData.getDescriptor(index);
int dim = 1;
String tdim = "";
String sep = "";
// Don't loop over all values.
// The last is the [2] for the complex data.
int[] dimens = colDesc.getDimens();
for (int i = 0; i < dimens.length - 1; i += 1) {
dim *= dimens[i];
tdim = dimens[i] + sep + tdim;
sep = ",";
}
String suffix = "C"; // For complex
// Update the TFORMn keyword.
if (colDesc.getBase() == double.class) {
suffix = "M";
}
// Worry about variable length columns.
String prefix = "";
if (this.myData.getDescriptor(index).isVarying()) {
prefix = "P";
dim = 1;
if (this.myData.getDescriptor(index).isLongVary()) {
prefix = "Q";
}
}
// Now update the header.
this.myHeader.findCard(TFORMn.n(index + 1));
HeaderCard hc = this.myHeader.nextCard();
String oldComment = hc.getComment();
if (oldComment == null) {
oldComment = "Column converted to complex";
}
this.myHeader.card(TFORMn.n(index + 1)).value(dim + prefix + suffix).comment(oldComment);
if (tdim.length() > 0) {
this.myHeader.addValue(TDIMn.n(index + 1), "(" + tdim + ")");
} else {
// Just in case there used to be a TDIM card that's no longer
// needed.
this.myHeader.deleteKey(TDIMn.n(index + 1));
}
status = true;
}
Standard.context(null);
return status;
}
// Need to tell header about the Heap before writing.
@Override
public void write(ArrayDataOutput ado) throws FitsException {
int oldSize = this.myHeader.getIntValue(PCOUNT);
if (oldSize != this.myData.getHeapSize()) {
this.myHeader.addValue(PCOUNT, this.myData.getHeapSize());
}
if (this.myHeader.getIntValue(PCOUNT) == 0) {
this.myHeader.deleteKey(THEAP);
} else {
this.myHeader.getIntValue(TFIELDS);
int offset = this.myHeader.getIntValue(NAXIS1) * this.myHeader.getIntValue(NAXIS2) + this.myData.getHeapOffset();
this.myHeader.addValue(THEAP, offset);
}
super.write(ado);
}
}
nom/tam/fits/TruncatedFileException.java 0000664 0000000 0000000 00000003333 12755570700 017362 0 ustar root root package nom.tam.fits;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
/**
* This exception is thrown when an EOF is detected in the middle of an HDU.
*/
public class TruncatedFileException extends FitsException {
/**
* serial version UID.
*/
private static final long serialVersionUID = 1L;
public TruncatedFileException(String msg) {
super(msg);
}
public TruncatedFileException(String msg, Exception cause) {
super(msg, cause);
}
}
nom/tam/fits/PaddingException.java 0000664 0000000 0000000 00000005163 12755570700 016202 0 ustar root root package nom.tam.fits;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
/**
* This exception is thrown if an error is found reading the padding following a
* valid FITS HDU. This padding is required by the FITS standard, but some FITS
* writes forego writing it. To access such data users can use something like:
*
* Fits f = new Fits("somefile");
* try {
* f.read();
* } catch (PaddingException e) {
* f.addHDU(e.getHDU());
* }
* to ensure that a truncated HDU is included in the FITS object.
* Generally the FITS file have already added any HDUs prior to the truncated
* one.
*/
public class PaddingException extends FitsException {
/**
* serial version id.
*/
private static final long serialVersionUID = 1L;
/**
* The HDU where the error happened.
*/
private BasicHDU truncatedHDU;
public PaddingException(String msg, Data data, Exception cause) throws FitsException {
super(msg, cause);
this.truncatedHDU = FitsFactory.hduFactory(data.getKernel());
this.truncatedHDU = FitsFactory.hduFactory(this.truncatedHDU.getHeader(), data);
}
public BasicHDU getTruncatedHDU() {
return this.truncatedHDU;
}
void updateHeader(Header hdr) throws FitsException {
this.truncatedHDU = FitsFactory.hduFactory(hdr, this.truncatedHDU.getData());
}
}
nom/tam/fits/ImageData.java 0000664 0000000 0000000 00000030512 12755570700 014565 0 ustar root root package nom.tam.fits;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import static nom.tam.fits.header.Standard.BITPIX;
import static nom.tam.fits.header.Standard.EXTEND;
import static nom.tam.fits.header.Standard.GCOUNT;
import static nom.tam.fits.header.Standard.NAXIS;
import static nom.tam.fits.header.Standard.NAXISn;
import static nom.tam.fits.header.Standard.PCOUNT;
import static nom.tam.util.LoggerHelper.getLogger;
import java.io.EOFException;
import java.io.IOException;
import java.nio.Buffer;
import java.util.logging.Level;
import java.util.logging.Logger;
import nom.tam.fits.header.Standard;
import nom.tam.image.StandardImageTiler;
import nom.tam.util.ArrayDataInput;
import nom.tam.util.ArrayDataOutput;
import nom.tam.util.ArrayFuncs;
import nom.tam.util.RandomAccess;
import nom.tam.util.array.MultiArrayIterator;
import nom.tam.util.type.PrimitiveType;
import nom.tam.util.type.PrimitiveTypeHandler;
/**
* This class instantiates FITS primary HDU and IMAGE extension data.
* Essentially these data are a primitive multi-dimensional array.
*
* Starting in version 0.9 of the FITS library, this routine allows users to
* defer the reading of images if the FITS data is being read from a file. An
* ImageTiler object is supplied which can return an arbitrary subset of the
* image as a one dimensional array -- suitable for manipulation by standard
* Java libraries. A call to the getData() method will still return a
* multi-dimensional array, but the image data will not be read until the user
* explicitly requests. it.
*/
public class ImageData extends Data {
/**
* This class describes an array
*/
protected static class ArrayDesc {
private final int[] dims;
private final Class type;
ArrayDesc(int[] dims, Class type) {
this.dims = dims;
this.type = type;
}
}
/**
* This inner class allows the ImageTiler to see if the user has read in the
* data.
*/
protected class ImageDataTiler extends StandardImageTiler {
ImageDataTiler(RandomAccess o, long offset, ArrayDesc d) {
super(o, offset, d.dims, d.type);
}
@Override
protected Object getMemoryImage() {
return ImageData.this.dataArray;
}
}
private static final Logger LOG = getLogger(ImageData.class);
/** The size of the data */
private long byteSize;
/**
* The actual array of data. This is normally a multi-dimensional primitive
* array. It may be null until the getData() routine is invoked, or it may
* be filled by during the read call when a non-random access device is
* used.
*/
private Object dataArray;
/** A description of what the data should look like */
private ArrayDesc dataDescription;
/** The image tiler associated with this image. */
private StandardImageTiler tiler;
/**
* Create the equivalent of a null data element.
*/
public ImageData() {
this.dataArray = new byte[0];
this.byteSize = 0;
}
/**
* Create an array from a header description. This is typically how data
* will be created when reading FITS data from a file where the header is
* read first. This creates an empty array.
*
* @param h
* header to be used as a template.
* @throws FitsException
* if there was a problem with the header description.
*/
public ImageData(Header h) throws FitsException {
this.dataDescription = parseHeader(h);
}
/**
* Create an ImageData object using the specified object to initialize the
* data array.
*
* @param x
* The initial data array. This should be a primitive array but
* this is not checked currently.
*/
public ImageData(Object x) {
this.dataArray = x;
this.byteSize = ArrayFuncs.computeLSize(x);
}
/**
* Fill header with keywords that describe image data.
*
* @param head
* The FITS header
* @throws FitsException
* if the object does not contain valid image data.
*/
@Override
protected void fillHeader(Header head) throws FitsException {
if (this.dataArray == null) {
head.nullImage();
return;
}
Standard.context(ImageData.class);
String classname = this.dataArray.getClass().getName();
int[] dimens = ArrayFuncs.getDimensions(this.dataArray);
if (dimens == null || dimens.length == 0) {
throw new FitsException("Image data object not array");
}
int bitpix;
switch (classname.charAt(dimens.length)) {
case 'B':
bitpix = BasicHDU.BITPIX_BYTE;
break;
case 'S':
bitpix = BasicHDU.BITPIX_SHORT;
break;
case 'I':
bitpix = BasicHDU.BITPIX_INT;
break;
case 'J':
bitpix = BasicHDU.BITPIX_LONG;
break;
case 'F':
bitpix = BasicHDU.BITPIX_FLOAT;
break;
case 'D':
bitpix = BasicHDU.BITPIX_DOUBLE;
break;
default:
throw new FitsException("Invalid Object Type for FITS data:" + classname.charAt(dimens.length));
}
// if this is neither a primary header nor an image extension,
// make it a primary header
head.setSimple(true);
head.setBitpix(bitpix);
head.setNaxes(dimens.length);
for (int i = 1; i <= dimens.length; i += 1) {
if (dimens[i - 1] == -1) {
throw new FitsException("Unfilled array for dimension: " + i);
}
head.setNaxis(i, dimens[dimens.length - i]);
}
// Just in case!
head.addValue(EXTEND, true);
head.addValue(PCOUNT, 0);
head.addValue(GCOUNT, 1);
Standard.context(null);
}
/**
* Return the actual data. Note that this may return a null when the data is
* not readable. It might be better to throw a FitsException, but this is a
* very commonly called method and we prefered not to change how users must
* invoke it.
*/
@Override
public Object getData() {
if (this.dataArray == null && this.tiler != null) {
try {
this.dataArray = this.tiler.getCompleteImage();
} catch (Exception e) {
LOG.log(Level.SEVERE, "Unable to get complete image", e);
return null;
}
}
return this.dataArray;
}
public StandardImageTiler getTiler() {
return this.tiler;
}
/** Get the size in bytes of the data */
@Override
protected long getTrueSize() {
return this.byteSize;
}
protected ArrayDesc parseHeader(Header h) throws FitsException {
int gCount = h.getIntValue(GCOUNT, 1);
int pCount = h.getIntValue(PCOUNT, 0);
if (gCount > 1 || pCount != 0) {
throw new FitsException("Group data treated as images");
}
int bitPix = h.getIntValue(BITPIX, 0);
PrimitiveType primitivType = PrimitiveTypeHandler.valueOf(bitPix);
Class baseClass = primitivType.primitiveClass();
int ndim = h.getIntValue(NAXIS, 0);
int[] dims = new int[ndim];
// Note that we have to invert the order of the axes
// for the FITS file to get the order in the array we
// are generating.
this.byteSize = 1;
for (int i = 0; i < ndim; i += 1) {
int cdim = h.getIntValue(NAXISn.n(i + 1), 0);
if (cdim < 0) {
throw new FitsException("Invalid array dimension:" + cdim);
}
this.byteSize *= cdim;
dims[ndim - i - 1] = cdim;
}
this.byteSize *= primitivType.size();
if (ndim == 0) {
this.byteSize = 0;
}
return new ArrayDesc(dims, baseClass);
}
@Override
public void read(ArrayDataInput i) throws FitsException {
// Don't need to read null data (noted by Jens Knudstrup)
if (this.byteSize == 0) {
return;
}
setFileOffset(i);
if (i instanceof RandomAccess) {
this.tiler = new ImageDataTiler((RandomAccess) i, ((RandomAccess) i).getFilePointer(), this.dataDescription);
try {
// Handle long skips.
i.skipAllBytes(this.byteSize);
} catch (IOException e) {
throw new FitsException("Unable to skip over image:" + e);
}
} else {
this.dataArray = ArrayFuncs.newInstance(this.dataDescription.type, this.dataDescription.dims);
try {
i.readLArray(this.dataArray);
} catch (IOException e) {
throw new FitsException("Unable to read image data:" + e);
}
this.tiler = new ImageDataTiler(null, 0, this.dataDescription);
}
int pad = FitsUtil.padding(getTrueSize());
try {
i.skipAllBytes(pad);
} catch (EOFException e) {
throw new PaddingException("Error skipping padding after image", this, e);
} catch (IOException e) {
throw new FitsException("Error skipping padding after image", e);
}
}
public void setBuffer(Buffer data) {
PrimitiveType primType = PrimitiveTypeHandler.valueOf(this.dataDescription.type);
this.dataArray = ArrayFuncs.newInstance(this.dataDescription.type, this.dataDescription.dims);
MultiArrayIterator iterator = new MultiArrayIterator(this.dataArray);
Object array = iterator.next();
while (array != null) {
primType.getArray(data, array);
array = iterator.next();
}
}
void setTiler(StandardImageTiler tiler) {
this.tiler = tiler;
}
@Override
public void write(ArrayDataOutput o) throws FitsException {
// Don't need to write null data (noted by Jens Knudstrup)
if (this.byteSize == 0) {
return;
}
if (this.dataArray == null) {
if (this.tiler != null) {
// Need to read in the whole image first.
try {
this.dataArray = this.tiler.getCompleteImage();
} catch (IOException e) {
throw new FitsException("Error attempting to fill image", e);
}
} else if (this.dataArray == null && this.dataDescription != null) {
// Need to create an array to match a specified header.
this.dataArray = ArrayFuncs.newInstance(this.dataDescription.type, this.dataDescription.dims);
} else {
// This image isn't ready to be written!
throw new FitsException("Null image data");
}
}
try {
o.writeArray(this.dataArray);
} catch (IOException e) {
throw new FitsException("IO Error on image write" + e);
}
FitsUtil.pad(o, getTrueSize());
}
}
nom/tam/fits/ImageHDU.java 0000664 0000000 0000000 00000014605 12755570700 014341 0 ustar root root package nom.tam.fits;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import static nom.tam.fits.header.Standard.BITPIX;
import static nom.tam.fits.header.Standard.GROUPS;
import static nom.tam.fits.header.Standard.NAXIS;
import static nom.tam.fits.header.Standard.NAXISn;
import static nom.tam.fits.header.Standard.SIMPLE;
import static nom.tam.fits.header.Standard.XTENSION;
import static nom.tam.fits.header.Standard.XTENSION_IMAGE;
import static nom.tam.util.LoggerHelper.getLogger;
import java.io.PrintStream;
import java.util.logging.Level;
import java.util.logging.Logger;
import nom.tam.image.StandardImageTiler;
import nom.tam.util.ArrayFuncs;
import nom.tam.util.type.PrimitiveType;
import nom.tam.util.type.PrimitiveTypeHandler;
import nom.tam.util.type.PrimitiveTypes;
/**
* FITS image header/data unit
*/
public class ImageHDU extends BasicHDU {
private static final Logger LOG = getLogger(ImageHDU.class);
/**
* @return Encapsulate an object as an ImageHDU.
* @param o
* object to encapsulate
* @throws FitsException
* if the operation failed
*/
public static ImageData encapsulate(Object o) throws FitsException {
return new ImageData(o);
}
/**
* @return is this object can be described as a FITS image.
* @param o
* The Object being tested.
*/
public static boolean isData(Object o) {
if (o.getClass().isArray()) {
PrimitiveType type = PrimitiveTypeHandler.valueOf(ArrayFuncs.getBaseClass(o));
return type != PrimitiveTypes.BOOLEAN && //
type != PrimitiveTypes.STRING && //
type != PrimitiveTypes.UNKNOWN;
}
return false;
}
/**
* Check that this HDU has a valid header for this type.
*
* @param hdr
* header to check
* @return true if this HDU has a valid header.
*/
public static boolean isHeader(Header hdr) {
boolean found = hdr.getBooleanValue(SIMPLE);
if (!found) {
String xtension = hdr.getStringValue(XTENSION);
xtension = xtension == null ? "" : xtension.trim();
if (XTENSION_IMAGE.equals(xtension) || "IUEIMAGE".equals(xtension)) {
found = true;
}
}
if (!found) {
return false;
}
return !hdr.getBooleanValue(GROUPS);
}
public static Data manufactureData(Header hdr) throws FitsException {
return new ImageData(hdr);
}
/**
* @return Create a header that describes the given image data.
* @param d
* The image to be described.
* @throws FitsException
* if the object does not contain valid image data.
*/
public static Header manufactureHeader(Data d) throws FitsException {
if (d == null) {
return null;
}
Header h = new Header();
d.fillHeader(h);
return h;
}
/**
* Build an image HDU using the supplied data.
*
* @param h
* the header for the image.
* @param d
* the data used in the image.
* @throws FitsException
* if there was a problem with the data.
*/
public ImageHDU(Header h, ImageData d) throws FitsException {
super(h, d);
}
/** Indicate that Images can appear at the beginning of a FITS dataset */
@Override
protected boolean canBePrimary() {
return true;
}
public StandardImageTiler getTiler() {
return this.myData.getTiler();
}
/**
* Print out some information about this HDU.
*/
@Override
public void info(PrintStream stream) {
if (isHeader(this.myHeader)) {
stream.println(" Image");
} else {
stream.println(" Image (bad header)");
}
stream.println(" Header Information:");
stream.println(" BITPIX=" + this.myHeader.getIntValue(BITPIX, -1));
int naxis = this.myHeader.getIntValue(NAXIS, -1);
stream.println(" NAXIS=" + naxis);
for (int i = 1; i <= naxis; i += 1) {
stream.println(" NAXIS" + i + "=" + this.myHeader.getIntValue(NAXISn.n(i), -1));
}
stream.println(" Data information:");
try {
if (this.myData.getData() == null) {
stream.println(" No Data");
} else {
stream.println(" " + ArrayFuncs.arrayDescription(this.myData.getData()));
}
} catch (Exception e) {
LOG.log(Level.SEVERE, "Unable to get image data", e);
stream.println(" Unable to get data");
}
}
/** Change the Image from/to primary */
@Override
protected void setPrimaryHDU(boolean status) {
try {
super.setPrimaryHDU(status);
} catch (FitsException e) {
LOG.log(Level.SEVERE, "Impossible exception in ImageData", e);
}
if (status) {
this.myHeader.setSimple(true);
} else {
this.myHeader.setXtension(XTENSION_IMAGE);
}
}
}
nom/tam/fits/Fits.java 0000664 0000000 0000000 00000075256 12755570700 013674 0 ustar root root package nom.tam.fits;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.io.Closeable;
import java.io.DataOutput;
import java.io.DataOutputStream;
import java.io.EOFException;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.Properties;
import java.util.logging.Level;
import java.util.logging.Logger;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import nom.tam.fits.compress.CompressionManager;
import nom.tam.fits.utilities.FitsCheckSum;
import nom.tam.util.ArrayDataInput;
import nom.tam.util.ArrayDataOutput;
import nom.tam.util.BufferedDataInputStream;
import nom.tam.util.BufferedDataOutputStream;
import nom.tam.util.BufferedFile;
import nom.tam.util.RandomAccess;
import nom.tam.util.SafeClose;
/**
* This class provides access to routines to allow users to read and write FITS
* files. Description of the Package
*
* This FITS package attempts to make using FITS files easy, but does not do
* exhaustive error checking. Users should not assume that just because a FITS
* file can be read and written that it is necessarily legal FITS. These classes
* try to make it easy to transform between arrays of Java primitives and their
* FITS encodings.
*
* The Fits class provides capabilities to read and write data at the HDU
* level, and to add and delete HDU's from the current Fits object. A large
* number of constructors are provided which allow users to associate the Fits
* object with some form of external data. This external data may be in a
* compressed format.
*
* Note that this association is limited, it only specifies where the various
* read methods should read data from. It does not automatically read the data
* content and store the results. To ensure that the external content has been
* read and parsed the user may wish to invoke the read() method after creating
* the Fits object associated with external data. E.g.,
*
*
* File fl = ... ;
* Fits f = new Fits(fl); // Or we could have used one of the other constructors.
* // At this point the Fits object is empty.
* f.read(); // Read the external data into the Fits object
* // At this point the Fits object should have one or more HDUs depending
* // upon the external content.
*
*
* Users can choose to read only some of the HDUs in a given input, and may add
* HDU's that were either read from other files or generated by the program. See
* the various read and addHDU methods.
* The FitsFactory class is a factory class which is used to create HDUs.
* HDU's can be of a number of types derived from the abstract class BasicHDU.
* The hierarchy of HDUs is:
*
* BasicHDU
*
* ImageHDU
* RandomGroupsHDU
* TableHDU
*
* BinaryTableHDU
* AsciiTableHDU
*
* UndefinedHDU
*
*
* The Header class provides many functions to add, delete and read header
* keywords in a variety of formats.
* The HeaderCard class provides access to the structure of a FITS header
* card.
* The header package defines sets of enumerations that allow users to
* create and access header keywords in a controlled way.
* The Data class is an abstract class which provides the basic methods for
* reading and writing FITS data. It provides methods to get the the actual
* underlying arrays and detailed methods for manipulation specific to the
* different data types.
* The TableHDU class provides a large number of methods to access and
* modify information in tables.
* The utilities package includes simple tools to copy and list FITS files.
*
*
* @version 1.12
*/
public class Fits implements Closeable {
/**
* logger to log to.
*/
private static final Logger LOG = Logger.getLogger(Fits.class.getName());
/**
* The input stream associated with this Fits object.
*/
private ArrayDataInput dataStr;
/**
* A vector of HDUs that have been added to this Fits object.
*/
private final List> hduList = new ArrayList>();
/**
* Has the input stream reached the EOF?
*/
private boolean atEOF;
/**
* The last offset we reached. A -1 is used to indicate that we cannot use
* the offset.
*/
private long lastFileOffset = -1;
/**
* Create an empty Fits object which is not associated with an input stream.
*/
public Fits() {
}
/**
* Associate FITS object with a File. If the file is compressed a stream
* will be used, otherwise random access will be supported.
*
* @param myFile
* The File object. The content of this file will not be read
* into the Fits object until the user makes some explicit
* request. * @throws FitsException if the operation failed
* @throws FitsException
* if the operation failed
*/
public Fits(File myFile) throws FitsException {
this(myFile, CompressionManager.isCompressed(myFile));
}
/**
* Associate the Fits object with a File
*
* @param myFile
* The File object. The content of this file will not be read
* into the Fits object until the user makes some explicit
* request.
* @param compressed
* Is the data compressed?
* @throws FitsException
* if the operation failed
*/
public Fits(File myFile, boolean compressed) throws FitsException {
fileInit(myFile, compressed);
}
/**
* Create a Fits object associated with the given data stream. Compression
* is determined from the first few bytes of the stream.
*
* @param str
* The data stream. The content of this stream will not be read
* into the Fits object until the user makes some explicit
* request.
* @throws FitsException
* if the operation failed
*/
public Fits(InputStream str) throws FitsException {
streamInit(str);
}
/**
* Create a Fits object associated with a data stream.
*
* @param str
* The data stream. The content of this stream will not be read
* into the Fits object until the user makes some explicit
* request.
* @param compressed
* Is the stream compressed? This is currently ignored.
* Compression is determined from the first two bytes in the
* stream.
* @throws FitsException
* if the operation failed
* @deprecated use {@link #Fits(InputStream)} compression is auto detected.
*/
@Deprecated
public Fits(InputStream str, boolean compressed) throws FitsException {
this(str);
LOG.log(Level.INFO, "compression ignored, will be autodetected. was set to " + compressed);
}
/**
* Associate the FITS object with a file or URL. The string is assumed to be
* a URL if it begins one of the protocol strings. If the string ends in .gz
* it is assumed that the data is in a compressed format. All string
* comparisons are case insensitive.
*
* @param filename
* The name of the file or URL to be processed. The content of
* this file will not be read into the Fits object until the user
* makes some explicit request.
* @throws FitsException
* Thrown if unable to find or open a file or URL from the
* string given.
**/
public Fits(String filename) throws FitsException {
this(filename, CompressionManager.isCompressed(filename));
}
/**
* Associate the FITS object with a file or URL. The string is assumed to be
* a URL if it begins one of the protocol strings. If the string ends in .gz
* it is assumed that the data is in a compressed format. All string
* comparisons are case insensitive.
*
* @param filename
* The name of the file or URL to be processed. The content of
* this file will not be read into the Fits object until the user
* makes some explicit request.
* @param compressed
* is the file compressed?
* @throws FitsException
* Thrown if unable to find or open a file or URL from the
* string given.
**/
public Fits(String filename, boolean compressed) throws FitsException {
if (filename == null) {
throw new FitsException("Null FITS Identifier String");
}
try {
File fil = new File(filename);
if (fil.exists()) {
fileInit(fil, compressed);
return;
}
} catch (Exception e) {
LOG.log(Level.FINE, "not a file " + filename, e);
}
try {
InputStream str = Thread.currentThread().getContextClassLoader().getResourceAsStream(filename);
if (str != null) {
streamInit(str);
return;
}
} catch (Exception e) {
LOG.log(Level.FINE, "not a resource " + filename, e);
}
try {
InputStream is = FitsUtil.getURLStream(new URL(filename), 0);
streamInit(is);
return;
} catch (Exception e) {
LOG.log(Level.FINE, "not a url " + filename, e);
}
throw new FitsException("could not detect type of " + filename);
}
/**
* Associate the FITS object with a given URL
*
* @param myURL
* The URL to be read. The content of this URL will not be read
* into the Fits object until the user makes some explicit
* request.
* @throws FitsException
* Thrown if unable to find or open a file or URL from the
* string given.
*/
public Fits(URL myURL) throws FitsException {
try {
streamInit(FitsUtil.getURLStream(myURL, 0));
} catch (IOException e) {
throw new FitsException("Unable to open input from URL:" + myURL, e);
}
}
/**
* Associate the FITS object with a given uncompressed URL
*
* @param myURL
* The URL to be associated with the FITS file. The content of
* this URL will not be read into the Fits object until the user
* makes some explicit request.
* @param compressed
* Compression flag, ignored.
* @throws FitsException
* Thrown if unable to use the specified URL.
* @deprecated use {@link #Fits(InputStream)} compression is auto detected.
*/
@Deprecated
public Fits(URL myURL, boolean compressed) throws FitsException {
this(myURL);
LOG.log(Level.INFO, "compression ignored, will be autodetected. was set to " + compressed);
}
/**
* @return a newly created HDU from the given Data.
* @param data
* The data to be described in this HDU.
* @param
* the class of the HDU
* @throws FitsException
* if the operation failed
*/
public static BasicHDU makeHDU(DataClass data) throws FitsException {
Header hdr = new Header();
data.fillHeader(hdr);
return FitsFactory.hduFactory(hdr, data);
}
/**
* @return a newly created HDU from the given header.
* @param h
* The header which describes the FITS extension
* @throws FitsException
* if the header could not be converted to a HDU.
*/
public static BasicHDU makeHDU(Header h) throws FitsException {
Data d = FitsFactory.dataFactory(h);
return FitsFactory.hduFactory(h, d);
}
/**
* @return a newly created HDU from the given data kernel.
* @param o
* The data to be described in this HDU.
* @throws FitsException
* if the parameter could not be converted to a HDU.
*/
public static BasicHDU makeHDU(Object o) throws FitsException {
return FitsFactory.hduFactory(o);
}
/**
* @return the version of the library.
*/
public static String version() {
Properties props = new Properties();
InputStream versionProperties = null;
try {
versionProperties = Fits.class.getResourceAsStream("/META-INF/maven/gov.nasa.gsfc.heasarc/nom-tam-fits/pom.properties");
props.load(versionProperties);
return props.getProperty("version");
} catch (IOException e) {
LOG.log(Level.INFO, "reading version failed, ignoring", e);
return "unknown";
} finally {
saveClose(versionProperties);
}
}
/**
* close the input stream, and ignore eventual errors.
*
* @param in
* the input stream to close.
*/
public static void saveClose(InputStream in) {
SafeClose.close(in);
}
/**
* Add an HDU to the Fits object. Users may intermix calls to functions
* which read HDUs from an associated input stream with the addHDU and
* insertHDU calls, but should be careful to understand the consequences.
*
* @param myHDU
* The HDU to be added to the end of the FITS object.
* @throws FitsException
* if the HDU could not be inserted.
*/
public void addHDU(BasicHDU myHDU) throws FitsException {
insertHDU(myHDU, getNumberOfHDUs());
}
/**
* Get the current number of HDUs in the Fits object.
*
* @return The number of HDU's in the object.
* @deprecated use {@link #getNumberOfHDUs()} instead
*/
@Deprecated
public int currentSize() {
return getNumberOfHDUs();
}
/**
* Delete an HDU from the HDU list.
*
* @param n
* The index of the HDU to be deleted. If n is 0 and there is
* more than one HDU present, then the next HDU will be converted
* from an image to primary HDU if possible. If not a dummy
* header HDU will then be inserted.
* @throws FitsException
* if the HDU could not be deleted.
*/
public void deleteHDU(int n) throws FitsException {
int size = getNumberOfHDUs();
if (n < 0 || n >= size) {
throw new FitsException("Attempt to delete non-existent HDU:" + n);
}
this.hduList.remove(n);
if (n == 0 && size > 1) {
BasicHDU newFirst = this.hduList.get(0);
if (newFirst.canBePrimary()) {
newFirst.setPrimaryHDU(true);
} else {
insertHDU(BasicHDU.getDummyHDU(), 0);
}
}
}
/**
* Get a stream from the file and then use the stream initialization.
*
* @param myFile
* The File to be associated.
* @param compressed
* Is the data compressed?
* @throws FitsException
* if the opening of the file failed.
*/
@SuppressFBWarnings(value = "OBL_UNSATISFIED_OBLIGATION", justification = "stream stays open, and will be read when nessesary.")
protected void fileInit(File myFile, boolean compressed) throws FitsException {
try {
if (compressed) {
streamInit(new FileInputStream(myFile));
} else {
randomInit(myFile);
}
} catch (IOException e) {
throw new FitsException("Unable to create Input Stream from File: " + myFile, e);
}
}
/**
* @return the n'th HDU. If the HDU is already read simply return a pointer
* to the cached data. Otherwise read the associated stream until
* the n'th HDU is read.
* @param n
* The index of the HDU to be read. The primary HDU is index 0.
* @return The n'th HDU or null if it could not be found.
* @throws FitsException
* if the header could not be read
* @throws IOException
* if the underlying buffer threw an error
*/
public BasicHDU getHDU(int n) throws FitsException, IOException {
int size = getNumberOfHDUs();
for (int i = size; i <= n; i += 1) {
BasicHDU hdu = readHDU();
if (hdu == null) {
return null;
}
}
return this.hduList.get(n);
}
/**
* Get the current number of HDUs in the Fits object.
*
* @return The number of HDU's in the object.
*/
public int getNumberOfHDUs() {
return this.hduList.size();
}
/**
* Get the data stream used for the Fits Data.
*
* @return The associated data stream. Users may wish to call this function
* after opening a Fits object when they wish detailed control for
* writing some part of the FITS file.
*/
public ArrayDataInput getStream() {
return this.dataStr;
}
/**
* Insert a FITS object into the list of HDUs.
*
* @param myHDU
* The HDU to be inserted into the list of HDUs.
* @param position
* The location at which the HDU is to be inserted.
* @throws FitsException
* if the HDU could not be inserted.
*/
public void insertHDU(BasicHDU myHDU, int position) throws FitsException {
if (myHDU == null) {
return;
}
if (position < 0 || position > getNumberOfHDUs()) {
throw new FitsException("Attempt to insert HDU at invalid location: " + position);
}
try {
if (position == 0) {
// Note that the previous initial HDU is no longer the first.
// If we were to insert tables backwards from last to first,
// we could get a lot of extraneous DummyHDUs but we currently
// do not worry about that.
if (getNumberOfHDUs() > 0) {
this.hduList.get(0).setPrimaryHDU(false);
}
if (myHDU.canBePrimary()) {
myHDU.setPrimaryHDU(true);
this.hduList.add(0, myHDU);
} else {
insertHDU(BasicHDU.getDummyHDU(), 0);
myHDU.setPrimaryHDU(false);
this.hduList.add(1, myHDU);
}
} else {
myHDU.setPrimaryHDU(false);
this.hduList.add(position, myHDU);
}
} catch (NoSuchElementException e) {
throw new FitsException("hduList inconsistency in insertHDU", e);
}
}
/**
* Initialize using buffered random access. This implies that the data is
* uncompressed.
*
* @param file
* the file to open
* @throws FitsException
* if the file could not be read
*/
protected void randomInit(File file) throws FitsException {
String permissions = "r";
if (!file.exists() || !file.canRead()) {
throw new FitsException("Non-existent or unreadable file");
}
if (file.canWrite()) {
permissions += "w";
}
try {
this.dataStr = new BufferedFile(file, permissions);
((BufferedFile) this.dataStr).seek(0);
} catch (IOException e) {
throw new FitsException("Unable to open file " + file.getPath(), e);
}
}
/**
* Return all HDUs for the Fits object. If the FITS file is associated with
* an external stream make sure that we have exhausted the stream.
*
* @return an array of all HDUs in the Fits object. Returns null if there
* are no HDUs associated with this object.
* @throws FitsException
* if the reading failed.
*/
public BasicHDU[] read() throws FitsException {
readToEnd();
int size = getNumberOfHDUs();
if (size == 0) {
return new BasicHDU[0];
}
return this.hduList.toArray(new BasicHDU[size]);
}
/**
* Read a FITS file from an InputStream object.
*
* @param is
* The InputStream stream whence the FITS information is found.
* @throws FitsException
* if the data read could not be interpreted
*/
public void read(InputStream is) throws FitsException {
if (is instanceof ArrayDataInput) {
this.dataStr = (ArrayDataInput) is;
} else {
this.dataStr = new BufferedDataInputStream(is);
}
read();
}
/**
* Read the next HDU on the default input stream.
*
* @return The HDU read, or null if an EOF was detected. Note that null is
* only returned when the EOF is detected immediately at the
* beginning of reading the HDU.
* @throws FitsException
* if the header could not be read
* @throws IOException
* if the underlying buffer threw an error
*/
public BasicHDU readHDU() throws FitsException, IOException {
if (this.dataStr == null || this.atEOF) {
if (this.dataStr == null) {
LOG.warning("trying to read a hdu, without an input source!");
}
return null;
}
if (this.dataStr instanceof RandomAccess && this.lastFileOffset > 0) {
FitsUtil.reposition(this.dataStr, this.lastFileOffset);
}
Header hdr = Header.readHeader(this.dataStr);
if (hdr == null) {
this.atEOF = true;
return null;
}
Data data = hdr.makeData();
try {
data.read(this.dataStr);
} catch (PaddingException e) {
e.updateHeader(hdr);
throw e;
}
this.lastFileOffset = FitsUtil.findOffset(this.dataStr);
BasicHDU nextHDU = FitsFactory.hduFactory(hdr, data);
this.hduList.add(nextHDU);
return nextHDU;
}
/**
* Read to the end of the associated input stream
*
* @throws FitsException
* if the operation failed
*/
private void readToEnd() throws FitsException {
while (this.dataStr != null && !this.atEOF) {
try {
if (readHDU() == null) {
break;
}
} catch (EOFException e) {
if (FitsFactory.getAllowTerminalJunk() && //
e.getCause() instanceof TruncatedFileException && //
getNumberOfHDUs() > 0) {
this.atEOF = true;
return;
}
throw new FitsException("IO error: " + e);
} catch (IOException e) {
throw new FitsException("IO error: " + e);
}
}
}
/**
* Add or Modify the CHECKSUM keyword in all headers. by R J Mathar
*
* @throws FitsException
* if the operation failed
* @throws IOException
* if the underlying stream failed
*/
public void setChecksum() throws FitsException, IOException {
for (int i = 0; i < getNumberOfHDUs(); i += 1) {
setChecksum(getHDU(i));
}
}
/**
* Set the data stream to be used for future input.
*
* @param stream
* The data stream to be used.
*/
public void setStream(ArrayDataInput stream) {
this.dataStr = stream;
this.atEOF = false;
this.lastFileOffset = -1;
}
/**
* Return the number of HDUs in the Fits object. If the FITS file is
* associated with an external stream make sure that we have exhausted the
* stream.
*
* @return number of HDUs.
* @deprecated The meaning of size of ambiguous. Use
* {@link #getNumberOfHDUs()} instead. Note size() will read the
* input file/stream to the EOF before returning the number of
* HDUs which {@link #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();
*
* @throws FitsException
* if the file could not be read.
*/
@Deprecated
public int size() throws FitsException {
readToEnd();
return getNumberOfHDUs();
}
/**
* Skip the next HDU on the default input stream.
*
* @throws FitsException
* if the HDU could not be skipped
* @throws IOException
* if the underlying stream failed
*/
public void skipHDU() throws FitsException, IOException {
if (this.atEOF) {
return;
} else {
Header hdr = new Header(this.dataStr);
int dataSize = (int) hdr.getDataSize();
this.dataStr.skipAllBytes(dataSize);
if (this.dataStr instanceof RandomAccess) {
this.lastFileOffset = ((RandomAccess) this.dataStr).getFilePointer();
}
}
}
/**
* Skip HDUs on the associate input stream.
*
* @param n
* The number of HDUs to be skipped.
* @throws FitsException
* if the HDU could not be skipped
* @throws IOException
* if the underlying stream failed
*/
public void skipHDU(int n) throws FitsException, IOException {
for (int i = 0; i < n; i += 1) {
skipHDU();
}
}
/**
* Initialize the input stream. Mostly this checks to see if the stream is
* compressed and wraps the stream if necessary. Even if the stream is not
* compressed, it will likely be wrapped in a PushbackInputStream. So users
* should probably not supply a BufferedDataInputStream themselves, but
* should allow the Fits class to do the wrapping.
*
* @param inputStream
* stream to initialize
* @throws FitsException
* if the initialization failed
*/
protected void streamInit(InputStream inputStream) throws FitsException {
this.dataStr = new BufferedDataInputStream(CompressionManager.decompress(inputStream));
}
/**
* Write a Fits Object to an external Stream.
*
* @param os
* A DataOutput stream.
* @throws FitsException
* if the operation failed
*/
public void write(DataOutput os) throws FitsException {
ArrayDataOutput obs;
boolean newOS = false;
if (os instanceof ArrayDataOutput) {
obs = (ArrayDataOutput) os;
} else if (os instanceof DataOutputStream) {
newOS = true;
obs = new BufferedDataOutputStream((DataOutputStream) os);
} else {
throw new FitsException("Cannot create ArrayDataOutput from class " + os.getClass().getName());
}
for (BasicHDU basicHDU : hduList) {
basicHDU.write(obs);
}
if (newOS) {
try {
obs.flush();
obs.close();
} catch (IOException e) {
throw new FitsException("Error flushing/closing the FITS output stream: " + e, e);
}
}
if (obs instanceof BufferedFile) {
try {
((BufferedFile) obs).setLength(((BufferedFile) obs).getFilePointer());
} catch (IOException e) {
throw new FitsException("Error resizing the FITS output stream: " + e, e);
}
}
}
/**
* Write the FITS to the specified file. This is a wrapper method provided
* for convenience, which calls the {@link #write(DataOutput)} method. It
* creates a suitable {@link nom.tam.util.BufferedFile}, to which the FITS
* is then written. Upon completion the underlying stream is closed.
*
* @param file
* a file to which the FITS is to be written.
* @throws FitsException
* if {@link #write(DataOutput)} failed
* @throws IOException
* if the underlying output stream could not be created or
* closed.
*/
public void write(File file) throws IOException, FitsException {
BufferedFile bf = null;
try {
bf = new BufferedFile(file, "rw");
write(bf);
} finally {
SafeClose.close(bf);
}
}
@Override
public void close() throws IOException {
if (dataStr != null) {
this.dataStr.close();
}
}
/**
* set the checksum of a HDU.
*
* @param hdu
* the HDU to add a checksum
* @throws FitsException
* the checksum could not be added to the header
* @deprecated use {@link FitsCheckSum#setChecksum(BasicHDU)}
*/
@Deprecated
public static void setChecksum(BasicHDU hdu) throws FitsException {
FitsCheckSum.setChecksum(hdu);
}
/**
* calculate the checksum for the block of data
*
* @param data
* the data to create the checksum for
* @return the checksum
* @deprecated use {@link FitsCheckSum#checksum(byte[])}
*/
@Deprecated
public static long checksum(final byte[] data) {
return FitsCheckSum.checksum(data);
}
}
nom/tam/fits/utilities/ 0000775 0000000 0000000 00000000000 12755570706 014126 5 ustar root root nom/tam/fits/utilities/FitsReader.java 0000664 0000000 0000000 00000004003 12755570700 017010 0 ustar root root package nom.tam.fits.utilities;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import nom.tam.fits.BasicHDU;
import nom.tam.fits.Fits;
public final class FitsReader {
private FitsReader() {
}
public static void main(String[] args) throws Exception {
String file = args[0];
Fits f = new Fits(file);
int i = 0;
BasicHDU h;
do {
h = f.readHDU();
if (h != null) {
if (i == 0) {
System.out.println("\n\nPrimary header:\n");
} else {
System.out.println("\n\nExtension " + i + ":\n");
}
i += 1;
h.info(System.out);
}
} while (h != null);
f.close();
}
}
nom/tam/fits/utilities/FitsHeaderCardParser.java 0000664 0000000 0000000 00000020173 12755570700 020753 0 ustar root root package nom.tam.fits.utilities;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.util.Locale;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import nom.tam.util.AsciiFuncs;
/**
* A helper utility class to parse header cards for there value (especially
* strings) and comments.
*
* @author Richard van Nieuwenhoven
*/
public final class FitsHeaderCardParser {
/**
* value comment pair of the header card.
*/
public static class ParsedValue {
/**
* the comment specified with the value.
*/
private String comment;
/**
* was the value quoted?
*/
private final boolean isString;
/**
* the value of the card. (trimmed)
*/
private String value = null;
public ParsedValue() {
isString = false;
}
public ParsedValue(String value, String comment) {
isString = true;
this.value = value;
this.comment = comment;
}
/**
* @return the comment of the card.
*/
public String getComment() {
return this.comment;
}
/**
* @return the value of the card.
*/
public String getValue() {
return this.value;
}
/**
* @return true if the value was quoted.
*/
public boolean isString() {
return this.isString;
}
}
/**
* pattern to match FITS keywords, specially to parse hirarchical keywords.
*/
private static final Pattern KEYWORD_PATTERN = Pattern.compile("([A-Z|a-z|0-9|_|-]+)([ |\\.]*=?)");
/**
* pattern to match a quoted string where 2 quotes are used to escape a
* single quote inside the string. Attention this patern ist optimized as
* specified in http://www.perlmonks.org/?node_id=607740
*/
private static final Pattern STRING_PATTERN = Pattern.compile("'((?:[^']+(?=')|'')*)'(?!')");
/**
* delete the start and trailing quote from the sting and replace all
* (escaped)double quotes with a single quote. Then trim the trailing
* blanks.
*
* @param quotedString
* the string to un-quote.
* @return the unquoted string
*/
private static String deleteQuotes(String quotedString) {
int indexOfQuote = quotedString.indexOf('\'');
if (indexOfQuote < 0) {
int newLength = quotedString.length();
while (newLength > 0 && AsciiFuncs.isWhitespace(quotedString.charAt(newLength - 1))) {
newLength--;
}
return quotedString.substring(0, newLength);
} else {
int lastIndexOfQuote = 0;
StringBuffer sb = new StringBuffer(quotedString.length());
while (indexOfQuote >= 0) {
sb.append(quotedString, lastIndexOfQuote, indexOfQuote);
lastIndexOfQuote = indexOfQuote + 1;
indexOfQuote = quotedString.indexOf('\'', lastIndexOfQuote + 1);
}
sb.append(quotedString, lastIndexOfQuote, quotedString.length());
int newLength = sb.length();
while (newLength > 0 && AsciiFuncs.isWhitespace(sb.charAt(newLength - 1))) {
newLength--;
}
sb.setLength(newLength);
return sb.toString();
}
}
/**
* get the not empty comment string from the end of the card. start scanning
* from the end of the value.
*
* @param stringCard
* the string representing the card
* @param startPosition
* the start point for the scan
* @return the not empty comment or null if no comment was found.
*/
private static String extractComment(String stringCard, int startPosition) {
int startOfComment = stringCard.indexOf('/', startPosition) + 1;
if (startOfComment > 0 && stringCard.length() > startOfComment) {
return stringCard.substring(startOfComment).trim();
}
return null;
}
/**
* parse a fits keyword from a card and return it as a dot separated list.
*
* @param card
* the card to parse.
* @return dot separated key list
*/
public static String parseCardKey(String card) {
int indexOfEquals = card.indexOf('=');
StringBuilder builder = new StringBuilder();
Matcher kewordMatcher = FitsHeaderCardParser.KEYWORD_PATTERN.matcher(card);
while (kewordMatcher.find() && kewordMatcher.start() < indexOfEquals) {
if (builder.length() != 0) {
builder.append('.');
}
builder.append(kewordMatcher.group(1).toUpperCase(Locale.US));
if (kewordMatcher.group(2).endsWith("=")) {
break;
}
}
return builder.toString();
}
/**
* Parse the card for a value and comment. Quoted string values are unquoted
* and the {@link ParsedValue#isString} specifies if the value was a quoted
* string. non quoted values are trimmed.
*
* @param card
* the card to parse.
* @return a parsed card or null if no value could be detected.
*/
public static ParsedValue parseCardValue(String card) {
ParsedValue value = parseStringValue(card);
if (value == null) {
// ok no string lets check for an equals.
int indexOfEquals = card.indexOf('=');
if (indexOfEquals > 0) {
// its no string so the value goes max till the comment
value = new ParsedValue();
int endOfValue = card.length() - 1;
int startOfComment = card.indexOf('/', indexOfEquals);
if (startOfComment > 0) {
endOfValue = startOfComment - 1;
value.comment = extractComment(card, startOfComment);
}
value.value = card.substring(indexOfEquals + 1, endOfValue + 1).trim();
}
}
return value;
}
/**
* lets see if there is a quoted sting in the card.
*
* @param card
* the card string to parse.
* @return the parsed value with the unquoted string or null if no quoted
* string was found.
*/
private static ParsedValue parseStringValue(String card) {
int indexOfQuote = card.indexOf('\'');
if (indexOfQuote >= 0) {
Matcher matcher = FitsHeaderCardParser.STRING_PATTERN.matcher(card);
if (matcher.find(indexOfQuote)) {
if (card.lastIndexOf('/', matcher.start()) < 0) {
return new ParsedValue(deleteQuotes(matcher.group(1)), extractComment(card, matcher.end()));
}
}
}
return null;
}
/**
* utility class will not be instantiated.
*/
private FitsHeaderCardParser() {
}
}
nom/tam/fits/utilities/FitsCopy.java 0000664 0000000 0000000 00000004203 12755570700 016522 0 ustar root root package nom.tam.fits.utilities;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import nom.tam.fits.BasicHDU;
import nom.tam.fits.Fits;
import nom.tam.util.BufferedFile;
public final class FitsCopy {
private FitsCopy() {
}
public static void main(String[] args) throws Exception {
String file = args[0];
Fits f = new Fits(file);
int i = 0;
BasicHDU h;
do {
h = f.readHDU();
if (h != null) {
if (i == 0) {
System.out.println("\n\nPrimary header:\n");
} else {
System.out.println("\n\nExtension " + i + ":\n");
}
i += 1;
h.info(System.out);
}
} while (h != null);
f.close();
BufferedFile bf = new BufferedFile(args[1], "rw");
f.write(bf);
bf.close();
}
}
nom/tam/fits/utilities/FitsLineAppender.java 0000664 0000000 0000000 00000014125 12755570700 020162 0 ustar root root package nom.tam.fits.utilities;
import nom.tam.fits.HeaderCard;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
/**
* This class handles the writing of a card line. It keeps track of the position
* in the line and will limit it to 80 characters. A write will never cross the
* line border but a write when the line is at position 80 will start a new
* line.
*
* @author Richard van Nieuwenhoven
*/
public class FitsLineAppender {
/**
* A String of 80 spaces to fill up fits card space.
*/
private static final String FULL_CARD_AS_SPACES = String.format("%80s", "");
/**
* the underlying StringBuilder to which the writing of fits lines happens.
*/
private final StringBuilder buffer;
/**
* the char current position in the line.
*/
private int charCount;
/**
* create a new FitsLineAppender that will have space allocated for one
* line.
*/
public FitsLineAppender() {
this.buffer = new StringBuilder(HeaderCard.FITS_HEADER_CARD_SIZE);
}
/**
* append a character to the fits line.
*
* @param character
* the character to append to the line.
*/
public void append(char character) {
this.buffer.append(character);
this.charCount++;
}
/**
* Append a sub-string to this line.
*
* @param stringValue
* the sub string to append.
*/
public void append(FitsSubString stringValue) {
stringValue.appendTo(this.buffer);
this.charCount += stringValue.length();
}
/**
* append a string to the fits line, but limit the append to the line
* length. rest of the string will be silently truncated.
*
* @param string
* the string to append
*/
public void append(String string) {
this.charCount = this.charCount % HeaderCard.FITS_HEADER_CARD_SIZE;
int newLength = this.charCount + string.length();
if (newLength > HeaderCard.FITS_HEADER_CARD_SIZE) {
this.buffer.append(string, 0, HeaderCard.FITS_HEADER_CARD_SIZE - this.charCount);
this.charCount = 0;
} else {
this.charCount = newLength;
this.buffer.append(string);
}
}
/**
* append a string to the buffer, replacing all occurrences of a character
* with an other.
*
* @param key
* the string to write
* @param toReplace
* the character to replace
* @param with
* the character to replace the toReplace character with.
*/
public void appendReplacing(String key, char toReplace, char with) {
int size = key.length();
for (int index = 0; index < size; index++) {
char character = key.charAt(index);
if (character == toReplace) {
this.buffer.append(with);
} else {
this.buffer.append(character);
}
}
this.charCount += size;
}
/**
* append a number of spaces to the line, limited to the line length! This
* will only be done if the line is already started, so attention when a
* line is still empty this method will have no effect on empty lines.
*
* @param count
* the number of spaces to write.
*/
public void appendSpacesTo(int count) {
this.charCount = this.charCount % HeaderCard.FITS_HEADER_CARD_SIZE;
if (this.charCount != 0) {
int spaces = count - this.charCount;
if (spaces > 0) {
this.buffer.append(FitsLineAppender.FULL_CARD_AS_SPACES, 0, spaces);
this.charCount += spaces;
}
}
}
/**
* fill the rest of current line with spaces and start a new fits line.
*/
public void completeLine() {
int count = HeaderCard.FITS_HEADER_CARD_SIZE - this.charCount % HeaderCard.FITS_HEADER_CARD_SIZE;
if (count < HeaderCard.FITS_HEADER_CARD_SIZE) {
this.buffer.append(FitsLineAppender.FULL_CARD_AS_SPACES, 0, count);
}
// line completed start with 0;
this.charCount = 0;
}
/**
* @return the character position in the current line.
*/
public int length() {
this.charCount = this.charCount % HeaderCard.FITS_HEADER_CARD_SIZE;
return this.charCount;
}
/**
* @return the number of characters still available in the current fits
* line.
*/
public int spaceLeftInLine() {
this.charCount = this.charCount % HeaderCard.FITS_HEADER_CARD_SIZE;
return HeaderCard.FITS_HEADER_CARD_SIZE - this.charCount;
}
@Override
public String toString() {
return this.buffer.toString();
}
public void append(String key, int start, int end) {
this.buffer.append(key, start, end);
this.charCount += end - start;
}
}
nom/tam/fits/utilities/FitsSubString.java 0000664 0000000 0000000 00000011367 12755570700 017541 0 ustar root root package nom.tam.fits.utilities;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
/**
* This class is a pointer into a part of an other string, it can be manipulated
* by changing the position pointers into the "original" string. This class is
* aware of the escape quote, two quotes in sequence the respresent a single
* quote.
*
* @author Richard van Nieuwenhoven
*/
public class FitsSubString {
/**
* the length of the substring (starting at the offset).
*/
private int length;
/**
* the offset into the original string where this string starts.
*/
private int offset;
/**
* the original String.
*/
private final String originalString;
/**
* constructor for the substring, start by representing the whole string.
*
* @param originalString
* the string to represent.
*/
public FitsSubString(String originalString) {
this.originalString = originalString == null ? "" : originalString;
this.offset = 0;
this.length = this.originalString.length();
}
/**
* append the current string representation to the StringBuffer.
*
* @param buffer
* the buffer to append to.
*/
public void appendTo(StringBuilder buffer) {
buffer.append(this.originalString, this.offset, this.offset + this.length);
}
/**
* get the character at the specified position.
*
* @param pos
* the position the get the character from
* @return the character at the specified position
*/
public char charAt(int pos) {
return this.originalString.charAt(pos + this.offset);
}
/**
* @return get the length of the orginal string from the current offset.
*/
public int fullLength() {
return this.originalString.length() - this.offset;
}
/**
* check the string and set it to the maximum length specified. if a escaped
* quote is on the boundary the length is reduced in a way that the string
* does not separate an escape quote.
*
* @param max
* the maximum string legth to set.
*/
public void getAdjustedLength(int max) {
if (max <= 0) {
this.length = 0;
} else if (this.length > max) {
int pos = max - 1;
while (charAt(pos) == '\'') {
pos--;
}
// now we are at the start of the quotes step forward in steps of 2
pos += (max - 1 - pos) / 2 * 2;
this.length = pos + 1;
}
}
/**
* @return the string length of this String.
*/
public int length() {
return this.length;
}
/**
* shift the sting to the rest of the string, the part of the original
* string that is after the part of the string this instance currently
* represents.
*/
public void rest() {
this.offset += this.length;
this.length = this.originalString.length() - this.offset;
}
/**
* skip over the specified number of characters.
*
* @param count
* the number of chars to skip
*/
public void skip(int count) {
this.offset += count;
this.length -= count;
}
/**
* @param string
* the string to check
* @return true if the current string starts with the specified string.
*/
public boolean startsWith(String string) {
return this.originalString.regionMatches(this.offset, string, 0, string.length());
}
}
nom/tam/fits/utilities/Main.java 0000664 0000000 0000000 00000004047 12755570700 015654 0 ustar root root package nom.tam.fits.utilities;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
public final class Main {
private Main() {
}
public static void main(String[] args) throws Exception {
if (args.length > 0 && "copy".equalsIgnoreCase(args[0])) {
FitsCopy.main(copyArgs(args));
} else if (args.length > 0 && "read".equalsIgnoreCase(args[0])) {
FitsReader.main(copyArgs(args));
} else {
System.out.println("do not know what to do, available are copy and read!"); // NOSONAR
}
}
private static String[] copyArgs(String[] args) {
String[] newArgs = new String[args.length - 1];
for (int index = 0; index < newArgs.length; index++) {
newArgs[index] = args[index + 1];
}
return newArgs;
}
}
nom/tam/fits/utilities/FitsCheckSum.java 0000664 0000000 0000000 00000025100 12755570700 017311 0 ustar root root package nom.tam.fits.utilities;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import static nom.tam.fits.header.Checksum.CHECKSUM;
import static nom.tam.fits.header.Checksum.DATASUM;
import static nom.tam.util.FitsIO.BYTE_1_OF_LONG_MASK;
import static nom.tam.util.FitsIO.BYTE_2_OF_LONG_MASK;
import static nom.tam.util.FitsIO.BYTE_3_OF_LONG_MASK;
import static nom.tam.util.FitsIO.BYTE_4_OF_LONG_MASK;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.logging.Logger;
import nom.tam.fits.BasicHDU;
import nom.tam.fits.FitsException;
import nom.tam.fits.Header;
import nom.tam.util.AsciiFuncs;
import nom.tam.util.BufferedDataOutputStream;
import nom.tam.util.FitsIO;
public final class FitsCheckSum {
private static final int CHECKSUM_STRING_SIZE = 16;
/**
* logger to log to.
*/
private static final Logger LOG = Logger.getLogger(FitsCheckSum.class.getName());
private static final int CHECKSUM_BLOCK_SIZE = 4;
private static final int CHECKSUM_HALF_BLOCK_SIZE = 2;
/**
* Calculate the Seaman-Pence 32-bit 1's complement checksum over the byte
* stream. The option to start from an intermediate checksum accumulated
* over another previous byte stream is not implemented. The implementation
* accumulates in two 64-bit integer values the two low-order and the two
* high-order bytes of adjacent 4-byte groups. A carry-over of bits is never
* done within the main loop (only once at the end at reduction to a 32-bit
* positive integer) since an overflow of a 64-bit value (signed, with
* maximum at 2^63-1) by summation of 16-bit values could only occur after
* adding approximately 140G short values (=2^47) (280GBytes) or more. We
* assume for now that this routine here is never called to swallow FITS
* files of that size or larger. by R J Mathar
* {@link nom.tam.fits.header.Checksum#CHECKSUM}
*
* @param data
* the byte sequence
* @return the 32bit checksum in the range from 0 to 2^32-1
* @since 2005-10-05
*/
public static long checksum(final byte[] data) {
long hi = 0;
long lo = 0;
final int len = CHECKSUM_HALF_BLOCK_SIZE * (data.length / CHECKSUM_BLOCK_SIZE);
// System.out.println(data.length + " bytes") ;
final int remain = data.length % CHECKSUM_BLOCK_SIZE;
if (remain != 0) {
throw new IllegalArgumentException("fits blocks always must be devidable by 4");
}
/*
* a write(2) on Sparc/PA-RISC would write the MSB first, on Linux the
* LSB; by some kind of coincidence, we can stay with the byte order
* known from the original C version of the algorithm.
*/
for (int i = 0; i < len; i += CHECKSUM_HALF_BLOCK_SIZE) {
/*
* The four bytes in this block handled by a single 'i' are each
* signed (-128 to 127) in Java and need to be masked indivdually to
* avoid sign extension /propagation.
*/
int offset = CHECKSUM_HALF_BLOCK_SIZE * i;
hi += data[offset++] << FitsIO.BITS_OF_1_BYTE & BYTE_2_OF_LONG_MASK | data[offset++] & BYTE_1_OF_LONG_MASK;
lo += data[offset++] << FitsIO.BITS_OF_1_BYTE & BYTE_2_OF_LONG_MASK | data[offset++] & BYTE_1_OF_LONG_MASK;
}
long hicarry = hi >>> FitsIO.BITS_OF_2_BYTES;
long locarry = lo >>> FitsIO.BITS_OF_2_BYTES;
while (hicarry != 0 || locarry != 0) {
hi = (hi & FitsIO.SHORT_OF_LONG_MASK) + locarry;
lo = (lo & FitsIO.SHORT_OF_LONG_MASK) + hicarry;
hicarry = hi >>> FitsIO.BITS_OF_2_BYTES;
locarry = lo >>> FitsIO.BITS_OF_2_BYTES;
}
return hi << FitsIO.BITS_OF_2_BYTES | lo;
}
/**
* Encode a 32bit integer according to the Seaman-Pence proposal.
*
* @see heasarc
* checksum doc
* @param c
* the checksum previously calculated
* @param compl
* complement the value
* @return the encoded string of 16 bytes.
*/
public static String checksumEnc(final long c, final boolean compl) {
byte[] asc = new byte[CHECKSUM_STRING_SIZE];
final int[] exclude = {
0x3a,
0x3b,
0x3c,
0x3d,
0x3e,
0x3f,
0x40,
0x5b,
0x5c,
0x5d,
0x5e,
0x5f,
0x60
};
final long[] mask = {
BYTE_4_OF_LONG_MASK,
BYTE_3_OF_LONG_MASK,
BYTE_2_OF_LONG_MASK,
BYTE_1_OF_LONG_MASK
};
final int offset = 0x30; /* ASCII 0 (zero */
final long value = compl ? ~c : c;
for (int i = 0; i < CHECKSUM_BLOCK_SIZE; i++) {
// each byte becomes four
final int byt = (int) ((value & mask[i]) >>> FitsIO.BITS_OF_3_BYTES - FitsIO.BITS_OF_1_BYTE * i);
final int quotient = byt / CHECKSUM_BLOCK_SIZE + offset;
final int remainder = byt % CHECKSUM_BLOCK_SIZE;
int[] ch = new int[CHECKSUM_BLOCK_SIZE];
for (int j = 0; j < CHECKSUM_BLOCK_SIZE; j++) {
ch[j] = quotient;
}
ch[0] += remainder;
boolean check = true;
while (check) {
// avoid ASCII punctuation
check = false;
for (int element : exclude) {
for (int j = 0; j < CHECKSUM_BLOCK_SIZE; j += CHECKSUM_HALF_BLOCK_SIZE) {
if (ch[j] == element || ch[j + 1] == element) {
ch[j]++;
ch[j + 1]--;
check = true;
}
}
}
}
for (int j = 0; j < CHECKSUM_BLOCK_SIZE; j++) {
// assign the bytes
asc[CHECKSUM_BLOCK_SIZE * j + i] = (byte) ch[j];
}
}
// shift the bytes 1 to the right circularly.
String resul = AsciiFuncs.asciiString(asc, CHECKSUM_STRING_SIZE - 1, 1);
return resul.concat(AsciiFuncs.asciiString(asc, 0, CHECKSUM_STRING_SIZE - 1));
}
/**
* Add or update the CHECKSUM keyword. by R J Mathar
*
* @param hdu
* the HDU to be updated.
* @throws FitsException
* if the operation failed
* @since 2005-10-05
*/
public static void setChecksum(BasicHDU hdu) throws FitsException {
try {
/*
* the next line with the delete is needed to avoid some unexpected
* problems with non.tam.fits.Header.checkCard() which otherwise
* says it expected PCOUNT and found DATE.
*/
Header hdr = hdu.getHeader();
hdr.deleteKey(CHECKSUM);
hdr.deleteKey(DATASUM);
/*
* delete the keys to force rewriting of the ckecksum and update of
* the checksum comment
*/
hdr.addValue(CHECKSUM, "0000000000000000");
hdr.addValue(DATASUM, "0");
// write the header to stream to get the cards sorted. no need to
// flush because we will ignore the data.
ByteArrayOutputStream hduByteImage = new ByteArrayOutputStream();
hdu.getHeader().write(new BufferedDataOutputStream(hduByteImage));
hduByteImage.reset();
/*
* Convert the entire sequence of 2880 byte header cards into a byte
* tiledImageOperation. The main benefit compared to the C
* implementations is that we do not need to worry about the
* particular byte order on machines (Linux/VAX/MIPS vs Hp-UX,
* Sparc...) supposed that the correct implementation is in the
* write() interface.
*/
BufferedDataOutputStream bdos = new BufferedDataOutputStream(hduByteImage);
hdu.getData().write(bdos);
bdos.flush();
long csd = checksum(hduByteImage.toByteArray());
hdu.getHeader().card(DATASUM).value(Long.toString(csd));
// We already have the checksum of the data. Lets compute it for
// the header.
hduByteImage.reset();
hdu.getHeader().write(bdos);
bdos.flush();
long csh = checksum(hduByteImage.toByteArray());
long cshdu = csh + csd;
// If we had a carry it should go into the
// beginning.
while ((cshdu & FitsIO.HIGH_INTEGER_MASK) != 0) {
long cshduIntPart = cshdu & FitsIO.INTEGER_MASK;
cshdu = cshduIntPart + 1;
}
/*
* This time we do not use a deleteKey() to ensure that the keyword
* is replaced "in place". Note that the value of the checksum is
* actually independent to a permutation of the 80-byte records
* within the header.
*/
hdr.card(CHECKSUM).value(checksumEnc(cshdu, true));
} catch (IOException e) {
throw new FitsException("Could not calculate the checksum!", e);
}
}
private FitsCheckSum() {
}
}
nom/tam/fits/HeaderOrder.java 0000664 0000000 0000000 00000013526 12755570700 015143 0 ustar root root package nom.tam.fits;
import static nom.tam.fits.header.Standard.BITPIX;
import static nom.tam.fits.header.Standard.BLOCKED;
import static nom.tam.fits.header.Standard.END;
import static nom.tam.fits.header.Standard.EXTEND;
import static nom.tam.fits.header.Standard.GCOUNT;
import static nom.tam.fits.header.Standard.NAXIS;
import static nom.tam.fits.header.Standard.PCOUNT;
import static nom.tam.fits.header.Standard.SIMPLE;
import static nom.tam.fits.header.Standard.TFIELDS;
import static nom.tam.fits.header.Standard.THEAP;
import static nom.tam.fits.header.Standard.XTENSION;
import java.io.Serializable;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
/**
* This class implements a comparator which ensures that FITS keywords are
* written out in a proper order.
*/
public class HeaderOrder implements java.util.Comparator, Serializable {
/**
* Serialization id.
*/
private static final long serialVersionUID = 1L;
/**
* Which order should the cards indexed by these keys be written out? This
* method assumes that the arguments are either the FITS Header keywords as
* strings, and some other type (or null) for comment style keywords.
*
* @return -1 if the first argument should be written first {
private static final int SPACE_NEEDED_FOR_EQUAL_AND_TWO_BLANKS = 3;
private static final double MAX_DECIMAL_VALUE_TO_USE_PLAIN_STRING = 1.0E16;
private static final Logger LOG = Logger.getLogger(HeaderCard.class.getName());
private static final String CONTINUE_CARD_PREFIX = CONTINUE.key() + " '";
public static final int FITS_HEADER_CARD_SIZE = 80;
private static final String HIERARCH_WITH_BLANK = NonStandard.HIERARCH.key() + " ";
private static final int HIERARCH_WITH_BLANK_LENGTH = HIERARCH_WITH_BLANK.length();
private static final String HIERARCH_WITH_DOT = NonStandard.HIERARCH.key() + ".";
/**
* regexp for IEEE floats
*/
private static final Pattern IEEE_REGEX = Pattern.compile("[+-]?(?=\\d*[.eE])(?=\\.?\\d)\\d*\\.?\\d*(?:[eE][+-]?\\d+)?");
private static final BigDecimal LONG_MAX_VALUE_AS_BIG_DECIMAL = BigDecimal.valueOf(Long.MAX_VALUE);
/**
* regexp for numbers.
*/
private static final Pattern LONG_REGEX = Pattern.compile("[+-]?[0-9][0-9]*");
/**
* max number of characters an integer can have.
*/
private static final int MAX_INTEGER_STRING_SIZE = Integer.toString(Integer.MAX_VALUE).length() - 1;
/** Maximum length of a FITS keyword field */
public static final int MAX_KEYWORD_LENGTH = 8;
/**
* the start and end quotes of the string and the ampasant to continue the
* string.
*/
public static final int MAX_LONG_STRING_CONTINUE_OVERHEAD = 3;
/**
* max number of characters a long can have.
*/
private static final int MAX_LONG_STRING_SIZE = Long.toString(Long.MAX_VALUE).length() - 1;
/**
* Maximum length of a FITS long string value field. the & for the
* continuation needs one char.
*/
public static final int MAX_LONG_STRING_VALUE_LENGTH = HeaderCard.MAX_STRING_VALUE_LENGTH - 1;
/**
* if a commend needs the be specified 2 extra chars are needed to start the
* comment
*/
public static final int MAX_LONG_STRING_VALUE_WITH_COMMENT_LENGTH = HeaderCard.MAX_LONG_STRING_VALUE_LENGTH - 2;
/**
* Maximum length of a FITS string value field.
*/
public static final int MAX_STRING_VALUE_LENGTH = HeaderCard.MAX_VALUE_LENGTH - 2;
/**
* Maximum length of a FITS value field.
*/
public static final int MAX_VALUE_LENGTH = 70;
private static final int NORMAL_ALIGN_POSITION = 30;
private static final int NORMAL_SMALL_STRING_ALIGN_POSITION = 19;
private static final int STRING_SPLIT_POSITION_FOR_EXTRA_COMMENT_SPACE = 35;
/**
* The comment part of the card (set to null if there's no comment)
*/
private String comment;
/**
* A flag indicating whether or not this is a string value
*/
private boolean isString;
/**
* The keyword part of the card (set to null if there's no keyword)
*/
private String key;
/**
* Does this card represent a nullable field. ?
*/
private boolean nullable;
/**
* The value part of the card (set to null if there's no value)
*/
private String value;
/**
* @return a created HeaderCard from a FITS card string.
* @param card
* the 80 character card image
*/
public static HeaderCard create(String card) {
try {
return new HeaderCard(stringToArrayInputStream(card));
} catch (Exception e) {
throw new IllegalArgumentException("card not legal", e);
}
}
/**
* Create a string from a BigDecimal making sure that it's not longer than
* the available space.
*
* @param decimalValue
* the decimal value to print
* @param availableSpace
* the space available for the value
* @return the string representing the value.
*/
private static String dblString(BigDecimal decimalValue, int availableSpace) {
return dblString(decimalValue, -1, availableSpace);
}
/**
* Create a string from a BigDecimal making sure that it's not longer than
* the available space.
*
* @param decimalValue
* the decimal value to print
* @param precision
* the precision to use
* @param availableSpace
* the space available for the value
* @return the string representing the value.
*/
private static String dblString(BigDecimal decimalValue, int precision, int availableSpace) {
BigDecimal decimal = decimalValue;
if (precision >= 0) {
decimal = decimalValue.setScale(precision, RoundingMode.HALF_UP);
}
double absInput = Math.abs(decimalValue.doubleValue());
if (absInput > 0d && absInput < MAX_DECIMAL_VALUE_TO_USE_PLAIN_STRING) {
String value = decimal.toPlainString();
if (value.length() < availableSpace) {
return value;
}
}
String value = decimalValue.toString();
while (value.length() > availableSpace) {
decimal = decimalValue.setScale(decimal.scale() - 1, BigDecimal.ROUND_HALF_UP);
value = decimal.toString();
}
return value;
}
/**
* Create a string from a BigDecimal making sure that it's not longer than
* the available space.
*
* @param decimalValue
* the decimal value to print
* @param availableSpace
* the space available for the value
* @return the string representing the value.
*/
private static String dblString(double decimalValue, int availableSpace) {
return dblString(BigDecimal.valueOf(decimalValue), -1, availableSpace);
}
/**
* @param input
* float value being converted
* @param precision
* the number of decimal places to show
* @return Create a fixed decimal string from a double with the specified
* precision.
*/
private static String dblString(double input, int precision, int availableSpace) {
return dblString(BigDecimal.valueOf(input), precision, availableSpace);
}
/**
* attention float to double cases are very lossy so a toString is needed to
* keep the precision. proof (double)500.055f = 500.05499267578125d
*
* @param floatValue
* the float value
* @return the BigDecimal as close to the value of the float as possible
*/
private static BigDecimal floatToBigDecimal(float floatValue) {
return new BigDecimal(floatValue, MathContext.DECIMAL32);
}
/**
* detect the decimal type of the value, does it fit in a Double/BigInteger
* or must it be a BigDecimal to keep the needed precission.
*
* @param value
* the String value to check.
* @return the type to fit the value
*/
private static Class getDecimalNumberType(String value) {
BigDecimal bigDecimal = new BigDecimal(value);
if (bigDecimal.abs().compareTo(HeaderCard.LONG_MAX_VALUE_AS_BIG_DECIMAL) > 0 && bigDecimal.remainder(BigDecimal.ONE).compareTo(BigDecimal.ZERO) == 0) {
return BigInteger.class;
} else if (bigDecimal.equals(BigDecimal.valueOf(Double.valueOf(value)))) {
return Double.class;
} else {
return BigDecimal.class;
}
}
private static Class getIntegerNumberType(String value) {
int length = value.length();
if (value.charAt(0) == '-' || value.charAt(0) == '+') {
length--;
}
if (length <= HeaderCard.MAX_INTEGER_STRING_SIZE) {
return Integer.class;
} else if (length <= HeaderCard.MAX_LONG_STRING_SIZE) {
return Long.class;
} else {
return BigInteger.class;
}
}
/**
* Read exactly one complete fits header line from the input.
*
* @param dis
* the data input stream to read the line
* @return a string of exactly 80 characters
* @throws IOException
* if the input stream could not be read
* @throws TruncatedFileException
* is there was not a complete line available in the input.
*/
private static String readOneHeaderLine(HeaderCardCountingArrayDataInput dis) throws IOException, TruncatedFileException {
byte[] buffer = new byte[FITS_HEADER_CARD_SIZE];
int len;
int need = FITS_HEADER_CARD_SIZE;
try {
while (need > 0) {
len = dis.in().read(buffer, FITS_HEADER_CARD_SIZE - need, need);
if (len == 0) {
throw new TruncatedFileException("nothing to read left");
}
need -= len;
}
} catch (EOFException e) {
if (need == FITS_HEADER_CARD_SIZE) {
throw e;
}
throw new TruncatedFileException(e.getMessage());
}
dis.cardRead();
return AsciiFuncs.asciiString(buffer);
}
private static int spaceAvailableForValue(String key) {
return FITS_HEADER_CARD_SIZE - (Math.max(key.length(), CONTINUE.key().length()) + SPACE_NEEDED_FOR_EQUAL_AND_TWO_BLANKS);
}
private static ArrayDataInput stringToArrayInputStream(String card) {
byte[] bytes = AsciiFuncs.getBytes(card);
if (bytes.length % FITS_HEADER_CARD_SIZE != 0) {
byte[] newBytes = new byte[bytes.length + FITS_HEADER_CARD_SIZE - bytes.length % FITS_HEADER_CARD_SIZE];
System.arraycopy(bytes, 0, newBytes, 0, bytes.length);
Arrays.fill(newBytes, bytes.length, newBytes.length, (byte) ' ');
bytes = newBytes;
}
return new BufferedDataInputStream(new ByteArrayInputStream(bytes));
}
/**
* This method is only used internally when it is sure that the creation of
* the card is granted not to throw an exception
*
* @param key
* the key for the card
* @param comment
* the comment for the card
* @param isString
* is this a string value card?
* @return the new HeaderCard
*/
protected static HeaderCard saveNewHeaderCard(String key, String comment, boolean isString) {
try {
return new HeaderCard(key, null, comment, false, isString);
} catch (HeaderCardException e) {
LOG.log(Level.SEVERE, "Impossible Exception for internal card creation:" + key, e);
throw new IllegalStateException(e);
}
}
public HeaderCard(ArrayDataInput dis) throws TruncatedFileException, IOException {
this(new HeaderCardCountingArrayDataInput(dis));
}
public HeaderCard(HeaderCardCountingArrayDataInput dis) throws TruncatedFileException, IOException {
this.key = null;
this.value = null;
this.comment = null;
this.isString = false;
String card = readOneHeaderLine(dis);
if (FitsFactory.getUseHierarch() && card.startsWith(HIERARCH_WITH_BLANK)) {
hierarchCard(card, dis);
return;
}
// extract the key
this.key = card.substring(0, MAX_KEYWORD_LENGTH).trim();
// if it is an empty key, assume the remainder of the card is a comment
if (this.key.isEmpty()) {
this.comment = card.substring(MAX_KEYWORD_LENGTH);
return;
}
// Non-key/value pair lines are treated as keyed comments
if (this.key.equals(COMMENT.key()) || this.key.equals(HISTORY.key()) || !card.startsWith("= ", MAX_KEYWORD_LENGTH)) {
this.comment = card.substring(MAX_KEYWORD_LENGTH).trim();
return;
}
extractValueCommentFromString(dis, card);
}
/**
* Create a HeaderCard from its component parts
*
* @param key
* keyword (null for a comment)
* @param value
* value (null for a comment or keyword without an '=')
* @param comment
* comment
* @exception HeaderCardException
* for any invalid keyword
*/
public HeaderCard(String key, BigDecimal value, String comment) throws HeaderCardException {
this(key, dblString(value, spaceAvailableForValue(key)), comment, false, false);
}
/**
* Create a HeaderCard from its component parts
*
* @param key
* keyword (null for a comment)
* @param value
* value (null for a comment or keyword without an '=')
* @param comment
* comment
* @exception HeaderCardException
* for any invalid keyword
*/
public HeaderCard(String key, BigInteger value, String comment) throws HeaderCardException {
this(key, dblString(new BigDecimal(value), spaceAvailableForValue(key)), comment, false, false);
}
/**
* Create a HeaderCard from its component parts
*
* @param key
* keyword (null for a comment)
* @param value
* value (null for a comment or keyword without an '=')
* @param comment
* comment
* @exception HeaderCardException
* for any invalid keyword
*/
public HeaderCard(String key, boolean value, String comment) throws HeaderCardException {
this(key, value ? "T" : "F", comment, false, false);
}
/**
* Create a HeaderCard from its component parts
*
* @param key
* keyword (null for a comment)
* @param value
* value (null for a comment or keyword without an '=')
* @param precision
* Number of decimal places (fixed format).
* @param comment
* comment
* @exception HeaderCardException
* for any invalid keyword
*/
public HeaderCard(String key, double value, int precision, String comment) throws HeaderCardException {
this(key, dblString(value, precision, spaceAvailableForValue(key)), comment, false, false);
}
/**
* Create a HeaderCard from its component parts
*
* @param key
* keyword (null for a comment)
* @param value
* value (null for a comment or keyword without an '=')
* @param comment
* comment
* @exception HeaderCardException
* for any invalid keyword
*/
public HeaderCard(String key, double value, String comment) throws HeaderCardException {
this(key, dblString(value, spaceAvailableForValue(key)), comment, false, false);
}
/**
* Create a HeaderCard from its component parts
*
* @param key
* keyword (null for a comment)
* @param value
* value (null for a comment or keyword without an '=')
* @param precision
* Number of decimal places (fixed format).
* @param comment
* comment
* @exception HeaderCardException
* for any invalid keyword
*/
public HeaderCard(String key, float value, int precision, String comment) throws HeaderCardException {
this(key, dblString(floatToBigDecimal(value), precision, spaceAvailableForValue(key)), comment, false, false);
}
/**
* Create a HeaderCard from its component parts
*
* @param key
* keyword (null for a comment)
* @param value
* value (null for a comment or keyword without an '=')
* @param comment
* comment
* @exception HeaderCardException
* for any invalid keyword
*/
public HeaderCard(String key, float value, String comment) throws HeaderCardException {
this(key, dblString(floatToBigDecimal(value), spaceAvailableForValue(key)), comment, false, false);
}
/**
* Create a HeaderCard from its component parts
*
* @param key
* keyword (null for a comment)
* @param value
* value (null for a comment or keyword without an '=')
* @param comment
* comment
* @exception HeaderCardException
* for any invalid keyword
*/
public HeaderCard(String key, int value, String comment) throws HeaderCardException {
this(key, String.valueOf(value), comment, false, false);
}
/**
* Create a HeaderCard from its component parts
*
* @param key
* keyword (null for a comment)
* @param value
* value (null for a comment or keyword without an '=')
* @param comment
* comment
* @exception HeaderCardException
* for any invalid keyword
*/
public HeaderCard(String key, long value, String comment) throws HeaderCardException {
this(key, String.valueOf(value), comment, false, false);
}
/**
* Create a comment style card. This constructor builds a card which has no
* value. This may be either a comment style card in which case the nullable
* field should be false, or a value field which has a null value, in which
* case the nullable field should be true.
*
* @param key
* The key for the comment or nullable field.
* @param comment
* The comment
* @param nullable
* Is this a nullable field or a comment-style card?
* @throws HeaderCardException
* for any invalid keyword or value
*/
public HeaderCard(String key, String comment, boolean nullable) throws HeaderCardException {
this(key, null, comment, nullable, true);
}
/**
* Create a HeaderCard from its component parts
*
* @param key
* keyword (null for a comment)
* @param value
* value (null for a comment or keyword without an '=')
* @param comment
* comment
* @exception HeaderCardException
* for any invalid keyword or value
*/
public HeaderCard(String key, String value, String comment) throws HeaderCardException {
this(key, value, comment, false, true);
}
/**
* Create a HeaderCard from its component parts
*
* @param key
* Keyword (null for a COMMENT)
* @param value
* Value
* @param comment
* Comment
* @param nullable
* Is this a nullable value card?
* @exception HeaderCardException
* for any invalid keyword or value
*/
public HeaderCard(String key, String value, String comment, boolean nullable) throws HeaderCardException {
this(key, value, comment, nullable, true);
}
/**
* Create a HeaderCard from its component parts
*
* @param key
* Keyword (null for a COMMENT)
* @param value
* Value
* @param comment
* Comment
* @param nullable
* Is this a nullable value card?
* @exception HeaderCardException
* for any invalid keyword or value
*/
private HeaderCard(String key, String value, String comment, boolean nullable, boolean isString) throws HeaderCardException {
this.isString = isString;
if (key == null && value != null) {
throw new HeaderCardException("Null keyword with non-null value");
} else if (key != null && key.length() > HeaderCard.MAX_KEYWORD_LENGTH && //
(!FitsFactory.getUseHierarch() || !key.startsWith(HIERARCH_WITH_DOT))) {
throw new HeaderCardException("Keyword too long");
}
if (value != null) {
value = value.replaceAll(" *$", "");
if (value.startsWith("'")) {
if (value.charAt(value.length() - 1) != '\'') {
throw new HeaderCardException("Missing end quote in string value");
}
value = value.substring(1, value.length() - 1).trim();
}
// Remember that quotes get doubled in the value...
if (!FitsFactory.isLongStringsEnabled()
&& value.replace("'", "''").length() > (this.isString ? HeaderCard.MAX_STRING_VALUE_LENGTH : HeaderCard.MAX_VALUE_LENGTH)) {
throw new HeaderCardException("Value too long");
}
}
this.key = key;
this.value = value;
this.comment = comment;
this.nullable = nullable;
}
/**
* @return the size of the card in blocks of 80 bytes. So normally every
* card will return 1. only long stings can return more than one.
*/
public int cardSize() {
if (this.isString && this.value != null && FitsFactory.isLongStringsEnabled()) {
int maxStringValueLength = maxStringValueLength();
String stringValue = this.value.replace("'", "''");
if (stringValue.length() > maxStringValueLength) {
// this is very bad for performance but it is to difficult to
// keep the cardSize and the toString compatible at all times
return toString().length() / FITS_HEADER_CARD_SIZE;
}
}
return 1;
}
public HeaderCard copy() throws HeaderCardException {
HeaderCard copy = new HeaderCard(this.key, null, this.comment, this.nullable, this.isString);
copy.value = this.value;
return copy;
}
/**
* @return the comment from this card
*/
public String getComment() {
return this.comment;
}
/**
* @return the keyword from this card
*/
@Override
public String getKey() {
return this.key;
}
/**
* @return the value from this card
*/
public String getValue() {
return this.value;
}
/**
* @param clazz
* the requested class of the value
* @param defaultValue
* the value if the card was not present.
* @param
* the type of the requested class
* @return the value from this card as a specific type
*/
public T getValue(Class clazz, T defaultValue) {
if (String.class.isAssignableFrom(clazz)) {
return clazz.cast(this.value);
} else if (this.value == null || this.value.isEmpty()) {
return defaultValue;
} else if (Boolean.class.isAssignableFrom(clazz)) {
return clazz.cast(getBooleanValue((Boolean) defaultValue));
}
BigDecimal parsedValue;
try {
parsedValue = new BigDecimal(this.value);
} catch (NumberFormatException e) {
return defaultValue;
}
if (Integer.class.isAssignableFrom(clazz)) {
return clazz.cast(parsedValue.intValueExact());
} else if (Long.class.isAssignableFrom(clazz)) {
return clazz.cast(parsedValue.longValueExact());
} else if (Double.class.isAssignableFrom(clazz)) {
return clazz.cast(parsedValue.doubleValue());
} else if (Float.class.isAssignableFrom(clazz)) {
return clazz.cast(parsedValue.floatValue());
} else if (BigDecimal.class.isAssignableFrom(clazz)) {
return clazz.cast(parsedValue);
} else if (BigInteger.class.isAssignableFrom(clazz)) {
return clazz.cast(parsedValue.toBigIntegerExact());
} else {
throw new IllegalArgumentException("unsupported class " + clazz);
}
}
/**
* @return Is this a key/value card?
*/
public boolean isKeyValuePair() {
return this.key != null && this.value != null;
}
/**
* @return if this card contain does a string value?
*/
public boolean isStringValue() {
return this.isString;
}
/**
* set the comment of a card.
*
* @param comment
* the comment to set.
*/
public void setComment(String comment) {
this.comment = comment;
}
/**
* Set the value for this card.
*
* @param update
* the new value to set
* @return the HeaderCard itself
*/
public HeaderCard setValue(BigDecimal update) {
this.value = dblString(update, spaceAvailableForValue(this.key));
return this;
}
/**
* Set the value for this card.
*
* @param update
* the new value to set
* @return the HeaderCard itself
*/
public HeaderCard setValue(boolean update) {
this.value = update ? "T" : "F";
return this;
}
/**
* Set the value for this card.
*
* @param update
* the new value to set
* @return the HeaderCard itself
*/
public HeaderCard setValue(double update) {
this.value = dblString(update, spaceAvailableForValue(this.key));
return this;
}
/**
* Set the value for this card.
*
* @param update
* the new value to set
* @param precision
* the number of decimal places to show
* @return the HeaderCard itself
*/
public HeaderCard setValue(double update, int precision) {
this.value = dblString(update, precision, spaceAvailableForValue(this.key));
return this;
}
/**
* Set the value for this card.
*
* @param update
* the new value to set
* @return the HeaderCard itself
*/
public HeaderCard setValue(float update) {
this.value = dblString(floatToBigDecimal(update), spaceAvailableForValue(this.key));
return this;
}
/**
* Set the value for this card.
*
* @param update
* the new value to set
* @param precision
* the number of decimal places to show
* @return the HeaderCard itself
*/
public HeaderCard setValue(float update, int precision) {
this.value = dblString(floatToBigDecimal(update), precision, spaceAvailableForValue(this.key));
return this;
}
/**
* Set the value for this card.
*
* @param update
* the new value to set
* @return the HeaderCard itself
*/
public HeaderCard setValue(int update) {
this.value = String.valueOf(update);
return this;
}
/**
* Set the value for this card.
*
* @param update
* the new value to set
* @return the HeaderCard itself
*/
public HeaderCard setValue(long update) {
this.value = String.valueOf(update);
return this;
}
/**
* Set the value for this card.
*
* @param update
* the new value to set
* @return the HeaderCard itself
*/
public HeaderCard setValue(String update) {
this.value = update;
return this;
}
/**
* Return the modulo 80 character card image, the toString tries to preserve
* as much as possible of the comment value by reducing the alignment of the
* Strings if the comment is longer and if longString is enabled the string
* can be split into one more card to have more space for the comment.
*/
@Override
public String toString() {
int alignSmallString = NORMAL_SMALL_STRING_ALIGN_POSITION;
int alignPosition = NORMAL_ALIGN_POSITION;
FitsLineAppender buf = new FitsLineAppender();
// start with the keyword, if there is one
if (this.key != null) {
if (this.key.length() > HIERARCH_WITH_BLANK_LENGTH && this.key.startsWith(HIERARCH_WITH_DOT)) {
FitsFactory.getHierarchFormater().append(this.key, buf);
alignSmallString = buf.length();
alignPosition = buf.length();
} else {
buf.append(this.key);
if (this.key.isEmpty()) {
buf.append(' ');
}
buf.appendSpacesTo(MAX_KEYWORD_LENGTH);
}
}
FitsSubString commentSubString = new FitsSubString(this.comment);
if (FITS_HEADER_CARD_SIZE - alignPosition - MAX_LONG_STRING_CONTINUE_OVERHEAD < commentSubString.length()) {
// with alignment the comment would not fit so lets make more space
alignPosition = Math.max(buf.length(), FITS_HEADER_CARD_SIZE - MAX_LONG_STRING_CONTINUE_OVERHEAD - commentSubString.length());
alignSmallString = buf.length();
}
boolean commentHandled = false;
if (this.value != null || this.nullable) {
buf.append("= ");
if (this.value != null) {
if (this.isString) {
commentHandled = stringValueToString(alignSmallString, alignPosition, buf, commentHandled);
} else {
buf.appendSpacesTo(alignPosition - this.value.length());
buf.append(this.value);
}
} else {
// Pad out a null value.
buf.appendSpacesTo(alignPosition);
}
// is there space left for a comment?
int spaceLeft = FITS_HEADER_CARD_SIZE - buf.length();
int spaceLeftInCard = spaceLeft % FITS_HEADER_CARD_SIZE;
commentSubString.getAdjustedLength(spaceLeftInCard - MAX_LONG_STRING_CONTINUE_OVERHEAD);
// if there is a comment, add a comment delimiter
if (!commentHandled && commentSubString.length() > 0) {
buf.append(" / ");
}
} else if (commentSubString.startsWith("= ")) {
buf.append(" ");
}
// finally, add any comment
if (!commentHandled && commentSubString.length() > 0) {
if (commentSubString.startsWith(" ")) {
commentSubString.skip(1);
}
// is there space left for a comment?
commentSubString.getAdjustedLength((FITS_HEADER_CARD_SIZE - buf.length()) % FITS_HEADER_CARD_SIZE);
buf.append(commentSubString);
commentSubString.rest();
if (commentSubString.length() > 0) {
LOG.log(Level.INFO, "" + this.key + " was trimmed to fit");
}
}
buf.completeLine();
return buf.toString();
}
/**
* @return the type of the value.
*/
public Class valueType() {
if (this.isString) {
return String.class;
} else if (this.value != null) {
String trimedValue = this.value.trim();
if ("T".equals(trimedValue) || "F".equals(trimedValue)) {
return Boolean.class;
} else if (HeaderCard.LONG_REGEX.matcher(trimedValue).matches()) {
return getIntegerNumberType(trimedValue);
} else if (HeaderCard.IEEE_REGEX.matcher(trimedValue).find()) {
return getDecimalNumberType(trimedValue);
}
}
return null;
}
private void extractValueCommentFromString(HeaderCardCountingArrayDataInput dis, String card) throws IOException, TruncatedFileException {
// extract the value/comment part of the string
ParsedValue parsedValue = FitsHeaderCardParser.parseCardValue(card);
if (FitsFactory.isLongStringsEnabled() && parsedValue.isString() && parsedValue.getValue().endsWith("&")) {
longStringCard(dis, parsedValue);
} else {
this.value = parsedValue.getValue();
this.isString = parsedValue.isString();
this.comment = parsedValue.getComment();
if (!this.isString && this.value.indexOf('\'') >= 0) {
throw new IllegalArgumentException("no single quotes allowed in values");
}
}
}
private Boolean getBooleanValue(Boolean defaultValue) {
if ("T".equals(this.value)) {
return Boolean.TRUE;
} else if ("F".equals(this.value)) {
return Boolean.FALSE;
}
return defaultValue;
}
/**
* Process HIERARCH style cards... HIERARCH LEV1 LEV2 ... = value / comment
* The keyword for the card will be "HIERARCH.LEV1.LEV2..." A '/' is assumed
* to start a comment.
*
* @param dis
*/
private void hierarchCard(String card, HeaderCardCountingArrayDataInput dis) throws IOException, TruncatedFileException {
this.key = FitsHeaderCardParser.parseCardKey(card);
extractValueCommentFromString(dis, card);
}
private void longStringCard(HeaderCardCountingArrayDataInput dis, ParsedValue parsedValue) throws IOException, TruncatedFileException {
// ok this is a longString now read over all continues.
StringBuilder longValue = new StringBuilder();
StringBuilder longComment = null;
ParsedValue continueCard = parsedValue;
do {
if (continueCard.getValue() != null) {
longValue.append(continueCard.getValue());
}
if (continueCard.getComment() != null) {
if (longComment == null) {
longComment = new StringBuilder();
} else {
longComment.append(' ');
}
longComment.append(continueCard.getComment());
}
continueCard = null;
if (longValue.length() > 0 && longValue.charAt(longValue.length() - 1) == '&') {
longValue.setLength(longValue.length() - 1);
dis.mark();
String card = readOneHeaderLine(dis);
if (card.startsWith(CONTINUE.key())) {
// extract the value/comment part of the string
continueCard = FitsHeaderCardParser.parseCardValue(card);
} else {
// the & was part of the string put it back.
longValue.append('&');
// ok move the input stream one card back.
dis.reset();
}
}
} while (continueCard != null);
this.comment = longComment == null ? null : longComment.toString();
this.value = longValue.toString();
this.isString = true;
}
private int maxStringValueLength() {
int maxStringValueLength = HeaderCard.MAX_STRING_VALUE_LENGTH;
if (FitsFactory.getUseHierarch() && getKey().length() > MAX_KEYWORD_LENGTH) {
maxStringValueLength -= getKey().length() - MAX_KEYWORD_LENGTH;
}
return maxStringValueLength;
}
private boolean stringValueToString(int alignSmallString, int alignPosition, FitsLineAppender buf, boolean commentHandled) {
String stringValue = this.value.replace("'", "''");
if (FitsFactory.isLongStringsEnabled() && stringValue.length() > maxStringValueLength()) {
writeLongStringValue(buf, stringValue);
commentHandled = true;
} else {
// left justify the string inside the quotes
buf.append('\'');
buf.append(stringValue);
buf.appendSpacesTo(alignSmallString);
buf.append('\'');
// Now add space to the comment area starting at column
// 30
buf.appendSpacesTo(alignPosition);
}
return commentHandled;
}
private void writeLongStringValue(FitsLineAppender buf, String stringValueString) {
FitsSubString stringValue = new FitsSubString(stringValueString);
FitsSubString commentValue = new FitsSubString(this.comment);
// We assume that we've made the test so that
// we need to write a long string.
// We also need to be careful that single quotes don't
// make the string too long and that we don't split
// in the middle of a quote.
stringValue.getAdjustedLength(FITS_HEADER_CARD_SIZE - buf.length() - MAX_LONG_STRING_CONTINUE_OVERHEAD);
// No comment here since we're using as much of the card
// as we can
buf.append('\'');
buf.append(stringValue);
buf.append("&'");
buf.completeLine();
stringValue.rest();
if (commentValue.startsWith(" ")) {
commentValue.skip(1);
}
while (stringValue.length() > 0) {
stringValue.getAdjustedLength(MAX_LONG_STRING_VALUE_LENGTH);
if (stringValue.fullLength() > MAX_LONG_STRING_VALUE_LENGTH) {
buf.append(CONTINUE_CARD_PREFIX);
buf.append(stringValue);
buf.append("&'");
stringValue.rest();
} else {
if (commentValue.length() > MAX_LONG_STRING_VALUE_WITH_COMMENT_LENGTH - stringValue.length()) {
// ok comment does not fit lets give it a little more room
stringValue.getAdjustedLength(STRING_SPLIT_POSITION_FOR_EXTRA_COMMENT_SPACE);
if (stringValue.fullLength() > stringValue.length()) {
buf.append(CONTINUE_CARD_PREFIX);
buf.append(stringValue);
buf.append("&'");
} else {
buf.append(CONTINUE_CARD_PREFIX);
buf.append(stringValue);
buf.append("'");
}
int spaceForComment = buf.spaceLeftInLine() - MAX_LONG_STRING_CONTINUE_OVERHEAD;
commentValue.getAdjustedLength(spaceForComment);
} else {
buf.append(CONTINUE_CARD_PREFIX);
buf.append(stringValue);
buf.append('\'');
}
if (commentValue.length() > 0) {
buf.append(" / ");
buf.append(commentValue);
commentValue.rest();
}
buf.completeLine();
stringValue.rest();
}
}
}
/**
* Set the key.
*/
void setKey(String newKey) {
this.key = newKey;
}
}
nom/tam/fits/BasicHDU.java 0000664 0000000 0000000 00000046137 12755570700 014345 0 ustar root root package nom.tam.fits;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import static nom.tam.fits.header.Standard.AUTHOR;
import static nom.tam.fits.header.Standard.BLANK;
import static nom.tam.fits.header.Standard.BSCALE;
import static nom.tam.fits.header.Standard.BUNIT;
import static nom.tam.fits.header.Standard.BZERO;
import static nom.tam.fits.header.Standard.DATAMAX;
import static nom.tam.fits.header.Standard.DATAMIN;
import static nom.tam.fits.header.Standard.DATE;
import static nom.tam.fits.header.Standard.DATE_OBS;
import static nom.tam.fits.header.Standard.EPOCH;
import static nom.tam.fits.header.Standard.EQUINOX;
import static nom.tam.fits.header.Standard.EXTEND;
import static nom.tam.fits.header.Standard.GCOUNT;
import static nom.tam.fits.header.Standard.GROUPS;
import static nom.tam.fits.header.Standard.INSTRUME;
import static nom.tam.fits.header.Standard.NAXIS;
import static nom.tam.fits.header.Standard.NAXISn;
import static nom.tam.fits.header.Standard.OBJECT;
import static nom.tam.fits.header.Standard.OBSERVER;
import static nom.tam.fits.header.Standard.ORIGIN;
import static nom.tam.fits.header.Standard.PCOUNT;
import static nom.tam.fits.header.Standard.REFERENC;
import static nom.tam.fits.header.Standard.TELESCOP;
import static nom.tam.util.LoggerHelper.getLogger;
import java.io.IOException;
import java.io.PrintStream;
import java.util.Date;
import java.util.logging.Level;
import java.util.logging.Logger;
import nom.tam.fits.header.IFitsHeader;
import nom.tam.fits.header.Standard;
import nom.tam.util.ArrayDataInput;
import nom.tam.util.ArrayDataOutput;
/**
* This abstract class is the parent of all HDU types. It provides basic
* functionality for an HDU.
*/
public abstract class BasicHDU implements FitsElement {
private static final int MAX_NAXIS_ALLOWED = 999;
private static final Logger LOG = getLogger(BasicHDU.class);
public static final int BITPIX_BYTE = 8;
public static final int BITPIX_SHORT = 16;
public static final int BITPIX_INT = 32;
public static final int BITPIX_LONG = 64;
public static final int BITPIX_FLOAT = -32;
public static final int BITPIX_DOUBLE = -64;
/** The associated header. */
protected Header myHeader = null;
/** The associated data unit. */
protected DataClass myData = null;
/** Is this the first HDU in a FITS file? */
protected boolean isPrimary = false;
protected BasicHDU(Header myHeader, DataClass myData) {
this.myHeader = myHeader;
this.myData = myData;
}
/**
* @return an HDU without content
*/
public static BasicHDU getDummyHDU() {
try {
// Update suggested by Laurent Bourges
ImageData img = new ImageData((Object) null);
return FitsFactory.hduFactory(ImageHDU.manufactureHeader(img), img);
} catch (FitsException e) {
LOG.log(Level.SEVERE, "Impossible exception in getDummyHDU", e);
return null;
}
}
/**
* Check that this is a valid header for the HDU. This method is static but
* should be implemented by all subclasses. TODO: refactor this to be in a
* meta object so it can inherit normally also see {@link #isData(Object)}
*
* @param header
* to validate.
* @return true if this is a valid header.
*/
public static boolean isHeader(Header header) {
return false;
}
/**
* @return if this object can be described as a FITS image. This method is
* static but should be implemented by all subclasses. TODO:
* refactor this to be in a meta object so it can inherit normally
* also see {@link #isHeader(Header)}
* @param o
* The Object being tested.
*/
public static boolean isData(Object o) {
return false;
}
/**
* Safely replace a card in the header, knowing that no exception will
* occur. Only for internal use!
*
* @param key
* the key of the card
* @param isString
* is the value a String
* @param value
* the String representation of the value
*/
protected void saveReplaceCard(String key, boolean isString, String value) {
HeaderCard card = HeaderCard.saveNewHeaderCard(key, null, isString);
card.setValue(value);
this.myHeader.deleteKey(card.getKey());
this.myHeader.addLine(card);
}
public void addValue(IFitsHeader key, boolean val) throws HeaderCardException {
this.myHeader.addValue(key.key(), val, key.comment());
}
public void addValue(IFitsHeader key, double val) throws HeaderCardException {
this.myHeader.addValue(key.key(), val, key.comment());
}
public void addValue(IFitsHeader key, int val) throws HeaderCardException {
this.myHeader.addValue(key.key(), val, key.comment());
}
public void addValue(IFitsHeader key, String val) throws HeaderCardException {
this.myHeader.addValue(key.key(), val, key.comment());
}
/**
* Add information to the header.
*
* @param key
* key to add to the header
* @param val
* value for the key to add
* @param comment
* comment for the key/value pair
* @throws HeaderCardException
* if the card does not follow the specification
*/
public void addValue(String key, boolean val, String comment) throws HeaderCardException {
this.myHeader.addValue(key, val, comment);
}
public void addValue(String key, double val, String comment) throws HeaderCardException {
this.myHeader.addValue(key, val, comment);
}
public void addValue(String key, int val, String comment) throws HeaderCardException {
this.myHeader.addValue(key, val, comment);
}
public void addValue(String key, String val, String comment) throws HeaderCardException {
this.myHeader.addValue(key, val, comment);
}
/**
* @return Indicate whether HDU can be primary HDU. This method must be
* overriden in HDU types which can appear at the beginning of a
* FITS file.
*/
boolean canBePrimary() {
return false;
}
/**
* Return the name of the person who compiled the information in the data
* associated with this header.
*
* @return either null or a String object
*/
public String getAuthor() {
return getTrimmedString(AUTHOR);
}
/**
* In FITS files the index represented by NAXIS1 is the index that changes
* most rapidly. This reflects the behavior of Fortran where there are true
* multidimensional arrays. In Java in a multidimensional array is an array
* of arrays and the first index is the index that changes slowest. So at
* some point a client of the library is going to have to invert the order.
* E.g., if I have a FITS file will
*
*
* BITPIX=16
* NAXIS1=10
* NAXIS2=20
* NAXIS3=30
*
*
* this will be read into a Java array short[30][20][10] so it makes sense
* to me at least that the returned dimensions are 30,20,10
*
* @return the dimensions of the axis.
* @throws FitsException
* if the axis are configured wrong.
*/
public int[] getAxes() throws FitsException {
int nAxis = this.myHeader.getIntValue(NAXIS, 0);
if (nAxis < 0) {
throw new FitsException("Negative NAXIS value " + nAxis);
}
if (nAxis > MAX_NAXIS_ALLOWED) {
throw new FitsException("NAXIS value " + nAxis + " too large");
}
if (nAxis == 0) {
return null;
}
int[] axes = new int[nAxis];
for (int i = 1; i <= nAxis; i++) {
axes[nAxis - i] = this.myHeader.getIntValue(NAXISn.n(i), 0);
}
return axes;
}
public int getBitPix() throws FitsException {
int bitpix = this.myHeader.getIntValue(Standard.BITPIX, -1);
switch (bitpix) {
case BITPIX_BYTE:
case BITPIX_SHORT:
case BITPIX_INT:
case BITPIX_LONG:
case BITPIX_FLOAT:
case BITPIX_DOUBLE:
break;
default:
throw new FitsException("Unknown BITPIX type " + bitpix);
}
return bitpix;
}
public long getBlankValue() throws FitsException {
if (!this.myHeader.containsKey(BLANK.key())) {
throw new FitsException("BLANK undefined");
}
return this.myHeader.getLongValue(BLANK);
}
public double getBScale() {
return this.myHeader.getDoubleValue(BSCALE, 1.0);
}
public String getBUnit() {
return getTrimmedString(BUNIT);
}
public double getBZero() {
return this.myHeader.getDoubleValue(BZERO, 0.0);
}
/**
* Get the FITS file creation date as a Date object.
*
* @return either null or a Date object
*/
public Date getCreationDate() {
try {
return new FitsDate(this.myHeader.getStringValue(DATE)).toDate();
} catch (FitsException e) {
LOG.log(Level.SEVERE, "Unable to convert string to FITS date", e);
return null;
}
}
/**
* @return the associated Data object
*/
public DataClass getData() {
return this.myData;
}
/**
* Get the equinox in years for the celestial coordinate system in which
* positions given in either the header or data are expressed.
*
* @return either null or a String object
* @deprecated use {@link #getEquinox()} instead
*/
@Deprecated
public double getEpoch() {
return this.myHeader.getDoubleValue(EPOCH, -1.0);
}
/**
* Get the equinox in years for the celestial coordinate system in which
* positions given in either the header or data are expressed.
*
* @return either null or a String object
*/
public double getEquinox() {
return this.myHeader.getDoubleValue(EQUINOX, -1.0);
}
/** Get the starting offset of the HDU */
@Override
public long getFileOffset() {
return this.myHeader.getFileOffset();
}
public int getGroupCount() {
return this.myHeader.getIntValue(GCOUNT, 1);
}
/**
* @return the associated header
*/
public Header getHeader() {
return this.myHeader;
}
/**
* get a builder for filling the header cards using the builder pattern.
*
* @param key
* the key for the first card.
* @return the builder for header cards.
*/
public HeaderCardBuilder card(IFitsHeader key) {
return this.myHeader.card(key);
}
/**
* Get the name of the instrument which was used to acquire the data in this
* FITS file.
*
* @return either null or a String object
*/
public String getInstrument() {
return getTrimmedString(INSTRUME);
}
/**
* @return the non-FITS data object
*/
public Object getKernel() {
try {
return this.myData.getKernel();
} catch (FitsException e) {
LOG.log(Level.SEVERE, "Unable to get kernel data", e);
return null;
}
}
/**
* Return the minimum valid value in the array.
*
* @return minimum value.
*/
public double getMaximumValue() {
return this.myHeader.getDoubleValue(DATAMAX);
}
/**
* Return the minimum valid value in the array.
*
* @return minimum value.
*/
public double getMinimumValue() {
return this.myHeader.getDoubleValue(DATAMIN);
}
/**
* Get the name of the observed object in this FITS file.
*
* @return either null or a String object
*/
public String getObject() {
return getTrimmedString(OBJECT);
}
/**
* Get the FITS file observation date as a Date object.
*
* @return either null or a Date object
*/
public Date getObservationDate() {
try {
return new FitsDate(this.myHeader.getStringValue(DATE_OBS)).toDate();
} catch (FitsException e) {
LOG.log(Level.SEVERE, "Unable to convert string to FITS observation date", e);
return null;
}
}
/**
* Get the name of the person who acquired the data in this FITS file.
*
* @return either null or a String object
*/
public String getObserver() {
return getTrimmedString(OBSERVER);
}
/**
* Get the name of the organization which created this FITS file.
*
* @return either null or a String object
*/
public String getOrigin() {
return getTrimmedString(ORIGIN);
}
public int getParameterCount() {
return this.myHeader.getIntValue(PCOUNT, 0);
}
/**
* Return the citation of a reference where the data associated with this
* header are published.
*
* @return either null or a String object
*/
public String getReference() {
return getTrimmedString(REFERENC);
}
@Override
public long getSize() {
int size = 0;
if (this.myHeader != null) {
size += this.myHeader.getSize();
}
if (this.myData != null) {
size += this.myData.getSize();
}
return size;
}
/**
* Get the name of the telescope which was used to acquire the data in this
* FITS file.
*
* @return either null or a String object
*/
public String getTelescope() {
return getTrimmedString(TELESCOP);
}
/**
* Get the String value associated with keyword.
*
* @param keyword
* the FITS keyword
* @return either null or a String with leading/trailing blanks
* stripped.
*/
public String getTrimmedString(String keyword) {
String s = this.myHeader.getStringValue(keyword);
if (s != null) {
s = s.trim();
}
return s;
}
/**
* Get the String value associated with keyword.
*
* @param keyword
* the FITS keyword
* @return either null or a String with leading/trailing blanks
* stripped.
*/
public String getTrimmedString(IFitsHeader keyword) {
String s = this.myHeader.getStringValue(keyword);
if (s != null) {
s = s.trim();
}
return s;
}
/**
* Print out some information about this HDU.
*
* @param stream
* the printstream to write the info on
*/
public abstract void info(PrintStream stream);
@SuppressWarnings("unchecked")
@Override
public void read(ArrayDataInput stream) throws FitsException, IOException {
this.myHeader = Header.readHeader(stream);
this.myData = (DataClass) this.myHeader.makeData();
this.myData.read(stream);
}
@Override
public boolean reset() {
return this.myHeader.reset();
}
@Override
public void rewrite() throws FitsException, IOException {
if (rewriteable()) {
this.myHeader.rewrite();
this.myData.rewrite();
} else {
throw new FitsException("Invalid attempt to rewrite HDU");
}
}
@Override
public boolean rewriteable() {
return this.myHeader.rewriteable() && this.myData.rewriteable();
}
/**
* Indicate that an HDU is the first element of a FITS file.
*
* @param newPrimary
* value to set
* @throws FitsException
* if the operation failed
*/
void setPrimaryHDU(boolean newPrimary) throws FitsException {
if (newPrimary && !canBePrimary()) {
throw new FitsException("Invalid attempt to make HDU of type:" + this.getClass().getName() + " primary.");
} else {
this.isPrimary = newPrimary;
}
// Some FITS readers don't like the PCOUNT and GCOUNT keywords
// in a primary array or they EXTEND keyword in extensions.
if (this.isPrimary && !this.myHeader.getBooleanValue(GROUPS, false)) {
this.myHeader.deleteKey(PCOUNT);
this.myHeader.deleteKey(GCOUNT);
}
if (this.isPrimary) {
HeaderCard card = this.myHeader.findCard(EXTEND);
if (card == null) {
getAxes(); // Leaves the iterator pointing to the last NAXISn
// card.
this.myHeader.nextCard();
this.myHeader.addValue(EXTEND, true);
}
}
if (!this.isPrimary) {
this.myHeader.iterator();
int pcount = this.myHeader.getIntValue(PCOUNT, 0);
int gcount = this.myHeader.getIntValue(GCOUNT, 1);
int naxis = this.myHeader.getIntValue(NAXIS, 0);
this.myHeader.deleteKey(EXTEND);
HeaderCard pcard = this.myHeader.findCard(PCOUNT);
HeaderCard gcard = this.myHeader.findCard(GCOUNT);
this.myHeader.getCard(2 + naxis);
if (pcard == null) {
this.myHeader.addValue(PCOUNT, pcount);
}
if (gcard == null) {
this.myHeader.addValue(GCOUNT, gcount);
}
this.myHeader.iterator();
}
}
@Override
public void write(ArrayDataOutput stream) throws FitsException {
if (this.myHeader != null) {
this.myHeader.write(stream);
}
if (this.myData != null) {
this.myData.write(stream);
}
try {
stream.flush();
} catch (IOException e) {
throw new FitsException("Error flushing at end of HDU", e);
}
}
}
nom/tam/fits/FitsElement.java 0000664 0000000 0000000 00000006402 12755570700 015171 0 ustar root root package nom.tam.fits;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.io.IOException;
import nom.tam.util.ArrayDataInput;
import nom.tam.util.ArrayDataOutput;
/**
* This interface allows to easily perform basic I/O operations on a FITS
* element.
*/
public interface FitsElement {
/**
* @return the byte at which this element begins. This is only available if
* the data is originally read from a random access medium.
*/
long getFileOffset();
/**
* @return The size of this element in bytes
*/
long getSize();
/**
* Read a data array into the current object and if needed position to the
* beginning of the next FITS block.
*
* @param in
* The input data stream
* @throws FitsException
* if the read was unsuccessful.
* @throws IOException
* if the read was unsuccessful.
*/
void read(ArrayDataInput in) throws FitsException, IOException;
/**
* Reset the input stream to point to the beginning of this element
*
* @return True if the reset succeeded.
*/
boolean reset();
/**
* Rewrite the contents of the element in place. The data must have been
* originally read from a random access device, and the size of the element
* may not have changed.
*
* @throws FitsException
* if the rewrite was unsuccessful.
* @throws IOException
* if the rewrite was unsuccessful.
*/
void rewrite() throws FitsException, IOException;
/**
* @return true if this element can be rewritten?
*/
boolean rewriteable();
/**
* Write the contents of the element to a data sink.
*
* @param out
* The data sink.
* @throws FitsException
* if the write was unsuccessful.
* @throws IOException
* if the write was unsuccessful.
*/
void write(ArrayDataOutput out) throws FitsException, IOException;
}
nom/tam/fits/HeaderCommentsMap.java 0000664 0000000 0000000 00000006206 12755570700 016310 0 ustar root root package nom.tam.fits;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import nom.tam.fits.header.Standard;
/**
* This class provides a modifiable map in which the comment fields for FITS
* header keywords produced by this library are set. The map is a simple String
* -> String map where the key Strings are normally class:keyword:id where
* class is the class name where the keyword is set, keyword is the keyword set
* and id is an integer used to distinguish multiple instances. Most users need
* not worry about this class, but users who wish to customize the appearance of
* FITS files may update the map. The code itself is likely to be needed to
* understand which values in the map must be modified.
*/
@Deprecated
public final class HeaderCommentsMap {
@Deprecated
public static void deleteComment(String key) {
key = simplyfyKey(key);
for (Standard value : Standard.values()) {
value.setCommentByKey(key, "");
}
}
@Deprecated
public static String getComment(String key) {
key = simplyfyKey(key);
for (Standard value : Standard.values()) {
String comment = value.getCommentByKey(key);
if (comment != null) {
return comment;
}
}
return null;
}
private static String simplyfyKey(String key) {
int firstDbPoint = key.indexOf(':');
if (firstDbPoint > 0) {
int secondDoublePoint = key.indexOf(':', firstDbPoint + 1);
if (secondDoublePoint > 0) {
return key.substring(0, secondDoublePoint);
}
}
return key;
}
@Deprecated
public static void updateComment(String key, String comment) {
key = simplyfyKey(key);
for (Standard value : Standard.values()) {
value.setCommentByKey(key, comment);
}
}
private HeaderCommentsMap() {
}
}
nom/tam/fits/header/ 0000775 0000000 0000000 00000000000 12755570710 013336 5 ustar root root nom/tam/fits/header/ObservationDurationDescription.java 0000664 0000000 0000000 00000016330 12755570700 022410 0 ustar root root package nom.tam.fits.header;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
/**
* This data dictionary contains FITS keywords that have been widely used within
* the astronomical community. It is recommended that these keywords only be
* used as defined here. These are the Keywords that describe the observation.
*
*
* @see http://heasarc.gsfc.nasa.gov/docs/fcg/common_dict.html
*
*
* @author Richard van Nieuwenhoven
*/
public enum ObservationDurationDescription implements IFitsHeader {
/**
* The value field shall contain a character string that gives the date on
* which the observation ended. This keyword has the same format, and is
* used in conjunction with, the standard DATA-OBS keyword that gives the
* starting date of the observation. These 2 keywords may give either the
* calendar date using the 'yyyy-mm-dd' format, or may give the full date
* and time using the 'yyyy-mm-ddThh:mm:ss.sss' format.
*/
DATE_END("DATE-END", SOURCE.HEASARC, HDU.ANY, VALUE.STRING, "date of the end of observation"),
/**
* The value field shall contain a floating point number giving the
* difference between the stop and start times of the observation in units
* of seconds. This keyword is synonymous with the TELAPSE keyword.
*/
ELAPTIME(SOURCE.UCOLICK, HDU.ANY, VALUE.REAL, "elapsed time of the observation"),
/**
* The value field shall contain a floating point number giving the exposure
* time of the observation in units of seconds. The exact definition of
* 'exposure time' is mission dependent and may, for example, include
* corrections for shutter open and close duration, detector dead time,
* vignetting, or other effects. This keyword is synonymous with the EXPTIME
* keyword.
*/
EXPOSURE(SOURCE.HEASARC, HDU.ANY, VALUE.REAL, "exposure time"),
/**
* The value field shall contain a floating point number giving the exposure
* time of the observation in units of seconds. The exact definition of
* 'exposure time' is mission dependent and may, for example, include
* corrections for shutter open and close duration, detector dead time,
* vignetting, or other effects. This keyword is synonymous with the
* EXPOSURE keyword.
*/
EXPTIME(SOURCE.NOAO, HDU.ANY, VALUE.REAL, "exposure time"),
/**
* The value field shall contain a floating point number giving the total
* integrated exposure time in units of seconds corrected for detector 'dead
* time' effects which reduce the net efficiency of the detector. The ratio
* of LIVETIME/ONTIME gives the mean dead time correction during the
* observation, which lies in the range 0.0 to 1.0.
*/
LIVETIME(SOURCE.HEASARC, HDU.ANY, VALUE.REAL, "exposure time after deadtime correction"),
/**
* The value field shall contain a floating point number giving the total
* integrated exposure time of the observation in units of seconds. ONTIME
* may be less than TELAPSE if there were intevals during the observation in
* which the target was not observed (e.g., the shutter was closed, or the
* detector power was turned off).
*/
ONTIME(SOURCE.HEASARC, HDU.ANY, VALUE.REAL, "integration time during the observation"),
/**
* The value field shall contain a floating point number giving the
* difference between the stop and start times of the observation in units
* of seconds. This keyword is synonymous with the ELAPTIME keyword.
*/
TELAPSE(SOURCE.HEASARC, HDU.ANY, VALUE.REAL, "elapsed time of the observation"),
/**
* The value field shall contain a character string that gives the time at
* which the observation ended. This keyword is used in conjunction with the
* DATE-END keyword to give the ending time of the observation; the DATE-END
* keyword gives the ending calendar date, with format 'yyyy-mm-dd', and
* TIME-END gives the time within that day using the format
* 'hh:mm:ss.sss...'. This keyword should not be used if the time is
* included directly as part of the DATE-END keyword value with the format
* 'yyyy-mm-ddThh:mm:ss.sss'.
*/
TIME_END("TIME-END", SOURCE.HEASARC, HDU.ANY, VALUE.STRING, "time at the end of the observation"),
/**
* The value field shall contain a character string that gives the time at
* which the observation started. This keyword is used in conjunction with
* the standard DATE-OBS keyword to give the starting time of the
* observation; the DATE-OBS keyword gives the starting calendar date, with
* format 'yyyy-mm-dd', and TIME-OBS gives the time within that day using
* the format 'hh:mm:ss.sss...'. This keyword should not be used if the time
* is included directly as part of the DATE-OBS keyword value with the
* format 'yyyy-mm-ddThh:mm:ss.sss'.
*/
TIME_OBS("TIME-OBS", SOURCE.HEASARC, HDU.ANY, VALUE.STRING, "time at the start of the observation");
@SuppressWarnings("CPD-START")
private final IFitsHeader key;
ObservationDurationDescription(SOURCE status, HDU hdu, VALUE valueType, String comment) {
this.key = new FitsHeaderImpl(name(), status, hdu, valueType, comment);
}
ObservationDurationDescription(String key, SOURCE status, HDU hdu, VALUE valueType, String comment) {
this.key = new FitsHeaderImpl(key == null ? name() : key, status, hdu, valueType, comment);
}
@Override
public String comment() {
return this.key.comment();
}
@Override
public HDU hdu() {
return this.key.hdu();
}
@Override
public String key() {
return this.key.key();
}
@Override
public IFitsHeader n(int... number) {
return this.key.n(number);
}
@Override
public SOURCE status() {
return this.key.status();
}
@Override
@SuppressWarnings("CPD-END")
public VALUE valueType() {
return this.key.valueType();
}
}
nom/tam/fits/header/InstrumentDescription.java 0000664 0000000 0000000 00000014337 12755570700 020564 0 ustar root root package nom.tam.fits.header;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
/**
* This data dictionary contains FITS keywords that have been widely used within
* the astronomical community. It is recommended that these keywords only be
* used as defined here. These are the Keywords that describe the instrument
* that took the data.
*
*
* @see http://heasarc.gsfc.nasa.gov/docs/fcg/common_dict.html
*
*
* @author Richard van Nieuwenhoven
*/
public enum InstrumentDescription implements IFitsHeader {
/**
* The value field shall contain a character string which gives the name of
* the instrumental aperture though which the observation was made. This
* keyword is typically used in instruments which have a selection of
* apertures which restrict the field of view of the detector.
*/
APERTURE(SOURCE.UNKNOWN, HDU.ANY, VALUE.STRING, "name of field of view aperture"),
/**
* The value field shall contain a character string which identifies the
* configuration or mode of the pre-processing software that operated on the
* raw instrumental data to generate the data that is recorded in the FITS
* file. Example: some X-ray satellite data may be recorded in 'BRIGHT',
* 'FAINT', or 'FAST' data mode.
*/
DATAMODE(SOURCE.HEASARC, HDU.ANY, VALUE.STRING, "pre-processor data mode"),
/**
* The value field shall contain a character string giving the name of the
* detector within the instrument that was used to make the observation.
* Example: 'CCD1'
*/
DETNAM(SOURCE.HEASARC, HDU.ANY, VALUE.STRING, "name of the detector used to make the observation"),
/**
* The value field shall contain a character string which gives the name of
* the filter that was used during the observation to select or modify the
* radiation that was transmitted to the detector. More than 1 filter may be
* listed by using the FILTERn indexed keyword. The value 'none' or 'NONE'
* indicates that no filter was used.
*/
FILTER(SOURCE.HEASARC, HDU.ANY, VALUE.STRING, "name of filter used during the observation"),
/**
* The value field of this indexed keyword shall contain a character string
* which gives the name of one of multiple filters that were used during the
* observation to select or modify the radiation that was transmitted to the
* detector. The value 'none' or 'NONE' indicates that no filter was used.
*/
FILTERn(SOURCE.HEASARC, HDU.ANY, VALUE.STRING, "name of filters used during the observation"),
/**
* The value field shall contain a character string which gives the name of
* the defraction grating that was used during the observation. More than 1
* grating may be listed by using the GRATINGn indexed keyword. The value
* 'none' or 'NONE' indicates that no grating was used.
*/
GRATING(SOURCE.HEASARC, HDU.ANY, VALUE.STRING, "name of the grating used during the observation."),
/**
* The value field of this indexed keyword shall contain a character string
* which gives the name of one of multiple defraction gratings that were
* used during the observation. The value 'none' or 'NONE' indicates that no
* grating was used.
*/
GRATINGn(SOURCE.HEASARC, HDU.ANY, VALUE.STRING, "name of gratings used during the observation."),
/**
* The value field shall contain a character string which gives the
* observing mode of the observation. This is used in cases where the
* instrument or detector can be configured to operate in different modes
* which significantly affect the resulting data. Examples: 'SLEW',
* 'RASTER', or 'POINTING'
*/
OBS_MODE(SOURCE.HEASARC, HDU.ANY, VALUE.STRING, "instrumental mode of the observation"),
/**
* The value field shall contain an integer giving the data value at which
* the detector becomes saturated. This keyword value may differ from the
* maximum value implied by the BITPIX in that more bits may be allocated in
* the FITS pixel values than the detector can accommodate.
*/
SATURATE(SOURCE.STScI, HDU.ANY, VALUE.INTEGER, "Data value at which saturation occurs");
@SuppressWarnings("CPD-START")
private final IFitsHeader key;
InstrumentDescription(IFitsHeader.SOURCE status, HDU hdu, VALUE valueType, String comment) {
this.key = new FitsHeaderImpl(name(), status, hdu, valueType, comment);
}
@Override
public String comment() {
return this.key.comment();
}
@Override
public HDU hdu() {
return this.key.hdu();
}
@Override
public String key() {
return this.key.key();
}
@Override
public IFitsHeader n(int... number) {
return this.key.n(number);
}
@Override
public SOURCE status() {
return this.key.status();
}
@Override
@SuppressWarnings("CPD-END")
public VALUE valueType() {
return this.key.valueType();
}
}
nom/tam/fits/header/package-info.java 0000664 0000000 0000000 00000011066 12755570700 016530 0 ustar root root /**
*
* There many many sources of FITS keywords. In addition to the standards
* documents many organisations (or groups of organisations) have defined their
* own sets of keywords. This results in many different dictionaries with partly
* overlapping definitions. To help the "normal" user of FITS files with these
* we started to collect the standards and will try to include them in this
* library to ease the use of the "right" keyword.
*
*
* These dictionaries are organized in a hierarchical form, that means every
* dictionary extends the list of keywords of another dictionary. The root of
* this tree of dictionaries is the dictionary used in the standard text itself.
* Under that is a dictionary that resulted from different libraries that used
* the same keywords, these are collected in a dictionary with commonly used
* keywords.
*
*
* These enumerations of keywords (dictionaries) can be found in and under the
* packages:
*
* {@link nom.tam.fits.header} {@link nom.tam.fits.header.extra}
*
* Currently we include:
*
*
* Standard
* source: [http://heasarc.gsfc.nasa.gov/docs/fcg/standard_dict.html](http://heasarc.gsfc.nasa.gov/docs/fcg/standard_dict.html) |
* Common standard
* inherits from Standard
* source: [http://heasarc.gsfc.nasa.gov/docs/fcg/common_dict.html](http://heasarc.gsfc.nasa.gov/docs/fcg/common_dict.html) |
* NOAO
* inherits from Common standard
* source: [http://iraf.noao.edu/iraf/web/projects/ccdmosaic/imagedef/fitsdic.html](http://iraf.noao.edu/iraf/web/projects/ccdmosaic/imagedef/fitsdic.html)
* SBFits
* inherits from Common standard
* source: [http://archive.sbig.com/pdffiles/SBFITSEXT_1r0.pdf](http://archive.sbig.com/pdffiles/SBFITSEXT_1r0.pdf)
* MaxImDL
* inherits from SBFits
* source: [http://www.cyanogen.com/help/maximdl/FITS_File_Header_Definitions.htm](http://www.cyanogen.com/help/maximdl/FITS_File_Header_Definitions.htm)
* CXCStclShared
* inherits from Common standard
* source: we found these duplicated
* CXC
* inherits from CXCStclShared
* source: [http://cxc.harvard.edu/contrib/arots/fits/content.txt](http://cxc.harvard.edu/contrib/arots/fits/content.txt)
* STScI
* inherits from CXCStclShared
* source: [http://tucana.noao.edu/ADASS/adass_proc/adass_95/zaraten/zaraten.html](http://tucana.noao.edu/ADASS/adass_proc/adass_95/zaraten/zaraten.html) |
*
*
*
* All duplicates where eliminated from enumerations including the enumerations
* that where already defined in one of the "parent" standards. So always use a
* keyword of one of the higher level standards when possible.
*
*
* Furthermore there are synonym keywords inside and over dictionaries, These we
* also started to collect in the Synonyms class in the header package. So you
* can easily find the primary keyword to use instead of the synonym.
*
*
* All these enums have no real effect for now in the library apart from the
* fact that you can now make compiler checked references to keywords (No more
* pruney String references). Future versions of the library will try to
* validate against them and warn you if you appear to be using a keyword
* inapprpopriately (in the wrong HDU, wrong type, etc) deprecated keyword.
*
*/
package nom.tam.fits.header;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
nom/tam/fits/header/DataDescription.java 0000664 0000000 0000000 00000030073 12755570700 017260 0 ustar root root package nom.tam.fits.header;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
/**
* This data dictionary contains FITS keywords that have been widely used within
* the astronomical community. It is recommended that these keywords only be
* used as defined here. These are the keywords that describe the data or the
* FITS file itself
*
*
* @see http://heasarc.gsfc.nasa.gov/docs/fcg/common_dict.html
*
*
* @author Richard van Nieuwenhoven
*/
public enum DataDescription implements IFitsHeader {
/**
* The value field shall contain a character string that uniquely defines
* the configuration state, or version, of the the software processing
* system that generated the data contained in the HDU. This keyword differs
* from the CREATOR keyword in that it give the name and version of the
* overall processing system and not just the name and version of a single
* program.
*/
CONFIGUR(SOURCE.INTEGRAL, HDU.ANY, VALUE.STRING, "software configuration used to process the data"),
/**
* The value field shall contain a character string giving the name, and
* optionally, the version of the program that originally created the
* current FITS HDU. This keyword is synonymous with the PROGRAM keyword.
* Example: 'TASKNAME V1.2.3'
*/
CREATOR(SOURCE.HEASARC, HDU.ANY, VALUE.STRING, "the name of the software task that created the file"),
/**
* The value field shall contain a character string giving the the host file
* name used to record the original data.
*/
FILENAME(SOURCE.NOAO, HDU.ANY, VALUE.STRING, "name of the file "),
/**
* The value field shall contain a character string giving the file type
* suffix of the host file name. The full file name typically consists of
* the root name (see ROOTNAME) followed by a file type suffix, separated by
* the period ('.') character.
*/
FILETYPE(SOURCE.UNKNOWN, HDU.ANY, VALUE.STRING, "type of file"),
/**
* The value fields of this hierarchical set of indexed keywords shall
* contain character strings that classify the type of data contained in the
* HDU. The HDUCLAS1 keyword gives the highest, most general data
* classification, and the HDUCLAS2 and higher keywords provide
* progressively more detailed subclassifications of the data.
*/
HDUCLASn(SOURCE.HEASARC, HDU.ANY, VALUE.STRING, "hierarchical classification of the data"),
/**
* The value field shall contain a character string that identifies the
* domain to which the associated HDUCLASn keywords apply. This keyword
* typically identifies the institution or project that has defined the
* allowed set of values for the associated hierarchical HDUCLASn keywords.
*/
HDUCLASS(SOURCE.HEASARC, HDU.ANY, VALUE.STRING, "general identifier for the classification of the data"),
/**
* The value field shall contain a character string that gives a reference
* to a document that describes the allowed values that may be assigned to
* the HDUCLASn data classification keywords.
*/
HDUDOC(SOURCE.HEASARC, HDU.ANY, VALUE.STRING, "reference to document describing the data format"),
/**
* This keyword is synonymous to the standard EXTLEVEL keyword except that
* it may also be used in the primary key. It is recommended that the
* HDULEVEL and EXTLEVEL keywords should not both be given in the same HDU
* key, but if they are, then the HDULEVEL keyword will have precedence.
*/
HDULEVEL(SOURCE.UNKNOWN, HDU.ANY, VALUE.INTEGER, "hierarchical level of the HDU"),
/**
* This keyword is synonymous to the standard EXTNAME keyword except that it
* may also be used in the primary key. It is recommended that the HDUNAME
* and EXTNAME keywords should not both be given in the same HDU key, but if
* they are, then the HDUNAME keyword will have precedence.
*/
HDUNAME(SOURCE.UNKNOWN, HDU.ANY, VALUE.STRING, "descriptive name of the HDU"),
/**
* This keyword is synonymous to the standard EXTVER keyword except that it
* may also be used in the primary key. It is recommended that the HDUVER
* and EXTVER keywords should not both be given in the same HDU key, but if
* they are, then the HDUVER keyword will have precedence.
*/
HDUVER(SOURCE.UNKNOWN, HDU.ANY, VALUE.INTEGER, "version number of the HDU"),
/**
* The value field shall contain a character string that gives the specific
* version of the document referenced by HDUDOC.
*/
HDUVERS(SOURCE.HEASARC, HDU.ANY, VALUE.STRING, "specific version of the document referenced by HDUDOC"),
/**
* The value field shall contain an integer giving the number of standard
* extensions contained in the FITS file. This keyword may only be used in
* the primary array key.
*/
NEXTEND(SOURCE.STScI, HDU.PRIMARY, VALUE.INTEGER, "Number of standard extensions"),
/**
* The value field shall contain a character string giving the name, and
* optionally, the version of the program that originally created the
* current FITS HDU. This keyword is synonymous with the CREATOR keyword.
* Example: 'TASKNAME V1.2.3'
*/
PROGRAM(SOURCE.UCOLICK, HDU.ANY, VALUE.STRING, "the name of the software task that created the file"),
/**
* The value field shall contain a character string giving the root of the
* host file name. The full file name typically consists of the root name
* followed by a file type suffix (see FILETYPE), separated by the period
* ('.') character.
*/
ROOTNAME(SOURCE.UNKNOWN, HDU.ANY, VALUE.STRING, "rootname of the file"),
/**
* The value field of this indexed keyword shall contain a floating point
* number specifying the suggested bin size when producing a histogram of
* the values in column n. This keyword is typically used in conjunction the
* TLMINn and TLMAXn keywords when constructing a histogram of the values in
* column n, such that the histogram ranges from TLMINn to TLMAXn with the
* histogram bin size given by TDBINn. This keyword may only be used in
* 'TABLE' or 'BINTABLE' extensions.
*/
TDBINn(SOURCE.CXC, HDU.TABLE, VALUE.REAL, "default histogram bin size for the column"),
/**
* The value field of this indexed keyword shall contain a floating point
* number specifying the maximum valid physical value represented in column
* n of the table, exclusive of any special values. This keyword may only be
* used in 'TABLE' or 'BINTABLE' extensions and is analogous to the DATAMAX
* keyword used for FITS images.
*/
TDMAXn(SOURCE.HEASARC, HDU.TABLE, VALUE.REAL, "maximum physical value in the column"),
/**
* The value field of this indexed keyword shall contain a floating point
* number specifying the minimum valid physical value represented in column
* n of the table, exclusive of any special values. This keyword may only be
* used in 'TABLE' or 'BINTABLE' extensions and is analogous to the DATAMIN
* keyword used for FITS images.
*/
TDMINn(SOURCE.HEASARC, HDU.TABLE, VALUE.REAL, "minimum physical value in the column"),
/**
* The value field shall contain a character string giving a title that is
* suitable for display purposes, e.g., for annotation on images or plots of
* the data contained in the HDU.
*/
TITLE(SOURCE.ROSAT, HDU.ANY, VALUE.STRING, "title for the observation or data"),
/**
* The value field of this indexed keyword shall contain a floating point
* number specifying the upper bound of the legal range of physical values
* that may be represented in column n of the table. The column may contain
* values that are greater than this legal maximum value but the
* interpretation of such values is not defined here. The value of this
* keyword is typically used as the maxinum value when constructing a
* histogram of the values in the column. This keyword may only be used in
* 'TABLE' or 'BINTABLE' extensions.
*/
TLMAXn(SOURCE.HEASARC, HDU.TABLE, VALUE.REAL, "maximum legal value in the column"),
/**
* The value field of this indexed keyword shall contain a floating point
* number specifying the lower bound of the legal range of physical values
* that may be represented in column n of the table. The column may contain
* values that are less than this legal minimum value but the interpretation
* of such values is not defined here. The value of this keyword is
* typically used as the mininum value when constructing a histogram of the
* values in the column. This keyword may only be used in 'TABLE' or
* 'BINTABLE' extensions.
*/
TLMINn(SOURCE.HEASARC, HDU.TABLE, VALUE.REAL, "minimum legal value in the column"),
/**
* The value field shall contain a character string that defines the order
* in which the rows in the current FITS ASCII or binary table extension
* have been sorted. The character string lists the name (as given by the
* TTYPEn keyword) of the primary sort column, optionally followed by the
* names of any secondary sort column(s). The presence of this keyword
* indicates that the rows in the table have been sorted first by the values
* in the primary sort column; any rows that have the same value in the
* primary column have been further sorted by the values in the secondary
* sort column and so on for all the specified columns. If more than one
* column is specified by TSORTKEY then the names must be separated by a
* comma. One or more spaces are also allowed between the comma and the
* following column name. By default, columns are sorted in ascending order,
* but a minus sign may precede the column name to indicate that the rows
* are sorted in descending order. This keyword may only be used in 'TABLE'
* or 'BINTABLE' extensions. Example: TSORTKEY = 'TIME, RA, DEC'.
*/
TSORTKEY(SOURCE.HEASARC, HDU.TABLE, VALUE.STRING, "defines the sort order of a table");
@SuppressWarnings("CPD-START")
private final IFitsHeader key;
DataDescription(IFitsHeader.SOURCE status, HDU hdu, VALUE valueType, String comment) {
this.key = new FitsHeaderImpl(name(), status, hdu, valueType, comment);
}
@Override
public String comment() {
return this.key.comment();
}
@Override
public HDU hdu() {
return this.key.hdu();
}
@Override
public String key() {
return this.key.key();
}
@Override
public IFitsHeader n(int... number) {
return this.key.n(number);
}
@Override
public SOURCE status() {
return this.key.status();
}
@Override
@SuppressWarnings("CPD-END")
public VALUE valueType() {
return this.key.valueType();
}
}
nom/tam/fits/header/Standard.java 0000664 0000000 0000000 00000104053 12755570700 015743 0 ustar root root package nom.tam.fits.header;
import nom.tam.fits.AsciiTable;
import nom.tam.fits.BasicHDU;
import nom.tam.fits.BinaryTable;
import nom.tam.fits.ImageData;
import nom.tam.fits.RandomGroupsData;
import nom.tam.fits.TableData;
import nom.tam.fits.UndefinedData;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
/**
* This data dictionary lists the 53 keywords currently defined in the FITS
* Standard.
*
*
* @see http://heasarc.gsfc.nasa.gov/docs/fcg/standard_dict.html
*
*
* @author Richard van Nieuwenhoven
*/
public enum Standard implements IFitsHeader {
/**
* The value field shall contain a character string identifying who compiled
* the information in the data associated with the key. This keyword is
* appropriate when the data originate in a published paper or are compiled
* from many sources.
*/
AUTHOR(SOURCE.RESERVED, HDU.ANY, VALUE.STRING, "author of the data"),
/**
* The value field shall contain an integer. The absolute value is used in
* computing the sizes of data structures. It shall specify the number of
* bits that represent a data value. RANGE: -64,-32,8,16,32
*/
BITPIX(SOURCE.MANDATORY, HDU.ANY, VALUE.INTEGER, "bits per data value", //
replaceable("header:bitpix", Object.class) //
),
/**
* This keyword shall be used only in primary array headers or IMAGE
* extension headers with positive values of BITPIX (i.e., in arrays with
* integer data). Columns 1-8 contain the string, `BLANK ' (ASCII blanks in
* columns 6-8). The value field shall contain an integer that specifies the
* representation of array values whose physical values are undefined.
*/
BLANK(SOURCE.RESERVED, HDU.IMAGE, VALUE.INTEGER, "value used for undefined array elements"),
/**
* Columns 1-8 contain ASCII blanks. This keyword has no associated value.
* Columns 9-80 may contain any ASCII text. Any number of card images with
* blank keyword fields may appear in a key.
*/
BLANKS(" ", SOURCE.RESERVED, HDU.ANY, VALUE.NONE, "descriptive comment"),
/**
* This keyword may be used only in the primary key. It shall appear within
* the first 36 card images of the FITS file. (Note: This keyword thus
* cannot appear if NAXIS is greater than 31, or if NAXIS is greater than 30
* and the EXTEND keyword is present.) Its presence with the required
* logical value of T advises that the physical block size of the FITS file
* on which it appears may be an integral multiple of the logical record
* length, and not necessarily equal to it. Physical block size and logical
* record length may be equal even if this keyword is present or unequal if
* it is absent. It is reserved primarily to prevent its use with other
* meanings. Since the issuance of version 1 of the standard, the BLOCKED
* keyword has been deprecated.
*
* @deprecated no blocksize other that 2880 may be used.
*/
@Deprecated
BLOCKED(SOURCE.RESERVED, HDU.PRIMARY, VALUE.LOGICAL, "is physical blocksize a multiple of 2880?"),
/**
* This keyword shall be used, along with the BZERO keyword, when the array
* pixel values are not the true physical values, to transform the primary
* data array values to the true physical values they represent, using the
* equation: physical_value = BZERO + BSCALE * array_value. The value field
* shall contain a floating point number representing the coefficient of the
* linear term in the scaling equation, the ratio of physical value to array
* value at zero offset. The default value for this keyword is 1.0.
*/
BSCALE(SOURCE.RESERVED, HDU.IMAGE, VALUE.REAL, "linear factor in scaling equation"),
/**
* The value field shall contain a character string, describing the physical
* units in which the quantities in the array, after application of BSCALE
* and BZERO, are expressed. The units of all FITS key keyword values, with
* the exception of measurements of angles, should conform with the
* recommendations in the IAU Style Manual. For angular measurements given
* as floating point values and specified with reserved keywords, degrees
* are the recommended units (with the units, if specified, given as 'deg').
*/
BUNIT(SOURCE.RESERVED, HDU.IMAGE, VALUE.STRING, "physical units of the array values"),
/**
* This keyword shall be used, along with the BSCALE keyword, when the array
* pixel values are not the true physical values, to transform the primary
* data array values to the true values using the equation: physical_value =
* BZERO + BSCALE * array_value. The value field shall contain a floating
* point number representing the physical value corresponding to an array
* value of zero. The default value for this keyword is 0.0.
*/
BZERO(SOURCE.RESERVED, HDU.IMAGE, VALUE.REAL, "zero point in scaling equation"),
/**
* The value field shall contain a floating point number giving the partial
* derivative of the coordinate specified by the CTYPEn keywords with
* respect to the pixel index, evaluated at the reference point CRPIXn, in
* units of the coordinate specified by the CTYPEn keyword. These units must
* follow the prescriptions of section 5.3 of the FITS Standard.
*/
CDELTn(SOURCE.RESERVED, HDU.IMAGE, VALUE.REAL, "coordinate increment along axis"),
/**
* This keyword shall have no associated value; columns 9-80 may contain any
* ASCII text. Any number of COMMENT card images may appear in a key.
*/
COMMENT(SOURCE.RESERVED, HDU.ANY, VALUE.NONE, "descriptive comment"),
/**
* This keyword is used to indicate a rotation from a standard coordinate
* system described by the CTYPEn to a different coordinate system in which
* the values in the array are actually expressed. Rules for such rotations
* are not further specified in the Standard; the rotation should be
* explained in comments. The value field shall contain a floating point
* number giving the rotation angle in degrees between axis n and the
* direction implied by the coordinate system defined by CTYPEn. In unit
* degrees.
*/
CROTAn(SOURCE.RESERVED, HDU.IMAGE, VALUE.REAL, "coordinate system rotation angle"),
/**
* The value field shall contain a floating point number, identifying the
* location of a reference point along axis n, in units of the axis index.
* This value is based upon a counter that runs from 1 to NAXISn with an
* increment of 1 per pixel. The reference point value need not be that for
* the center of a pixel nor lie within the actual data array. Use comments
* to indicate the location of the index point relative to the pixel.
*/
CRPIXn(SOURCE.RESERVED, HDU.IMAGE, VALUE.REAL, "coordinate system reference pixel"),
/**
* The value field shall contain a floating point number, giving the value
* of the coordinate specified by the CTYPEn keyword at the reference point
* CRPIXn. Units must follow the prescriptions of section 5.3 of the FITS
* Standard.
*/
CRVALn(SOURCE.RESERVED, HDU.IMAGE, VALUE.REAL, "coordinate system value at reference pixel"),
/**
* The value field shall contain a character string, giving the name of the
* coordinate represented by axis n.
*/
CTYPEn(SOURCE.RESERVED, HDU.IMAGE, VALUE.STRING, "name of the coordinate axis"),
/**
* The value field shall always contain a floating point number, regardless
* of the value of BITPIX. This number shall give the maximum valid physical
* value represented by the array, exclusive of any special values.
*/
DATAMAX(SOURCE.RESERVED, HDU.IMAGE, VALUE.REAL, "maximum data value"),
/**
* The value field shall always contain a floating point number, regardless
* of the value of BITPIX. This number shall give the minimum valid physical
* value represented by the array, exclusive of any special values.
*/
DATAMIN(SOURCE.RESERVED, HDU.IMAGE, VALUE.REAL, "minimum data value"),
/**
* The date on which the HDU was created, in the format specified in the
* FITS Standard. The old date format was 'yy/mm/dd' and may be used only
* for dates from 1900 through 1999. the new Y2K compliant date format is
* 'yyyy-mm-dd' or 'yyyy-mm-ddTHH:MM:SS[.sss]'.
*/
DATE(SOURCE.RESERVED, HDU.ANY, VALUE.STRING, "date of file creation"),
/**
* The date of the observation, in the format specified in the FITS
* Standard. The old date format was 'yy/mm/dd' and may be used only for
* dates from 1900 through 1999. The new Y2K compliant date format is
* 'yyyy-mm-dd' or 'yyyy-mm-ddTHH:MM:SS[.sss]'.
*/
DATE_OBS("DATE-OBS", SOURCE.RESERVED, HDU.ANY, VALUE.STRING, "date of the observation"),
/**
* This keyword has no associated value. Columns 9-80 shall be filled with
* ASCII blanks.
*/
END(SOURCE.MANDATORY, HDU.ANY, VALUE.NONE, "marks the end of the key keywords"),
/**
* The value field shall contain a floating point number giving the equinox
* in years for the celestial coordinate system in which positions are
* expressed. Starting with Version 1, the Standard has deprecated the use
* of the EPOCH keyword and thus it shall not be used in FITS files created
* after the adoption of the standard; rather, the EQUINOX keyword shall be
* used.
*
* @deprecated use {@link #EQUINOX} in stead
*/
@Deprecated
EPOCH(SOURCE.RESERVED, HDU.ANY, VALUE.REAL, "equinox of celestial coordinate system"),
/**
* The value field shall contain a floating point number giving the equinox
* in years for the celestial coordinate system in which positions are
* expressed.
*/
EQUINOX(SOURCE.RESERVED, HDU.ANY, VALUE.REAL, "equinox of celestial coordinate system"),
/**
* If the FITS file may contain extensions, a card image with the keyword
* EXTEND and the value field containing the logical value T must appear in
* the primary key immediately after the last NAXISn card image, or, if
* NAXIS=0, the NAXIS card image. The presence of this keyword with the
* value T in the primary key does not require that extensions be present.
*/
EXTEND(SOURCE.RESERVED, HDU.PRIMARY, VALUE.LOGICAL, "may the FITS file contain extensions?", //
replaceable("basichdu:extend", BasicHDU.class, "Allow extensions"), //
replaceable("header:extend", Object.class, "Extensions are permitted"), //
replaceable("imagedata:extend", ImageData.class, "Extension permitted"), //
replaceable("undefineddata:extend", UndefinedData.class, "Extensions are permitted")
),
/**
* The value field shall contain an integer, specifying the level in a
* hierarchy of extension levels of the extension key containing it. The
* value shall be 1 for the highest level; levels with a higher value of
* this keyword shall be subordinate to levels with a lower value. If the
* EXTLEVEL keyword is absent, the file should be treated as if the value
* were 1. This keyword is used to describe an extension and should not
* appear in the primary key.RANGE: [1:] DEFAULT: 1
*/
EXTLEVEL(SOURCE.RESERVED, HDU.EXTENSION, VALUE.INTEGER, "hierarchical level of the extension"),
/**
* The value field shall contain a character string, to be used to
* distinguish among different extensions of the same type, i.e., with the
* same value of XTENSION, in a FITS file. This keyword is used to describe
* an extension and should not appear in the primary key.
*/
EXTNAME(SOURCE.RESERVED, HDU.EXTENSION, VALUE.STRING, "name of the extension"),
/**
* The value field shall contain an integer, to be used to distinguish among
* different extensions in a FITS file with the same type and name, i.e.,
* the same values for XTENSION and EXTNAME. The values need not start with
* 1 for the first extension with a particular value of EXTNAME and need not
* be in sequence for subsequent values. If the EXTVER keyword is absent,
* the file should be treated as if the value were 1. This keyword is used
* to describe an extension and should not appear in the primary key.RANGE:
* [1:] DEFAULT: 1
*/
EXTVER(SOURCE.RESERVED, HDU.EXTENSION, VALUE.INTEGER, "version of the extension"),
/**
* The value field shall contain an integer that shall be used in any way
* appropriate to define the data structure, consistent with Eq. 5.2 in the
* FITS Standard. This keyword originated for use in FITS Random Groups
* where it specifies the number of random groups present. In most other
* cases this keyword will have the value 1.
*/
GCOUNT(SOURCE.MANDATORY, HDU.EXTENSION, VALUE.INTEGER, "group count", //
replaceable("randomgroupsdata:gcount", RandomGroupsData.class), //
replaceable("asciitable:gcount", AsciiTable.class), //
replaceable("basichdu:gcount", Object.class, "Required value"), //
replaceable("binarytable:gcount", BinaryTable.class), //
replaceable("imagedata:gcount", ImageData.class, "No extra parameters"), //
replaceable("undefineddata:gcount", UndefinedData.class)
),
/**
* The value field shall contain the logical constant T. The value T
* associated with this keyword implies that random groups records are
* present.
*/
GROUPS(SOURCE.MANDATORY, HDU.GROUPS, VALUE.LOGICAL, "indicates random groups structure", //
replaceable("randomgroupsdata:groups", RandomGroupsData.class) //
),
/**
* This keyword shall have no associated value; columns 9-80 may contain any
* ASCII text. The text should contain a history of steps and procedures
* associated with the processing of the associated data. Any number of
* HISTORY card images may appear in a key.
*/
HISTORY(SOURCE.RESERVED, HDU.ANY, VALUE.NONE, "processing history of the data"),
/**
* The value field shall contain a character string identifying the
* instrument used to acquire the data associated with the key.
*/
INSTRUME(SOURCE.RESERVED, HDU.ANY, VALUE.STRING, "name of instrument"),
/**
* The value field shall contain a non-negative integer no greater than 999,
* representing the number of axes in the associated data array. A value of
* zero signifies that no data follow the key in the HDU. In the context of
* FITS 'TABLE' or 'BINTABLE' extensions, the value of NAXIS is always
* 2.RANGE: [0:999]
*/
NAXIS(SOURCE.MANDATORY, HDU.ANY, VALUE.INTEGER, "number of axes", //
replaceable("header:naxis", Object.class) //
),
/**
* The value field of this indexed keyword shall contain a non-negative
* integer, representing the number of elements along axis n of a data
* array. The NAXISn must be present for all values n = 1,...,NAXIS, and for
* no other values of n. A value of zero for any of the NAXISn signifies
* that no data follow the key in the HDU. If NAXIS is equal to 0, there
* should not be any NAXISn keywords.RANGE: [0:]
*/
NAXISn(SOURCE.MANDATORY, HDU.ANY, VALUE.INTEGER, "size of the n'th axis", //
replaceable("asciitable:naxis1", AsciiTable.class, "Size of row in bytes"), //
replaceable("binarytable:naxis1", BinaryTable.class, "Bytes per row"), //
replaceable("randomgroupsdata:naxis1", RandomGroupsData.class), //
replaceable("randomgroupsdata:naxisN", RandomGroupsData.class), //
replaceable("tablehdu:naxis2", TableData.class), //
replaceable("header:naxisN", Object.class), //
replaceable("undefineddata:naxis1", UndefinedData.class, "Number of Bytes") //
),
/**
* The value field shall contain a character string giving a name for the
* object observed.
*/
OBJECT(SOURCE.RESERVED, HDU.ANY, VALUE.STRING, "name of observed object"),
/**
* The value field shall contain a character string identifying who acquired
* the data associated with the key.
*/
OBSERVER(SOURCE.RESERVED, HDU.ANY, VALUE.STRING, "observer who acquired the data"),
/**
* The value field shall contain a character string identifying the
* organization or institution responsible for creating the FITS file.
*/
ORIGIN(SOURCE.RESERVED, HDU.ANY, VALUE.STRING, "organization responsible for the data"),
/**
* The value field shall contain an integer that shall be used in any way
* appropriate to define the data structure, consistent with Eq. 5.2 in the
* FITS Standard. This keyword was originated for use with FITS Random
* Groups and represented the number of parameters preceding each group. It
* has since been used in 'BINTABLE' extensions to represent the size of the
* data heap following the main data table. In most other cases its value
* will be zero.
*/
PCOUNT(SOURCE.MANDATORY, HDU.EXTENSION, VALUE.INTEGER, "parameter count", //
replaceable("asciitable:pcount", AsciiTable.class, "No group data"), //
replaceable("basichdu:pcount", Object.class, "Required value"), //
replaceable("binarytablehdu:pcount", BinaryTable.class, "Includes heap"), //
replaceable("binarytable:pcount", BinaryTable.class), //
replaceable("imagedata:pcount", ImageData.class, "One group"), //
replaceable("randomgroupsdata:pcount", RandomGroupsData.class), //
replaceable("undefineddata:pcount", UndefinedData.class) //
),
/**
* This keyword is reserved for use within the FITS Random Groups structure.
* This keyword shall be used, along with the PZEROn keyword, when the nth
* FITS group parameter value is not the true physical value, to transform
* the group parameter value to the true physical values it represents,
* using the equation, physical_value = PZEROn + PSCALn *
* group_parameter_value. The value field shall contain a floating point
* number representing the coefficient of the linear term, the scaling
* factor between true values and group parameter values at zero offset. The
* default value for this keyword is 1.0.
*/
PSCALn(SOURCE.RESERVED, HDU.GROUPS, VALUE.REAL, "parameter scaling factor"),
/**
* This keyword is reserved for use within the FITS Random Groups structure.
* The value field shall contain a character string giving the name of
* parameter n. If the PTYPEn keywords for more than one value of n have the
* same associated name in the value field, then the data value for the
* parameter of that name is to be obtained by adding the derived data
* values of the corresponding parameters. This rule provides a mechanism by
* which a random parameter may have more precision than the accompanying
* data array elements; for example, by summing two 16-bit values with the
* first scaled relative to the other such that the sum forms a number of up
* to 32-bit precision.
*/
PTYPEn(SOURCE.RESERVED, HDU.GROUPS, VALUE.STRING, "name of random groups parameter"),
/**
* This keyword is reserved for use within the FITS Random Groups structure.
* This keyword shall be used, along with the PSCALn keyword, when the nth
* FITS group parameter value is not the true physical value, to transform
* the group parameter value to the physical value. The value field shall
* contain a floating point number, representing the true value
* corresponding to a group parameter value of zero. The default value for
* this keyword is 0.0. The transformation equation is as follows:
* physical_value = PZEROn + PSCALn * group_parameter_value.DEFAULT: 0.0
*/
PZEROn(SOURCE.RESERVED, HDU.GROUPS, VALUE.REAL, "parameter scaling zero point"),
/**
* Coordinate reference frame of major/minor axes.If absent the default
* value is 'FK5'.
*/
RADESYS(SOURCE.RESERVED, HDU.ANY, VALUE.STRING, "Coordinate reference frame of major/minor axes."),
/**
* Coordinate reference frame of major/minor axes. use RADESYS instead.
*
* @deprecated use {@link #RADESYS} instead.
*/
@Deprecated
RADECSYS(SOURCE.RESERVED, HDU.ANY, VALUE.STRING, "Coordinate reference frame of major/minor axes."),
/**
* The value field shall contain a character string citing a reference where
* the data associated with the key are published.
*/
REFERENC(SOURCE.RESERVED, HDU.ANY, VALUE.STRING, "bibliographic reference"),
/**
* The SIMPLE keyword is required to be the first keyword in the primary key
* of all FITS files. The value field shall contain a logical constant with
* the value T if the file conforms to the standard. This keyword is
* mandatory for the primary key and is not permitted in extension headers.
* A value of F signifies that the file does not conform to this standard.
*/
SIMPLE(SOURCE.MANDATORY, HDU.PRIMARY, VALUE.LOGICAL, "does file conform to the Standard?", //
replaceable("header:simple", Object.class, "Java FITS: " + new java.util.Date()) //
),
/**
* The value field of this indexed keyword shall contain an integer
* specifying the column in which field n starts in an ASCII TABLE
* extension. The first column of a row is numbered 1.RANGE: [1:]
*/
TBCOLn(SOURCE.MANDATORY, HDU.ASCII_TABLE, VALUE.INTEGER, "begining column number", //
replaceable("asciitable:tbcolN", AsciiTable.class, "Column offset") //
),
/**
* The value field of this indexed keyword shall contain a character string
* describing how to interpret the contents of field n as a multidimensional
* array, providing the number of dimensions and the length along each axis.
* The form of the value is not further specified by the Standard. A
* proposed convention is described in Appendix B.2 of the FITS Standard in
* which the value string has the format '(l,m,n...)' where l, m, n,... are
* the dimensions of the array.
*/
TDIMn(SOURCE.RESERVED, HDU.BINTABLE, VALUE.STRING, "dimensionality of the array ", //
replaceable("binarytablehdu:tdimN", BinaryTable.class), //
replaceable("headercard:tdimN", Object.class) //
),
/**
* The value field of this indexed keyword shall contain a character string
* describing the format recommended for the display of the contents of
* field n. If the table value has been scaled, the physical value shall be
* displayed. All elements in a field shall be displayed with a single,
* repeated format. For purposes of display, each byte of bit (type X) and
* byte (type B) arrays is treated as an unsigned integer. Arrays of type A
* may be terminated with a zero byte. Only the format codes in Table 8.6,
* discussed in section 8.3.4 of the FITS Standard, are permitted for
* encoding. The format codes must be specified in upper case. If the Bw.m,
* Ow.m, and Zw.m formats are not readily available to the reader, the Iw.m
* display format may be used instead, and if the ENw.d and ESw.d formats
* are not available, Ew.d may be used. The meaning of this keyword is not
* defined for fields of type P in the Standard but may be defined in
* conventions using such fields.
*/
TDISPn(SOURCE.RESERVED, HDU.TABLE, VALUE.STRING, "display format"),
/**
* The value field shall contain a character string identifying the
* telescope used to acquire the data associated with the key.
*/
TELESCOP(SOURCE.RESERVED, HDU.ANY, VALUE.STRING, "name of telescope"),
/**
* The value field shall contain a non-negative integer representing the
* number of fields in each row of a 'TABLE' or 'BINTABLE' extension. The
* maximum permissible value is 999. RANGE: [0:999]
*/
TFIELDS(SOURCE.MANDATORY, HDU.TABLE, VALUE.INTEGER, "number of columns in the table", //
replaceable("asciitablehdu:tfields", AsciiTable.class), //
replaceable("binarytable:tfields", BinaryTable.class), //
replaceable("tablehdu:tfields", TableData.class, "Number of table fields"), //
replaceable("asciitable:tfields", AsciiTable.class, "Number of fields in table") //
),
/**
* The value field of this indexed keyword shall contain a character string
* describing the format in which field n is encoded in a 'TABLE' or
* 'BINTABLE' extension.
*/
TFORMn(SOURCE.MANDATORY, HDU.TABLE, VALUE.STRING, "column data format", //
replaceable("asciitable:tformN", AsciiTable.class), //
replaceable("binarytable:tformN", BinaryTable.class) //
),
/**
* The value field of this keyword shall contain an integer providing the
* separation, in bytes, between the start of the main data table and the
* start of a supplemental data area called the heap. The default value
* shall be the product of the values of NAXIS1 and NAXIS2. This keyword
* shall not be used if the value of PCOUNT is zero. A proposed application
* of this keyword is presented in Appendix B.1 of the FITS Standard.
*/
THEAP(SOURCE.RESERVED, HDU.BINTABLE, VALUE.INTEGER, "offset to starting data heap address", //
replaceable("binarytablehdu:theap", BinaryTable.class) //
),
/**
* In ASCII 'TABLE' extensions, the value field for this indexed keyword
* shall contain the character string that represents an undefined value for
* field n. The string is implicitly blank filled to the width of the field.
* In binary 'BINTABLE' table extensions, the value field for this indexed
* keyword shall contain the integer that represents an undefined value for
* field n of data type B, I, or J. The keyword may not be used in
* 'BINTABLE' extensions if field n is of any other data type.
*/
TNULLn(SOURCE.RESERVED, HDU.TABLE, VALUE.STRING, "value used to indicate undefined table element"),
/**
* This indexed keyword shall be used, along with the TZEROn keyword, when
* the quantity in field n does not represent a true physical quantity. The
* value field shall contain a floating point number representing the
* coefficient of the linear term in the equation, physical_value = TZEROn +
* TSCALn * field_value, which must be used to compute the true physical
* value of the field, or, in the case of the complex data types C and M, of
* the real part of the field with the imaginary part of the scaling factor
* set to zero. The default value for this keyword is 1.0. This keyword may
* not be used if the format of field n is A, L, or X.DEFAULT: 1.0
*/
TSCALn(SOURCE.RESERVED, HDU.TABLE, VALUE.REAL, "linear data scaling factor"),
/**
* The value field for this indexed keyword shall contain a character
* string, giving the name of field n. It is recommended that only letters,
* digits, and underscore (hexadecimal code 5F, ('_') be used in the name.
* String comparisons with the values of TTYPEn keywords should not be case
* sensitive. The use of identical names for different fields should be
* avoided.
*/
TTYPEn(SOURCE.RESERVED, HDU.TABLE, VALUE.STRING, "column name"),
/**
* The value field shall contain a character string describing the physical
* units in which the quantity in field n, after any application of TSCALn
* and TZEROn, is expressed. The units of all FITS key keyword values, with
* the exception of measurements of angles, should conform with the
* recommendations in the IAU Style Manual. For angular measurements given
* as floating point values and specified with reserved keywords, degrees
* are the recommended units (with the units, if specified, given as 'deg').
*/
TUNITn(SOURCE.RESERVED, HDU.TABLE, VALUE.STRING, "column units"),
/**
* This indexed keyword shall be used, along with the TSCALn keyword, when
* the quantity in field n does not represent a true physical quantity. The
* value field shall contain a floating point number representing the true
* physical value corresponding to a value of zero in field n of the FITS
* file, or, in the case of the complex data types C and M, in the real part
* of the field, with the imaginary part set to zero. The default value for
* this keyword is 0.0. This keyword may not be used if the format of field
* n is A, L, or X.DEFAULT: 0.0
*/
TZEROn(SOURCE.RESERVED, HDU.TABLE, VALUE.REAL, "column scaling zero point"),
/**
* The value field shall contain a character string giving the name of the
* extension type. This keyword is mandatory for an extension key and must
* not appear in the primary key. For an extension that is not a standard
* extension, the type name must not be the same as that of a standard
* extension.
*/
XTENSION(SOURCE.MANDATORY, HDU.EXTENSION, VALUE.STRING, "marks beginning of new HDU");
public static final IFitsHeader NAXIS1 = NAXISn.n(1);
public static final IFitsHeader NAXIS2 = NAXISn.n(2);
private static final ThreadLocal> COMMENT_CONTEXT = new ThreadLocal>();
/**
* The value of the XTENSION keword in case of a binary table.
*/
public static final String XTENSION_BINTABLE = "BINTABLE";
/**
* The value of the XTENSION keword in case of an image.
*/
public static final String XTENSION_IMAGE = "IMAGE";
private final StandardCommentReplacement[] commentReplacements;
@SuppressWarnings("CPD-START")
private final IFitsHeader key;
Standard(SOURCE status, HDU hdu, VALUE valueType, String comment, StandardCommentReplacement... replacements) {
this.key = new FitsHeaderImpl(name(), status, hdu, valueType, comment);
this.commentReplacements = replacements;
}
Standard(String headerName, SOURCE status, HDU hdu, VALUE valueType, String comment, StandardCommentReplacement... replacements) {
this.key = new FitsHeaderImpl(headerName == null ? name() : headerName, status, hdu, valueType, comment);
this.commentReplacements = replacements;
}
@Override
public String comment() {
Class contextClass = COMMENT_CONTEXT.get();
if (contextClass == null) {
contextClass = Object.class;
}
for (StandardCommentReplacement stdCommentReplacement : commentReplacements) {
if (stdCommentReplacement.getContext().isAssignableFrom(contextClass)) {
if (stdCommentReplacement.getComment() != null) {
return stdCommentReplacement.getComment();
}
}
}
return this.key.comment();
}
@Override
public HDU hdu() {
return this.key.hdu();
}
@Override
public String key() {
return this.key.key();
}
@Override
public IFitsHeader n(int... number) {
return this.key.n(number);
}
@Override
public SOURCE status() {
return this.key.status();
}
@Override
@SuppressWarnings("CPD-END")
public VALUE valueType() {
return this.key.valueType();
}
public static void context(Class clazz) {
COMMENT_CONTEXT.set(clazz);
}
/**
* scan for a comment with the specified reference key.
*
* @param commentKey
* the reference key
* @return the comment for the reference key
*/
public String getCommentByKey(String commentKey) {
for (StandardCommentReplacement commentReplacement : commentReplacements) {
if (commentReplacement.getRef().equals(commentKey)) {
String foundcommentReplacement = commentReplacement.getComment();
if (foundcommentReplacement == null) {
return comment();
} else {
return foundcommentReplacement;
}
}
}
return null;
}
/**
* set the comment for the specified reference key.
*
* @param commentKey
* the reference key
* @param value
* the comment to set when the fits key is used.
*/
public void setCommentByKey(String commentKey, String value) {
for (StandardCommentReplacement commentReplacement : commentReplacements) {
if (commentReplacement.getRef().equals(commentKey)) {
commentReplacement.setComment(value);
return;
}
}
}
private static StandardCommentReplacement replaceable(String string, Class clazz) {
return new StandardCommentReplacement(string, clazz);
}
private static StandardCommentReplacement replaceable(String string, Class clazz, String comment) {
return new StandardCommentReplacement(string, clazz, comment);
}
}
nom/tam/fits/header/IFitsHeader.java 0000664 0000000 0000000 00000012016 12755570700 016327 0 ustar root root package nom.tam.fits.header;
/*
* #%L
* INDI for Java Utilities for the fits image format
* %%
* Copyright (C) 2012 - 2015 indiforjava
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
public interface IFitsHeader {
enum HDU {
ANY,
ASCII_TABLE,
BINTABLE,
EXTENSION,
GROUPS,
IMAGE,
PRIMARY,
PRIMARY_EXTENSION,
TABLE
}
enum SOURCE {
/**
*
* @see checksum doc
*
*/
CHECKSUM("http://heasarc.gsfc.nasa.gov/docs/heasarc/ofwg/docs/general/checksum/checksum.html"),
/**
*
* @see http://cxc.harvard.edu/contrib/arots/fits/content.txt
*
*/
CXC("http://cxc.harvard.edu/contrib/arots/fits/content.txt"),
/**
*
* @see http://arcdev.hq.eso.org/dicb/dicd/dic-1-1.4.html
*
*/
ESO("http://arcdev.hq.eso.org/dicb/dicd/dic-1-1.4.html"),
/**
*
* @see http://heasarc.gsfc.nasa.gov/docs/heasarc/ofwg/docs/ofwg_recomm/r13.html
*
*/
HEASARC("http://heasarc.gsfc.nasa.gov/docs/heasarc/ofwg/docs/ofwg_recomm/r13.html"),
/**
* integral.
*/
INTEGRAL(null),
/**
* defined mandatory by the fits standard.
*/
MANDATORY("http://heasarc.gsfc.nasa.gov/docs/fcg/standard_dict.html"),
/**
*
* @see http://www.cyanogen.com/help/maximdl/FITS_File_Header_Definitions.htm
*
*/
MaxImDL("http://www.cyanogen.com/help/maximdl/FITS_File_Header_Definitions.htm"),
/**
*
* @see http://iraf.noao.edu/iraf/web/projects/ccdmosaic/imagedef/fitsdic.html
*
*/
NOAO("http://iraf.noao.edu/iraf/web/projects/ccdmosaic/imagedef/fitsdic.html"),
/**
* defined reserved by the fits standard.
*/
RESERVED("http://heasarc.gsfc.nasa.gov/docs/fcg/standard_dict.html"),
/**
* rosat no link available.
*/
ROSAT(null),
/**
*
* @see http://archive.sbig.com/pdffiles/SBFITSEXT_1r0.pdf
*
*/
SBIG("http://archive.sbig.com/pdffiles/SBFITSEXT_1r0.pdf"),
/**
*
* @see http://tucana.noao.edu/ADASS/adass_proc/adass_95/zaraten/zaraten.html
*
*/
STScI("http://tucana.noao.edu/ADASS/adass_proc/adass_95/zaraten/zaraten.html"),
/**
*
* @see http://www.ucolick.org
*
*/
UCOLICK("http://www.ucolick.org"),
/**
* developed over time, source long forgotten.
*/
UNKNOWN(null);
private final String url;
SOURCE(String url) {
this.url = url;
}
public String url() {
return this.url;
}
}
enum VALUE {
INTEGER,
LOGICAL,
NONE,
REAL,
STRING,
ANY
}
String comment();
HDU hdu();
String key();
IFitsHeader n(int... number);
SOURCE status();
VALUE valueType();
}
nom/tam/fits/header/extra/ 0000775 0000000 0000000 00000000000 12755570710 014461 5 ustar root root nom/tam/fits/header/extra/CXCExt.java 0000664 0000000 0000000 00000013064 12755570700 016425 0 ustar root root package nom.tam.fits.header.extra;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import nom.tam.fits.header.FitsHeaderImpl;
import nom.tam.fits.header.IFitsHeader;
/**
* This is the file content.txt that presents a comprehensive compilation of all
* classes of data products in the Chandra Data Archive for the "flight"
* dataset. This file is the definitive authority on the values of various FITS
* header keywords.
*
* All files are identified by the CONTENT value of their principal HDUs.
*
*
*
* http://cxc.harvard.edu/contrib/arots/fits/content.txt
*
*
* @author Richard van Nieuwenhoven
*/
public enum CXCExt implements IFitsHeader {
/**
* ASC-DS processing system revision (release)
*/
ASCDSVER("ASC-DS processing system revision (release)"),
/**
* Correction applied to Basic Time rate (s)
*/
BTIMCORR("Correction applied to Basic Time rate (s)"),
/**
* Basic Time clock drift (s / VCDUcount^2)
*/
BTIMDRFT("Basic Time clock drift (s / VCDUcount^2)"),
/**
* Basic Time offset (s)
*/
BTIMNULL("Basic Time offset (s)"),
/**
* Basic Time clock rate (s / VCDUcount)
*/
BTIMRATE("Basic Time clock rate (s / VCDUcount)"),
/**
* Data product identification '########'
*/
CONTENT("Data product identification"),
/**
* ???
*/
CONVERS("??"),
/**
* Data class '########'
*/
DATACLAS("Data class"),
/**
* Dead time correction
*/
DTCOR("Dead time correction"),
/**
* Assumed focal length, mm; Level 1 and up
*/
FOC_LEN("Assumed focal length, mm; Level 1 and up"),
/**
* ICD reference
*/
HDUSPEC("ICD reference"),
/**
* The OGIP long string convention may be used.
*/
LONGSTRN("The OGIP long string convention may be used."),
/**
* Mission is AXAF
*/
MISSION("Mission is AXAF"),
/**
* Processing version of data
*/
REVISION("Processing version of data"),
/**
* Nominal roll angle, deg
*/
ROLL_NOM("Nominal roll angle, deg"),
/**
* Sequence number
*/
SEQ_NUM("Sequence number"),
/**
* SIM focus pos (mm)
*/
SIM_X("SIM focus pos (mm)"),
/**
* SIM orthogonal axis pos (mm)
*/
SIM_Y("SIM orthogonal axis pos (mm)"),
/**
* SIM translation stage pos (mm)
*/
SIM_Z("SIM translation stage pos (mm)"),
/**
* Major frame count at start
*/
STARTMJF("Major frame count at start"),
/**
* Minor frame count at start
*/
STARTMNF("Minor frame count at start"),
/**
* On-Board MET close to STARTMJF and STARTMNF
*/
STARTOBT("On-Board MET close to STARTMJF and STARTMNF"),
/**
* Major frame count at stop
*/
STOPMJF("Major frame count at stop"),
/**
* Minor frame count at stop
*/
STOPMNF("Minor frame count at stop"),
/**
* Absolute precision of clock correction
*/
TIERABSO("Absolute precision of clock correction"),
/**
* Short-term clock stability
*/
TIERRELA("Short-term clock stability"),
/**
* Time stamp reference as bin fraction
*/
TIMEPIXR("Time stamp reference as bin fraction"),
/**
* Telemetry revision number (IP&CL)
*/
TLMVER("Telemetry revision number (IP&CL)"),
/**
* As in the "TIME" column: raw space craft clock;
*/
TSTART("As in the \"TIME\" column: raw space craft clock;"),
/**
* add TIMEZERO and MJDREF for absolute TT
*/
TSTOP("add TIMEZERO and MJDREF for absolute TT");
@SuppressWarnings("CPD-START")
private final IFitsHeader key;
CXCExt(String comment) {
this.key = new FitsHeaderImpl(name(), IFitsHeader.SOURCE.CXC, HDU.ANY, VALUE.STRING, comment);
}
@Override
public String comment() {
return this.key.comment();
}
@Override
public HDU hdu() {
return this.key.hdu();
}
@Override
public String key() {
return this.key.key();
}
@Override
public IFitsHeader n(int... number) {
return this.key.n(number);
}
@Override
public SOURCE status() {
return this.key.status();
}
@Override
@SuppressWarnings("CPD-END")
public VALUE valueType() {
return this.key.valueType();
}
}
nom/tam/fits/header/extra/STScIExt.java 0000664 0000000 0000000 00000014611 12755570700 016734 0 ustar root root package nom.tam.fits.header.extra;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import nom.tam.fits.header.FitsHeaderImpl;
import nom.tam.fits.header.IFitsHeader;
/**
* This keyword dictionary gathered form STScI.
*
*
* @see http://tucana.noao.edu/ADASS/adass_proc/adass_95/zaraten/zaraten.html
*
*
* @author Richard van Nieuwenhoven.
*/
public enum STScIExt implements IFitsHeader {
/**
* approach vectors
*/
APPVEC("approach vectors"),
/**
* Telemetry rate
*/
BIT_RATE("Telemetry rate"),
/**
* date of initial data represented (dd/mm/yy)
*/
DATE_BEG("DATE-BEG", "date of initial data represented."),
/**
* Date of original file creation (dd/mm/yy)
*/
DATE_MAP("DATE-MAP", "Date of original file creation"),
/**
* File standard deviation of DEC (degrees)
*/
DEC_PNTE(""),
/**
* Detector X field of view (mm)
*/
FOV_X_MM("Detector X field of view (mm)"),
/**
* Detector X field of view (mm)
*/
FOV_Y_MM("Detector Y field of view (mm)"),
/**
* BITS/PIXEL OF IPPS RASTER.
*/
IPPS_B_P("IPPS-B/P", "BITS/PIXEL OF IPPS RASTER."),
/**
* IPPS identification.
*/
IPPS_ID("IPPS-ID", ""),
/**
* MAXIMUM VALUE IN RASTER
*/
IPPS_MAX("IPPS-MAX", "MAXIMUM VALUE IN RASTER"),
/**
* MINIMUM VALUE IN RASTER
*/
IPPS_MIN("IPPS-MIN", "MINIMUM VALUE IN RASTER"),
/**
* RASTER LFN/RASTER ORDINAL
*/
IPPS_RF("IPPS-RF", "RASTER LFN/RASTER ORDINAL"),
/**
* ?
*/
JOBNAME(""),
/**
* Fractional portion of ephemeris MJD
*/
MJDREFF("Fractional portion of ephemeris MJD"),
/**
* Integer portion of ephemeris MJD
*/
MJDREFI("Integer portion of ephemeris MJD"),
/**
* Modal Configuration ID
*/
MODAL_ID("Modal Configuration ID"),
/**
* optical attribute number is id.
*/
OPTICn(""),
/**
* beginning orbit number
*/
ORBITBEG("beginning orbit number"),
/**
* ending orbit number
*/
ORBITEND("ending orbit number"),
/**
* File standard deviation of ROLL (degrees)
*/
PA_PNTE("File standard deviation of ROLL"),
/**
* Quad tree pixel resolution
*/
PIXRESOL("Quad tree pixel resolution"),
/**
* Processing script version
*/
PROCVER("Processing script version"),
/**
* ?
*/
PRODUCT(""),
/**
* File standard deviation of RA (degrees)
*/
RA_PNTE("File standard deviation of RA "),
/**
* Sequential number from ODB
*/
SEQNUM("Sequential number from ODB"),
/**
* Number of times sequence processed
*/
SEQPNUM("Number of times sequence processed"),
/**
* solar elongations included
*/
SOLELONG("solar elongations included"),
/**
* ?
*/
TCDLTn(""),
/**
* ?
*/
TCRPXn(""),
/**
* ?
*/
TCRVLn(""),
/**
* ?
*/
TCTYPn(""),
/**
* Default time system. All times which do not have a "timesys" element
* associated with them in this dictionary default to this keyword. time
* system (same as IRAS)
*/
TIMESYS("Default time system"),
/**
* offset to be applied to TIME column
*/
TIMEZERO("offset to be applied to TIME column"),
/**
* observation start time in TIMESYS system .
*/
TSTART("observation start time"),
/**
* observation stop time in TIMESYS system .
*/
TSTOP("observation stop time"),
/**
* Version of Data Reduction Software
*/
VERSION("Version of Data Reduction Software "),
/**
* nominal wavelength of Band n
*/
WAVEn("nominal wavelength of Band"),
/**
* signal from zodiacal dust remains in map
*/
ZLREMOV("signal from zodiacal dust remains in map"),
/**
* Modified Julian date at the start of the exposure. The fractional part of
* the date is given to better than a second of time.
*
* units = 'd'
*
*
* default value = none
*
*
* index = none
*
*/
MJD_OBS("MJD-OBS", "MJD of exposure start");
@SuppressWarnings("CPD-START")
private final IFitsHeader key;
STScIExt(String comment) {
this.key = new FitsHeaderImpl(name(), IFitsHeader.SOURCE.CXC, HDU.ANY, VALUE.STRING, comment);
}
STScIExt(String key, String comment) {
this.key = new FitsHeaderImpl(name(), IFitsHeader.SOURCE.CXC, HDU.ANY, VALUE.STRING, comment);
}
@Override
public String comment() {
return this.key.comment();
}
@Override
public HDU hdu() {
return this.key.hdu();
}
@Override
public String key() {
return this.key.key();
}
@Override
public IFitsHeader n(int... number) {
return this.key.n(number);
}
@Override
public SOURCE status() {
return this.key.status();
}
@Override
@SuppressWarnings("CPD-END")
public VALUE valueType() {
return this.key.valueType();
}
}
nom/tam/fits/header/extra/NOAOExt.java 0000664 0000000 0000000 00000576730 12755570700 016562 0 ustar root root package nom.tam.fits.header.extra;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import nom.tam.fits.header.FitsHeaderImpl;
import nom.tam.fits.header.IFitsHeader;
/**
* This keyword dictionary defines keywords which may be used in image data
* recorded by the data acquisition system. It currently does not consider
* keywords for data processing. Most of the keywords defined here will not be
* used. New parameters must be added to the logical class heirarchy and then a
* keyword defined in this dictionary before use in image data.
*
*
* @see http://iraf.noao.edu/iraf/web/projects/ccdmosaic/imagedef/fitsdic.html
*
*
* @author Richard van Nieuwenhoven.
*/
public enum NOAOExt implements IFitsHeader {
/**
*
* default value = none
*
*
* index = none
*
*/
ACTFREQ(HDU.PRIMARY, VALUE.NONE, ""),
/**
*
* default value = none
*
*
* index = none
*
*/
ACTHWV(HDU.PRIMARY, VALUE.STRING, ""),
/**
* Times for the active optics sensor measurements given as modified Julian
* dates.
*
* units = 'd'
*
*
* default value = MJDHDR ACTMJD
*
*
* index = none 1-999
*
*/
ACTMJD(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Times for the active optics sensor measurements given as modified Julian
* dates.
*
* units = 'd'
*
*
* default value = MJDHDR ACTMJD
*
*
* index = none 1-999
*
*/
ACTMJDn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Active optics system position angle measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
ACTPAN(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Active optics system position angle measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
ACTPANn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Active optics system linear position sensor measurements in appropriate
* units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
ACTPOS(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Active optics system linear position sensor measurements in appropriate
* units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
ACTPOSn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Active optics system pressure sensor measurements in appropriate units.
*
* units = UNITPRES
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
ACTPRE(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Active optics system pressure sensor measurements in appropriate units.
*
* units = UNITPRES
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
ACTPREn(HDU.PRIMARY, VALUE.REAL, ""),
/**
*
* default value = none
*
*
* index = none
*
*/
ACTSTAT(HDU.PRIMARY, VALUE.NONE, ""),
/**
*
* default value = none
*
*
* index = none
*
*/
ACTSWV(HDU.PRIMARY, VALUE.NONE, ""),
/**
* Active optics system temperature sensor measurements in degrees Celsius.
*
* units = UNITTEMP
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
ACTTEM(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Active optics system temperature sensor measurements in degrees Celsius.
*
* units = UNITTEMP
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
ACTTEMn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Active optics voltage sensor measurements in volts.
*
* units = UNITVOLT
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
ACTVOL(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Active optics voltage sensor measurements in volts.
*
* units = UNITVOLT
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
ACTVOLn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Times for the adapter sensor measurements given as modified Julian dates.
*
* units = 'd'
*
*
* default value = MJDHDR ADAMJD
*
*
* index = none 1-999
*
*/
ADAMJD(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Times for the adapter sensor measurements given as modified Julian dates.
*
* units = 'd'
*
*
* default value = MJDHDR ADAMJD
*
*
* index = none 1-999
*
*/
ADAMJDn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Adapter position angle measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
ADAPAN(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Adapter position angle measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
ADAPANn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Adapter linear position sensor measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
ADAPOS(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Adapter linear position sensor measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
ADAPOSn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Adapter pressure sensor measurements in appropriate units.
*
* units = UNITPRES
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
ADAPRE(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Adapter pressure sensor measurements in appropriate units.
*
* units = UNITPRES
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
ADAPREn(HDU.PRIMARY, VALUE.REAL, ""),
/**
*
* default value = none
*
*
* index = none
*
*/
ADAPSWV(HDU.PRIMARY, VALUE.NONE, ""),
/**
*
* default value = none
*
*
* index = none
*
*/
ADAPTER(HDU.PRIMARY, VALUE.NONE, ""),
/**
*
* default value = none
*
*
* index = none
*
*/
ADASTAT(HDU.PRIMARY, VALUE.NONE, ""),
/**
* Adapter temperature sensor measurements in degrees Celsius.
*
* units = UNITTEMP
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
ADATEM(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Adapter temperature sensor measurements in degrees Celsius.
*
* units = UNITTEMP
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
ADATEMn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Adapter voltage sensor measurements in volts.
*
* units = UNITVOLT
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
ADAVOL(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Adapter voltage sensor measurements in volts.
*
* units = UNITVOLT
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
ADAVOLn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Atmospheric dispersion compensator hardware identification.
*
* default value = none
*
*
* index = none
*
*/
ADC(HDU.PRIMARY, VALUE.STRING, "ADC Identification"),
/**
* Times for the ADC sensor measurements given as modified Julian dates.
*
* units = 'd'
*
*
* default value = MJDHDR ADCMJD
*
*
* index = none 1-999
*
*/
ADCMJD(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Times for the ADC sensor measurements given as modified Julian dates.
*
* units = 'd'
*
*
* default value = MJDHDR ADCMJD
*
*
* index = none 1-999
*
*/
ADCMJDn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* ADC position angle measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
ADCPAN(HDU.PRIMARY, VALUE.REAL, ""),
/**
* ADC position angle measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
ADCPANn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* ADC linear position sensor measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
ADCPOS(HDU.PRIMARY, VALUE.REAL, ""),
/**
* ADC linear position sensor measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
ADCPOSn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* ADC pressure sensor measurements in appropriate units.
*
* units = UNITPRES
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
ADCPRE(HDU.PRIMARY, VALUE.REAL, ""),
/**
* ADC pressure sensor measurements in appropriate units.
*
* units = UNITPRES
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
ADCPREn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* ADC status.
*
* units = 'dictionary'
*
*
* default value = none
*
*
* index = none
*
*/
ADCSTAT(HDU.PRIMARY, VALUE.STRING, ""),
/**
* Atmospheric dispersion compensator software identification.
*
* default value = none
*
*
* index = none
*
*/
ADCSWV(HDU.PRIMARY, VALUE.STRING, "ADC software version"),
/**
* ADC temperature sensor measurements in degrees Celsius.
*
* units = UNITTEMP
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
ADCTEM(HDU.PRIMARY, VALUE.REAL, ""),
/**
* ADC temperature sensor measurements in degrees Celsius.
*
* units = UNITTEMP
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
ADCTEMn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* ADC voltage sensor measurements in volts.
*
* units = UNITVOLT
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
ADCVOL(HDU.PRIMARY, VALUE.REAL, ""),
/**
* ADC voltage sensor measurements in volts.
*
* units = UNITVOLT
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
ADCVOLn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Declination of the aperture(s).
*
* units = APDECU ADEU%4d
*
*
* default value = OBJDEC ODEC%4d
*
*
* index = none 1-9999
*
*/
ADECnnn(HDU.PRIMARY, VALUE.STRING, "Aperture declination"),
/**
* Declination unit.
*
* default value = OBJDECU APDECU
*
*
* index = none 1-9999
*
*/
ADEUnnn(HDU.PRIMARY, VALUE.STRING, "Declination unit"),
/**
* Object declination for wavefront sensing.
*
* units = ADODECU
*
*
* default value = none
*
*
* index = none
*
*/
ADODEC(HDU.PRIMARY, VALUE.STRING, "Adaptive optics object declination"),
/**
* Declination unit.
*
* default value = none
*
*
* index = none
*
*/
ADODECU(HDU.PRIMARY, VALUE.STRING, "Declination unit"),
/**
* Object coordinate epoch for wavefront sensing.
*
* default value = TELEPOCH
*
*
* index = none
*
*/
ADOEPOCH(HDU.PRIMARY, VALUE.NONE, ""),
/**
* Object coordinate system equinox for wavefront sensing. A value before
* 1984 is Besselian otherwise it is Julian.
*
* default value = TELEQUIN
*
*
* index = none
*
*/
ADOEQUIN(HDU.PRIMARY, VALUE.REAL, ""),
/**
*
* default value = none
*
*
* index = none
*
*/
ADOFREQ(HDU.PRIMARY, VALUE.NONE, ""),
/**
*
* default value = none
*
*
* index = none
*
*/
ADOHWV(HDU.PRIMARY, VALUE.NONE, ""),
/**
* Times for the adaptive optics sensor measurements given as modified
* Julian dates.
*
* units = 'd'
*
*
* default value = MJDHDR ADOMJD
*
*
* index = none 1-999
*
*/
ADOMJD(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Times for the adaptive optics sensor measurements given as modified
* Julian dates.
*
* units = 'd'
*
*
* default value = MJDHDR ADOMJD
*
*
* index = none 1-999
*
*/
ADOMJDn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Adaptive optics system position angle measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
ADOPAN(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Adaptive optics system position angle measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
ADOPANn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Adaptive optics system linear position sensor measurements in appropriate
* units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
ADOPOS(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Adaptive optics system linear position sensor measurements in appropriate
* units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
ADOPOSn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Adaptive optics system pressure sensor measurements in appropriate units.
*
* units = UNITPRES
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
ADOPRE(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Adaptive optics system pressure sensor measurements in appropriate units.
*
* units = UNITPRES
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
ADOPREn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Object right ascension for wavefront sensing.
*
* units = ADORAU
*
*
* default value = none
*
*
* index = none
*
*/
ADORA(HDU.PRIMARY, VALUE.STRING, "Adaptive optics object right ascension"),
/**
* Object coordinate system type for wavefront sensing.
*
* default value = TELRADEC
*
*
* index = none
*
*/
ADORADEC(HDU.PRIMARY, VALUE.STRING, ""),
/**
* Right ascension unit.
*
* default value = none
*
*
* index = none
*
*/
ADORAU(HDU.PRIMARY, VALUE.STRING, "Right ascension unit"),
/**
*
* default value = none
*
*
* index = none
*
*/
ADOSTAT(HDU.PRIMARY, VALUE.NONE, ""),
/**
*
* default value = none
*
*
* index = none
*
*/
ADOSWV(HDU.PRIMARY, VALUE.NONE, ""),
/**
* Adaptive optics system temperature sensor measurements in degrees
* Celsius.
*
* units = UNITTEMP
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
ADOTEM(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Adaptive optics system temperature sensor measurements in degrees
* Celsius.
*
* units = UNITTEMP
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
ADOTEMn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Type of object used for wavefront sensing.
*
* default value = none
*
*
* index = none
*
*/
ADOTYPE(HDU.PRIMARY, VALUE.STRING, "Adaptive optics object type"),
/**
* Adaptive optics system voltage sensor measurements in volts.
*
* units = UNITVOLT
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
ADOVOL(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Adaptive optics system voltage sensor measurements in volts.
*
* units = UNITVOLT
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
ADOVOLn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Epoch of the coordinates for the aperture(s).
*
* units = 'yr'
*
*
* default value = OBJEPOCH OEPO%4d
*
*
* index = none 1-9999
*
*/
AEPOnnn(HDU.PRIMARY, VALUE.REAL, "Aperture coordinate epoch"),
/**
* Coordinate system equinox for the aperture(s). A value before 1984 is
* Besselian otherwise it is Julian.
*
* units = 'yr'
*
*
* default value = OBJEQUIN OEQU%4d
*
*
* index = none 1-9999
*
*/
AEQUnnn(HDU.PRIMARY, VALUE.REAL, "Aperture coordinate equinox"),
/**
* The computed airmass(es) at the time(s) given by the AMMJDn keywords.
*
* default value = none none
*
*
* index = none 1-9
*
*/
AIRMASSn(HDU.PRIMARY, VALUE.REAL, "Airmass"),
/**
* Times for the airmass calculation given as modified Julian dates. The
* MJDHDR keyword may be used for the time at which the image header is
* created or the MJD-OBS keyword may be used for the time of observation.
*
* units = 'd'
*
*
* default value = MJDHDR AMMJD
*
*
* index = none 1-9
*
*/
AMMJD(HDU.PRIMARY, VALUE.REAL, "MJD of airmass"),
/**
* Times for the airmass calculation given as modified Julian dates. The
* MJDHDR keyword may be used for the time at which the image header is
* created or the MJD-OBS keyword may be used for the time of observation.
*
* units = 'd'
*
*
* default value = MJDHDR AMMJD
*
*
* index = none 1-9
*
*/
AMMJDn(HDU.PRIMARY, VALUE.REAL, "MJD of airmass"),
/**
* Amplifier integration or sample time.
*
* units = 'ns'
*
*
* default value = none
*
*
* index = none
*
*/
AMPINTEG(HDU.PRIMARY_EXTENSION, VALUE.REAL, "Amplifier integration/sample time"),
/**
* Times for the amplifier sensor measurements given as modified Julian
* dates. The MJDHDR keyword may be used for the time at which the image
* header is created or the MJD-OBS keyword may be used for the time of
* observation.
*
* units = 'd'
*
*
* default value = MJD-OBS AMPMJD
*
*
* index = none 1-999
*
*/
AMPMJD(HDU.PRIMARY_EXTENSION, VALUE.REAL, ""),
/**
* Times for the amplifier sensor measurements given as modified Julian
* dates. The MJDHDR keyword may be used for the time at which the image
* header is created or the MJD-OBS keyword may be used for the time of
* observation.
*
* units = 'd'
*
*
* default value = MJD-OBS AMPMJD
*
*
* index = none 1-999
*
*/
AMPMJDn(HDU.PRIMARY_EXTENSION, VALUE.REAL, ""),
/**
* Amplifier name.
*
* default value = none
*
*
* index = none
*
*/
AMPNAME(HDU.EXTENSION, VALUE.STRING, "Amplifier name"),
/**
* CCD amplifier position angle measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
AMPPAN(HDU.PRIMARY_EXTENSION, VALUE.REAL, ""),
/**
* CCD amplifier position angle measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
AMPPANn(HDU.PRIMARY_EXTENSION, VALUE.REAL, ""),
/**
* CCD amplifier linear position sensor measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
AMPPOS(HDU.PRIMARY_EXTENSION, VALUE.REAL, ""),
/**
* CCD amplifier linear position sensor measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
AMPPOSn(HDU.PRIMARY_EXTENSION, VALUE.REAL, ""),
/**
* CCD amplifier pressure sensor measurements in appropriate units.
*
* units = UNITPRES
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
AMPPRE(HDU.PRIMARY_EXTENSION, VALUE.REAL, ""),
/**
* CCD amplifier pressure sensor measurements in appropriate units.
*
* units = UNITPRES
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
AMPPREn(HDU.PRIMARY_EXTENSION, VALUE.REAL, ""),
/**
* Amplifier unbinned pixel read time.
*
* units = 'ns'
*
*
* default value = none none
*
*
* index = none none
*
*/
AMPREAD(HDU.PRIMARY_EXTENSION, VALUE.REAL, "Unbinned pixel read time"),
/**
* CCD amplifier sampling method used. This may also include any integration
* times.
*
* default value = none
*
*
* index = none
*
*/
AMPSAMPL(HDU.PRIMARY_EXTENSION, VALUE.STRING, "Amplifier sampling method"),
/**
* Mapping of the CCD section to amplifier coordinates.
*
* default value = none
*
*
* index = none
*
*/
AMPSEC(HDU.EXTENSION, VALUE.STRING, "Amplifier section"),
/**
* The logical unbinned size of the amplifier readout in section notation.
* This includes drift scanning if applicable.
*
* default value = none
*
*
* index = none
*
*/
AMPSIZE(HDU.EXTENSION, VALUE.STRING, "Amplifier readout size"),
/**
* CCD amplifier temperature sensor measurements in degrees Celsius.
*
* units = UNITTEMP
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
AMPTEM(HDU.PRIMARY_EXTENSION, VALUE.REAL, ""),
/**
* CCD amplifier temperature sensor measurements in degrees Celsius.
*
* units = UNITTEMP
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
AMPTEMn(HDU.PRIMARY_EXTENSION, VALUE.REAL, ""),
/**
* CCD amplifier voltage sensor measurements in volts. }
*
* units = UNITVOLT
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
AMPVOL(HDU.PRIMARY_EXTENSION, VALUE.REAL, ""),
/**
* CCD amplifier voltage sensor measurements in volts. }
*
* units = UNITVOLT
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
AMPVOLn(HDU.PRIMARY_EXTENSION, VALUE.REAL, ""),
/**
* Aperture position angle unit.
*
* default value = PAUNIT APPAUNIT
*
*
* index = none 1-9999
*
*/
APAUnnn(HDU.PRIMARY, VALUE.STRING, "Aperture position angle unit"),
/**
* Declination of the aperture(s).
*
* units = APDECU ADEU%4d
*
*
* default value = OBJDEC ODEC%4d
*
*
* index = none 1-9999
*
*/
APDEC(HDU.PRIMARY, VALUE.STRING, "Aperture declination"),
/**
* Declination unit.
*
* default value = OBJDECU APDECU
*
*
* index = none 1-9999
*
*/
APDECU(HDU.PRIMARY, VALUE.STRING, "Declination unit"),
/**
* Aperture diameter of the aperture(s) for circular apertures and fibers.
* This is also used as an approximation to the size of hexagonal lenses.
*
* units = APUNIT
*
*
* default value = none APERDIA
*
*
* index = none 1-9999
*
*/
APDInnn(HDU.PRIMARY, VALUE.REAL, "Aperture diameter"),
/**
* Epoch of the coordinates for the aperture(s).
*
* units = 'yr'
*
*
* default value = OBJEPOCH OEPO%4d
*
*
* index = none 1-9999
*
*/
APEPOCH(HDU.PRIMARY, VALUE.REAL, "Aperture coordinate epoch"),
/**
* Coordinate system equinox for the aperture(s). A value before 1984 is
* Besselian otherwise it is Julian.
*
* units = 'yr'
*
*
* default value = OBJEQUIN OEQU%4d
*
*
* index = none 1-9999
*
*/
APEQUIN(HDU.PRIMARY, VALUE.REAL, "Aperture coordinate equinox"),
/**
* Aperture diameter of the aperture(s) for circular apertures and fibers.
* This is also used as an approximation to the size of hexagonal lenses.
*
* units = APUNIT
*
*
* default value = none APERDIA
*
*
* index = none 1-9999
*
*/
APERDIA(HDU.PRIMARY, VALUE.REAL, "Aperture diameter"),
/**
* Aperture length of the aperture(s) for slit apertures.
*
* units = APUNIT
*
*
* default value = none APERLEN
*
*
* index = none 1-999
*
*/
APERLEN(HDU.PRIMARY, VALUE.REAL, "Slit length"),
/**
* Aperture identification. This can be a physical aperture identification,
* the name of a mask, a fiber configuration, etc. When there are many
* apertures the keyword APERTURE may be used to specify a configuration or
* mask identification and the APER%4d keywords can be used to identify some
* information about the aperture such as a fiber number.
*
* default value = none APERTURE
*
*
* index = none 1-9999
*
*/
APERnnn(HDU.PRIMARY, VALUE.STRING, "Aperture identification"),
/**
* Aperture position angle of the aperture(s) on the sky. This is measured
* using the longest dimension from north to east for slits. For hexagonal
* lenslets it gives the position angle for one of the sides.
*
* units = APPAUNIT
*
*
* default value = none APERPA
*
*
* index = none 1-9999
*
*/
APERPA(HDU.PRIMARY, VALUE.REAL, "Aperture position angle"),
/**
* Aperture identification. This can be a physical aperture identification,
* the name of a mask, a fiber configuration, etc. When there are many
* apertures the keyword APERTURE may be used to specify a configuration or
* mask identification and the APER%4d keywords can be used to identify some
* information about the aperture such as a fiber number.
*
* default value = none APERTURE
*
*
* index = none 1-9999
*
*/
APERWID(HDU.PRIMARY, VALUE.REAL, "Slit width"),
/**
* Aperture length of the aperture(s) for slit apertures.
*
* units = APUNIT
*
*
* default value = none APERLEN
*
*
* index = none 1-999
*
*/
APLEnnn(HDU.PRIMARY, VALUE.REAL, "Slit length"),
/**
* Aperture position angle of the aperture(s) on the sky. This is measured
* using the longest dimension from north to east for slits. For hexagonal
* lenslets it gives the position angle for one of the sides.
*
* units = APPAUNIT
*
*
* default value = none APERPA
*
*
* index = none 1-9999
*
*/
APPAnnn(HDU.PRIMARY, VALUE.REAL, "Aperture position angle"),
/**
* Aperture position angle unit.
*
* default value = PAUNIT APPAUNIT
*
*
* index = none 1-9999
*
*/
APPAUNIT(HDU.PRIMARY, VALUE.STRING, "Aperture position angle unit"),
/**
* Right ascension of the aperture(s).
*
* units = APRAU ARAU%4d
*
*
* default value = OBJRA ORA%4d
*
*
* index = none 1-9999
*
*/
APRA(HDU.PRIMARY, VALUE.STRING, "Aperture right ascension"),
/**
* Aperture coordinate system type for the aperture(s).
*
* default value = OBJRADEC ORDS%4d
*
*
* index = none 1-9999
*
*/
APRADEC(HDU.PRIMARY, VALUE.STRING, "Aperture coordinate system"),
/**
* Right ascension unit.
*
* default value = OBJRAU APRAU
*
*
* index = none 1-9999
*
*/
APRAU(HDU.PRIMARY, VALUE.STRING, "Right ascension unit"),
/**
* Aperture type. This is an from a dictionary. The common types are "slit",
* "hole", "fiber", "hexlens", "hexlens+fiber" and "none". The last type is
* for aperture-less spectroscopy such as with objective prisms. Typically
* for multiobject spectroscopy all the aperture types will be the same and
* the keyword will be APTYPE.
*
* default value = none APTYPE
*
*
* index = none 1-9999
*
*/
APTYnnn(HDU.PRIMARY, VALUE.STRING, "Aperture type"),
/**
* Aperture type. This is an from a dictionary. The common types are "slit",
* "hole", "fiber", "hexlens", "hexlens+fiber" and "none". The last type is
* for aperture-less spectroscopy such as with objective prisms. Typically
* for multiobject spectroscopy all the aperture types will be the same and
* the keyword will be APTYPE.
*
* default value = none APTYPE
*
*
* index = none 1-9999
*
*/
APTYPE(HDU.PRIMARY, VALUE.STRING, "Aperture type"),
/**
* Units of aperture dimensions. This applies to slit widths and lengths,
* fiber diameters, lenslet diameters, etc. It may be a physical dimension
* or a projected angle on the sky.
*
* default value = UNITAP APUNIT
*
*
* index = none 1-9999
*
*/
APUNIT(HDU.PRIMARY, VALUE.STRING, "Aperture dimension unit"),
/**
* Units of aperture dimensions. This applies to slit widths and lengths,
* fiber diameters, lenslet diameters, etc. It may be a physical dimension
* or a projected angle on the sky.
*
* default value = UNITAP APUNIT
*
*
* index = none 1-9999
*
*/
APUNnnn(HDU.PRIMARY, VALUE.STRING, "Aperture dimension unit"),
/**
* Aperture width of the aperture(s) for slit apertures.
*
* units = APUNIT
*
*
* default value = none APERWID
*
*
* index = none 1-9999
*
*/
APWInnn(HDU.PRIMARY, VALUE.REAL, "Slit width"),
/**
* Right ascension of the aperture(s).
*
* units = APRAU ARAU%4d
*
*
* default value = OBJRA ORA%4d
*
*
* index = none 1-9999
*
*/
ARAnnn(HDU.PRIMARY, VALUE.STRING, "Aperture right ascension"),
/**
* Right ascension unit.
*
* default value = OBJRAU APRAU
*
*
* index = none 1-9999
*
*/
ARAUnnn(HDU.PRIMARY, VALUE.STRING, "Right ascension unit"),
/**
* Archive hardware version.
*
* default value = none
*
*
* index = none
*
*/
ARCHHWV(HDU.PRIMARY, VALUE.STRING, "Archive hardware"),
/**
* Archive identification. This may be the same as the observation
* identification.
*
* default value = OBSID none
*
*
* index = none none
*
*/
ARCHID(HDU.PRIMARY, VALUE.STRING, "Archive identification"),
/**
* The archive name in which the observation is archived.
*
* default value = none
*
*
* index = none
*
*/
ARCHIVE(HDU.PRIMARY, VALUE.STRING, "Archive"),
/**
* Archive status of data.
*
* default value = none
*
*
* index = none
*
*/
ARCHSTAT(HDU.PRIMARY, VALUE.STRING, "Archive status"),
/**
* Archive software version.
*
* default value = none
*
*
* index = none
*
*/
ARCHSWV(HDU.PRIMARY, VALUE.STRING, "Archive software version"),
/**
* Arcon predicted gain. This is the gain measured in the laboratory. The
* GAIN keyword may also have this value initially but it is updated to the
* most recent estimate of the gain.
*
* units = 'e/counts'
*
*
* default value = none
*
*
* index = none
*
*/
ARCONG(HDU.EXTENSION, VALUE.REAL, "Predicted gain"),
/**
* Arcon gain index value.
*
* default value = none
*
*
* index = none
*
*/
ARCONGI(HDU.EXTENSION, VALUE.INTEGER, "Gain selection"),
/**
* Arcon predicted RMS readout noise. This is the value measured in the
* laboratory. The RDNOISE keyword may also have this value initially but it
* is updated to the most current estimate.
*
* units = 'e'
*
*
* default value = none
*
*
* index = none
*
*/
ARCONRN(HDU.EXTENSION, VALUE.REAL, "Predicted readout noise"),
/**
* Arcon waveform complilation date.
*
* default value = none
*
*
* index = none
*
*/
ARCONWD(HDU.PRIMARY_EXTENSION, VALUE.STRING, "Date CCD waveforms last compiled"),
/**
* Arcon waveform options enabled.
*
* default value = none
*
*
* index = none
*
*/
ARCONWM(HDU.PRIMARY_EXTENSION, VALUE.STRING, "Arcon waveform options enabled"),
/**
* Aperture coordinate system type for the aperture(s).
*
* default value = OBJRADEC ORDS%4d
*
*
* index = none 1-9999
*
*/
ARDSnnn(HDU.PRIMARY, VALUE.STRING, "Aperture coordinate system"),
/**
* Transformation matrix between CCD and amplifier coordinates. Normally
* only two values will be non-zero and will have values of 1 or -1. If
* missing the default is an identify matrix.
*
* default value = 0.(i!=j),1.(i=j)
*
*
* index = 1-9,1-9
*
*/
ATMn_n(HDU.EXTENSION, VALUE.REAL, "Amplifier transformation matrix"),
/**
* Transformation origin vector between CCD and amplifier coordinates.
*
* default value = 0.
*
*
* index = 1-9
*
*/
ATVn(HDU.EXTENSION, VALUE.REAL, "Amplifier transformation vector"),
/**
* Section of the recorded image containing overscan or prescan data. This
* will be in binned pixels if binning is done. Multiple regions may be
* recorded and specified, such as both prescan and overscan, but the first
* section given by this parameter is likely to be the one used during
* calibration.
*
* default value = none none
*
*
* index = none 1-9999
*
*/
BIASnnn(HDU.EXTENSION, VALUE.STRING, "Bias section"),
/**
* Section of the recorded image containing overscan or prescan data. This
* will be in binned pixels if binning is done. Multiple regions may be
* recorded and specified, such as both prescan and overscan, but the first
* section given by this parameter is likely to be the one used during
* calibration.
*
* default value = none none
*
*
* index = none 1-9999
*
*/
BIASSEC(HDU.EXTENSION, VALUE.STRING, "Bias section"),
/**
* Description of bad pixels. The value is an IRAF bad pixel mask name.
*
* default value = none
*
*
* index = none
*
*/
BPM(HDU.PRIMARY_EXTENSION, VALUE.STRING, "Bad pixels"),
/**
* Camera configuration.
*
* default value = none
*
*
* index = none
*
*/
CAMCONF(HDU.PRIMARY, VALUE.STRING, "Camera Configuration"),
/**
* Camera name.
*
* default value = none
*
*
* index = none
*
*/
CAMERA(HDU.PRIMARY, VALUE.STRING, "Camera name"),
/**
* Camera focus.
*
* units = 'instrumental'
*
*
* default value = none
*
*
* index = none
*
*/
CAMFOCUS(HDU.PRIMARY, VALUE.REAL, "Camera focus"),
/**
* Camera hardware version.
*
* default value = none
*
*
* index = none
*
*/
CAMHWV(HDU.PRIMARY, VALUE.STRING, "Camera version"),
/**
* Times for the instrument sensor measurements given as modified Julian
* dates.
*
* units = 'd'
*
*
* default value = MJD-OBS CAMMJD
*
*
* index = none 1-999
*
*/
CAMMJD(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Times for the instrument sensor measurements given as modified Julian
* dates.
*
* units = 'd'
*
*
* default value = MJD-OBS CAMMJD
*
*
* index = none 1-999
*
*/
CAMMJDn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Camera position angle measurements in appropriate units.
*
* units = UNITANG
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
CAMPAN(HDU.PRIMARY, VALUE.REAL, "Camera position angle"),
/**
* Camera position angle measurements in appropriate units.
*
* units = UNITANG
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
CAMPANn(HDU.PRIMARY, VALUE.REAL, "Camera position angle"),
/**
* Camera linear position sensor measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
CAMPOS(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Camera linear position sensor measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
CAMPOSn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Camera pressure sensor measurements in appropriate units.
*
* units = UNITPRES
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
CAMPRE(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Camera pressure sensor measurements in appropriate units.
*
* units = UNITPRES
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
CAMPREn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Camera status.
*
* default value = none
*
*
* index = none
*
*/
CAMSTAT(HDU.PRIMARY, VALUE.STRING, "Camera status"),
/**
* Camera software version.
*
* default value = none
*
*
* index = none
*
*/
CAMSWV(HDU.PRIMARY, VALUE.STRING, "Camera software version"),
/**
* Camera temperature sensor measurements in degrees Celsius.
*
* units = UNITTEMP
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
CAMTEM(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Camera temperature sensor measurements in degrees Celsius.
*
* units = UNITTEMP
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
CAMTEMn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Camera voltage sensor measurements in volts.
*
* units = UNITVOLT
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
CAMVOL(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Camera voltage sensor measurements in volts.
*
* units = UNITVOLT
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
CAMVOLn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Declination of the CCD center.
*
* units = CCDDECU
*
*
* default value = DETDEC
*
*
* index = none
*
*/
CCDDEC(HDU.PRIMARY_EXTENSION, VALUE.STRING, "CCD declination"),
/**
* Declination unit.
*
* default value = DETDECU
*
*
* index = none
*
*/
CCDDECU(HDU.PRIMARY_EXTENSION, VALUE.STRING, "Declination unit"),
/**
* Epoch of the CCD center coordinates.
*
* units = 'yr'
*
*
* default value = DETEPOCH
*
*
* index = none
*
*/
CCDEPOCH(HDU.PRIMARY_EXTENSION, VALUE.REAL, "CCD coordinate epoch"),
/**
* CCD coordinate system equinox. A value before 1984 is Besselian otherwise
* it is Julian.
*
* units = 'yr'
*
*
* default value = DETEQUIN
*
*
* index = none
*
*/
CCDEQUIN(HDU.PRIMARY_EXTENSION, VALUE.REAL, "CCD coordinate equinox"),
/**
* CCD hardware version
*
* default value = DETHWV
*
*
* index = none
*
*/
CCDHWV(HDU.PRIMARY_EXTENSION, VALUE.STRING, "CCD version"),
/**
* Times for the CCD sensor measurements given as modified Julian dates. The
* MJDHDR keyword may be used for the time at which the image header is
* created or the MJD-OBS keyword may be used for the time of observation.
*
* units = 'd'
*
*
* default value = MJDHDR CCDMJD
*
*
* index = none 1-999
*
*/
CCDMJD(HDU.PRIMARY_EXTENSION, VALUE.REAL, ""),
/**
* Times for the CCD sensor measurements given as modified Julian dates. The
* MJDHDR keyword may be used for the time at which the image header is
* created or the MJD-OBS keyword may be used for the time of observation.
*
* units = 'd'
*
*
* default value = MJDHDR CCDMJD
*
*
* index = none 1-999
*
*/
CCDMJDn(HDU.PRIMARY_EXTENSION, VALUE.REAL, ""),
/**
* CCD identification.
*
* default value = DETECTOR
*
*
* index = none
*
*/
CCDNAME(HDU.PRIMARY_EXTENSION, VALUE.STRING, "CCD identification"),
/**
* Number of amplifiers used to readout the CCD. This keyword may be absent
* if only one amplifier is used.
*
* default value = 1
*
*
* index = none
*
*/
CCDNAMPS(HDU.PRIMARY_EXTENSION, VALUE.INTEGER, "Number of amplifiers used"),
/**
* CCD position angle measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
CCDPAN(HDU.PRIMARY_EXTENSION, VALUE.REAL, ""),
/**
* CCD position angle measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
CCDPANn(HDU.PRIMARY_EXTENSION, VALUE.REAL, ""),
/**
* CCD linear position sensor measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
CCDPOS(HDU.PRIMARY_EXTENSION, VALUE.REAL, ""),
/**
* CCD linear position sensor measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
CCDPOSn(HDU.PRIMARY_EXTENSION, VALUE.REAL, ""),
/**
* CCD pressure sensor measurements in appropriate units.
*
* units = UNITPRES
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
CCDPRE(HDU.PRIMARY_EXTENSION, VALUE.REAL, ""),
/**
* CCD pressure sensor measurements in appropriate units.
*
* units = UNITPRES
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
CCDPREn(HDU.PRIMARY_EXTENSION, VALUE.REAL, ""),
/**
* The actual format size of the CCD. This is the same as the CCDSIZE
* keyword except in the case of drift scanning.
*
* default value = none
*
*
* index = none
*
*/
CCDPSIZE(HDU.PRIMARY_EXTENSION, VALUE.STRING, "CCD size"),
/**
* Right ascension of the CCD center.
*
* units = CCDRAU
*
*
* default value = DETRA
*
*
* index = none
*
*/
CCDRA(HDU.PRIMARY_EXTENSION, VALUE.STRING, "CCD right ascension"),
/**
* CCD coordinate system type.
*
* default value = DETRADEC
*
*
* index = none
*
*/
CCDRADEC(HDU.PRIMARY_EXTENSION, VALUE.STRING, "CCD coordinate system"),
/**
* Right ascension unit.
*
* default value = DETRAU
*
*
* index = none
*
*/
CCDRAU(HDU.PRIMARY_EXTENSION, VALUE.STRING, "Right ascension unit"),
/**
* The unbinned section of the logical CCD pixel raster covered by the
* amplifier readout in section notation. The section must map directly to
* the specified data section through the binning and CCD to image
* coordiante transformation. The image data section (DATASEC) is specified
* with the starting pixel less than the ending pixel. Thus the order of
* this section may be flipped depending on the coordinate transformation
* (which depends on how the CCD coordinate system is defined).
*
* default value = CCDSIZE
*
*
* index = none
*
*/
CCDSEC(HDU.EXTENSION, VALUE.STRING, "Region of CCD read"),
/**
* The logical unbinned size of the CCD in section notation. Normally this
* would be the physical size of the CCD unless drift scanning is done. This
* is the full size even when subraster readouts are done.
*
* default value = DETSIZE
*
*
* index = none
*
*/
CCDSIZE(HDU.PRIMARY_EXTENSION, VALUE.STRING, "CCD size"),
/**
* CCD on-chip summing given as two or four integer numbers. These define
* the summing of CCD pixels in the amplifier readout order. The first two
* numbers give the number of pixels summed in the serial and parallel
* directions respectively. If the first pixel read out consists of fewer
* unbinned pixels along either direction the next two numbers give the
* number of pixels summed for the first serial and parallel pixels. From
* this it is implicit how many pixels are summed for the last pixels given
* the size of the CCD section (CCDSEC). It is highly recommended that
* controllers read out all pixels with the same summing in which case the
* size of the CCD section will be the summing factors times the size of the
* data section.
*
* default value = '1 1'
*
*
* index = none
*
*/
CCDSUM(HDU.EXTENSION, VALUE.STRING, "CCD on-chip summing"),
/**
* CCD software version
*
* default value = DETSWV
*
*
* index = none
*
*/
CCDSWV(HDU.PRIMARY_EXTENSION, VALUE.STRING, "CCD software version"),
/**
* CCD temperature sensor measurements in degrees Celsius.
*
* units = UNITTEMP
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
CCDTEM(HDU.PRIMARY_EXTENSION, VALUE.REAL, "CCD temperature"),
/**
* CCD temperature sensor measurements in degrees Celsius.
*
* units = UNITTEMP
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
CCDTEMn(HDU.PRIMARY_EXTENSION, VALUE.REAL, "CCD temperature"),
/**
* CCD voltage sensor measurements in volts.
*
* units = UNITVOLT
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
CCDVOL(HDU.PRIMARY_EXTENSION, VALUE.REAL, ""),
/**
* CCD voltage sensor measurements in volts.
*
* units = UNITVOLT
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
CCDVOLn(HDU.PRIMARY_EXTENSION, VALUE.REAL, ""),
/**
* Spectrum coordinate matrix. World coordinate axis 1 is defined to be the
* dispersion and the other axes are spatial. The matrix implies a
* dispersion axis in the image coordinates.
*
* units = CUNIT1/pixel CUN1%4d/pixel
*
*
* default value = 1. CD1_1
*
*
* index = none 1-9999
*
*/
CD1_1(HDU.EXTENSION, VALUE.REAL, "Coordinate scale matrix"),
/**
* Spectrum coordinate matrix. World coordinate axis 1 is defined to be the
* dispersion and the other axes are spatial. The matrix implies a
* dispersion axis in the image coordinates.
*
* units = CUNIT1/pixel CUN1%4d/pixel
*
*
* default value = 0. CD1_2
*
*
* index = none 1-9999
*
*/
CD1_2(HDU.EXTENSION, VALUE.REAL, "Coordinate scale matrix"),
/**
* Spectrum coordinate matrix. World coordinate axis 1 is defined to be the
* dispersion and the other axes are spatial. The matrix implies a
* dispersion axis in the image coordinates.
*
* units = CUNIT1/pixel CUN1%4d/pixel
*
*
* default value = 1. CD1_1
*
*
* index = none 1-9999
*
*/
CD11nnn(HDU.EXTENSION, VALUE.REAL, "Coordinate scale matrix"),
/**
* Spectrum coordinate matrix. World coordinate axis 1 is defined to be the
* dispersion and the other axes are spatial. The matrix implies a
* dispersion axis in the image coordinates.
*
* units = CUNIT1/pixel CUN1%4d/pixel
*
*
* default value = 0. CD1_2
*
*
* index = none 1-9999
*
*/
CD12nnn(HDU.EXTENSION, VALUE.REAL, "Coordinate scale matrix"),
/**
* Spectrum coordinate matrix. World coordinate axis 1 is defined to be the
* dispersion and the other axes are spatial. The matrix implies a
* dispersion axis in the image coordinates.
*
* units = CUNIT2/pixel CUN2%4d/pixel
*
*
* default value = 0. CD2_1
*
*
* index = none 1-9999
*
*/
CD2_1(HDU.EXTENSION, VALUE.REAL, "Coordinate scale matrix"),
/**
* Spectrum coordinate matrix. World coordinate axis 1 is defined to be the
* dispersion and the other axes are spatial. The matrix implies a
* dispersion axis in the image coordinates.
*
* units = CUNIT2/pixel CUN2%4d/pixel
*
*
* default value = 1. CD2_2
*
*
* index = none 1-9999
*
*/
CD2_2(HDU.EXTENSION, VALUE.REAL, "Coordinate scale matrix"),
/**
* Spectrum coordinate matrix. World coordinate axis 1 is defined to be the
* dispersion and the other axes are spatial. The matrix implies a
* dispersion axis in the image coordinates.
*
* units = CUNIT2/pixel CUN2%4d/pixel
*
*
* default value = 0. CD2_1
*
*
* index = none 1-9999
*
*/
CD21nnn(HDU.EXTENSION, VALUE.REAL, "Coordinate scale matrix"),
/**
* Spectrum coordinate matrix. World coordinate axis 1 is defined to be the
* dispersion and the other axes are spatial. The matrix implies a
* dispersion axis in the image coordinates.
*
* units = CUNIT2/pixel CUN2%4d/pixel
*
*
* default value = 1. CD2_2
*
*
* index = none 1-9999
*
*/
CD22nnn(HDU.EXTENSION, VALUE.REAL, "Spec coord matrix"),
/**
* Coordinate scale matrix for image world coordinates. This describes the
* scales and rotations of the coordinate axes.
*
* units = CUNIT2/pixel CUN2%4d/pixel
*
*
* default value = 1. CD2_2
*
*
* index = none 1-9999
*
*/
CHPANGLE(HDU.PRIMARY, VALUE.NONE, ""),
/**
*
* default value = none
*
*
* index = none
*
*/
CHPDIST(HDU.PRIMARY, VALUE.NONE, ""),
/**
*
* default value = none
*
*
* index = none
*
*/
CHPFREQ(HDU.PRIMARY, VALUE.NONE, ""),
/**
*
* default value = none
*
*
* index = none
*
*/
CHPHWV(HDU.PRIMARY, VALUE.NONE, ""),
/**
* Times for the chopping system sensor measurements given as modified
* Julian dates.
*
* units = 'd'
*
*
* default value = MJDHDR CHPMJD
*
*
* index = none 1-999
*
*/
CHPMJD(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Times for the chopping system sensor measurements given as modified
* Julian dates.
*
* units = 'd'
*
*
* default value = MJDHDR CHPMJD
*
*
* index = none 1-999
*
*/
CHPMJDn(HDU.PRIMARY, VALUE.REAL, ""),
/**
*
* default value = none
*
*
* index = none
*
*/
CHPNCHOP(HDU.PRIMARY, VALUE.NONE, ""),
/**
* Chopping system position angle measurements in appropriate units. Note
* that CHPANGLE should be used for the chopping angle and these keywords
* are for other system position angle measurements.
*
* default value = none none
*
*
* index = none 1-999
*
*/
CHPPAN(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Chopping system position angle measurements in appropriate units. Note
* that CHPANGLE should be used for the chopping angle and these keywords
* are for other system position angle measurements.
*
* default value = none none
*
*
* index = none 1-999
*
*/
CHPPANn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Chopping system linear position sensor measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
CHPPOS(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Chopping system linear position sensor measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
CHPPOSn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Chopping system pressure sensor measurements in appropriate units.
*
* units = UNITPRES
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
CHPPRE(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Chopping system pressure sensor measurements in appropriate units.
*
* units = UNITPRES
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
CHPPREn(HDU.PRIMARY, VALUE.REAL, ""),
/**
*
* default value = none
*
*
* index = none
*
*/
CHPSTAT(HDU.PRIMARY, VALUE.NONE, ""),
/**
*
* default value = none
*
*
* index = none
*
*/
CHPSWV(HDU.PRIMARY, VALUE.NONE, ""),
/**
* Chopping system temperature sensor measurements in degrees Celsius.
*
* units = UNITTEMP
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
CHPTEM(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Chopping system temperature sensor measurements in degrees Celsius.
*
* units = UNITTEMP
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
CHPTEMn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Chopping system voltage sensor measurements in volts.
*
* units = UNITVOLT
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
CHPVOL(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Chopping system voltage sensor measurements in volts.
*
* units = UNITVOLT
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
CHPVOLn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Dispersion limit for the region occupied by the spectrum.
*
* units = CUNIT1 CUN1%4d
*
*
* default value = none CMAX1
*
*
* index = none 1-9999
*
*/
CMAX1(HDU.EXTENSION, VALUE.REAL, "Spectrum dispersion limit"),
/**
* Cross-dispersion limit for the region occupied by the spectrum.
*
* units = CUNIT2 CUN2%4d
*
*
* default value = none CMAX2
*
*
* index = none 1-9999
*
*/
CMAX2(HDU.EXTENSION, VALUE.REAL, "Spectrum cross-dispersion limit"),
/**
* Dispersion limit for the region occupied by the spectrum.
*
* units = CUNIT1 CUN1%4d
*
*
* default value = none CMIN1
*
*
* index = none 1-9999
*
*/
CMIN1(HDU.EXTENSION, VALUE.REAL, "Spectrum dispersion limit"),
/**
* Cross-dispersion limit for the region occupied by the spectrum.
*
* units = CUNIT2 CUN2%4d
*
*
* default value = none CMIN2
*
*
* index = none 1-9999
*
*/
CMIN2(HDU.EXTENSION, VALUE.REAL, "Spectrum cross-dispersion limit"),
/**
* Observer comments.
*
* default value = none
*
*
* index = 1-9999
*
*/
CMMTnnn(HDU.PRIMARY, VALUE.STRING, ""),
/**
* Dispersion limit for the region occupied by the spectrum.
*
* units = CUNIT1 CUN1%4d
*
*
* default value = none CMIN1
*
*
* index = none 1-9999
*
*/
CMN1nnn(HDU.EXTENSION, VALUE.REAL, "Spectrum dispersion limit"),
/**
* Cross-dispersion limit for the region occupied by the spectrum.
*
* units = CUNIT2 CUN2%4d
*
*
* default value = none CMIN2
*
*
* index = none 1-9999
*
*/
CMN2nnn(HDU.EXTENSION, VALUE.REAL, "Spectrum cross-dispersion limit"),
/**
* Dispersion limit for the region occupied by the spectrum.
*
* units = CUNIT1 CUN1%4d
*
*
* default value = none CMAX1
*
*
* index = none 1-9999
*
*/
CMX1nnn(HDU.EXTENSION, VALUE.REAL, "Spectrum dispersion limit"),
/**
* Cross-dispersion limit for the region occupied by the spectrum.
*
* units = CUNIT2 CUN2%4d
*
*
* default value = none CMAX2
*
*
* index = none 1-9999
*
*/
CMX2nnn(HDU.EXTENSION, VALUE.REAL, "Spectrum cross-dispersion limit"),
/**
* Controller hardware version.
*
* default value = none
*
*
* index = none
*
*/
CONHWV(HDU.PRIMARY_EXTENSION, VALUE.STRING, "Controller hardware version"),
/**
* Controller status.
*
* default value = none
*
*
* index = none
*
*/
CONSTAT(HDU.PRIMARY_EXTENSION, VALUE.STRING, "Controller status"),
/**
* Controller software version.
*
* default value = none
*
*
* index = none
*
*/
CONSWV(HDU.PRIMARY_EXTENSION, VALUE.STRING, "Controller software version"),
/**
* Detector controller name.
*
* default value = none
*
*
* index = none
*
*/
CONTROLR(HDU.PRIMARY_EXTENSION, VALUE.STRING, "Detector controller"),
/**
* Correctors in the optical path.
*
* default value = none none
*
*
* index = none 1-999
*
*/
CORRCT(HDU.PRIMARY, VALUE.STRING, "Corrector"),
/**
* Correctors in the optical path.
*
* default value = none none
*
*
* index = none 1-999
*
*/
CORRCTn(HDU.PRIMARY, VALUE.STRING, "Corrector"),
/**
* Correctors in the optical path.
*
* default value = none
*
*
* index = none
*
*/
CORRCTOR(HDU.PRIMARY, VALUE.STRING, "Corrector Identification"),
/**
* Default cross dispersion unit.
*
* default value = 'arcsec'
*
*
* index = none
*
*/
CROSUNIT(HDU.PRIMARY_EXTENSION, VALUE.STRING, "Declination unit"),
/**
* Default cross dispersion coordinate value.
*
* units = CROSUNIT
*
*
* default value = none
*
*
* index = none
*
*/
CROSVAL(HDU.PRIMARY_EXTENSION, VALUE.REAL, "Cross dispersion coordinate"),
/**
* Reference spectrum pixel coordinate. Generally this should be the at the
* center of the spectrum. In raw data the spectrum position(s) may be
* predicted apart from an offset that will be determined during data
* reduction.
*
* units = 'pixel' 'pixel'
*
*
* default value = none CRPIX1
*
*
* index = none 1-9999
*
*/
CRP1nnn(HDU.EXTENSION, VALUE.REAL, "Coordinate reference pixel"),
/**
* Reference spectrum pixel coordinate. Generally this should be the at the
* center of the spectrum. In raw data the spectrum position(s) may be
* predicted apart from an offset that will be determined during data
* reduction.
*
* units = 'pixel' 'pixel'
*
*
* default value = none CRPIX2
*
*
* index = none 1-9999
*
*/
CRP2nnn(HDU.EXTENSION, VALUE.REAL, "Coordinate reference pixel"),
/**
* Reference spectrum pixel coordinate. Generally this should be the at the
* center of the spectrum. In raw data the spectrum position(s) may be
* predicted apart from an offset that will be determined during data
* reduction.
*
* units = 'pixel' 'pixel'
*
*
* default value = none CRPIX1
*
*
* index = none 1-9999
*
*/
CRPIX1(HDU.EXTENSION, VALUE.REAL, "Coordinate reference pixel"),
/**
* Reference spectrum pixel coordinate. Generally this should be the at the
* center of the spectrum. In raw data the spectrum position(s) may be
* predicted apart from an offset that will be determined during data
* reduction.
*
* units = 'pixel' 'pixel'
*
*
* default value = none CRPIX2
*
*
* index = none 1-9999
*
*/
CRPIX2(HDU.EXTENSION, VALUE.REAL, "Coordinate reference pixel"),
/**
* Spectrum reference dispersion coordinate corresponding to the spectrum
* reference pixel coordinate. Note that by definition WCS axis 1 is always
* the dispersion axis. The mapping of this WCS axis to the dispersion
* direction in the image is given by the coordinate transformation matrix
* keywords. In raw data the reference dispersion coordinate may be
* approximately predicted. This will be refined during data reductions.
*
* units = CUNIT1 CUN1%4d
*
*
* default value = none CRVAL1
*
*
* index = none 1-9999
*
*/
CRV1nnn(HDU.EXTENSION, VALUE.REAL, "Coordinate reference value"),
/**
* Spectrum reference dispersion coordinate corresponding to the spectrum
* reference pixel coordinate. Note that by definition WCS axis 1 is always
* the dispersion axis. The mapping of this WCS axis to the dispersion
* direction in the image is given by the coordinate transformation matrix
* keywords. In raw data the reference dispersion coordinate may be
* approximately predicted. This will be refined during data reductions.
*
* units = CUNIT1 CUN1%4d
*
*
* default value = 0. CRVAL1
*
*
* index = none 1-9999
*
*/
CRV2nnn(HDU.EXTENSION, VALUE.REAL, "Coordinate reference value"),
/**
* Spectrum reference dispersion coordinate corresponding to the spectrum
* reference pixel coordinate. Note that by definition WCS axis 1 is always
* the dispersion axis. The mapping of this WCS axis to the dispersion
* direction in the image is given by the coordinate transformation matrix
* keywords. In raw data the reference dispersion coordinate may be
* approximately predicted. This will be refined during data reductions.
*
* units = CUNIT1 CUN1%4d
*
*
* default value = none CRVAL1
*
*
* index = none 1-9999
*
*/
CRVAL1(HDU.EXTENSION, VALUE.REAL, "Spectrum dispersion center"),
/**
* Reference right ascension coordinate corresponding to the image reference
* pixel coordinate. Note that by definition WCS axis 1 is always the right
* ascension axis. The mapping of this WCS axis to the right ascension
* direction in the image is given by the coordinate transformation matrix
* keywords. In raw data the reference right ascension coordinate may be
* only approximate. This will be refined during data reductions.
*
* units = CUNIT1 CUN1%4d
*
*
* default value = 0. CRVAL1
*
*
* index = none 1-9999
*
*/
CRVAL2(HDU.EXTENSION, VALUE.REAL, "Spectrum cross-dispersion center"),
/**
* Reference declination coordinate corresponding to the image reference
* pixel coordinate. Note that by definition WCS axis 1 is always the
* declination axis. The mapping of this WCS axis to the declination
* direction in the image is given by the coordinate transformation matrix
* keywords. In raw data the reference right ascension coordinate may be
* only approximate. This will be refined during data reductions.
*
* units = CUNIT2 CUN2%4d
*
*
* default value = 0. CRVAL2
*
*
* index = none 1-9999
*
*/
CTY1nnn(HDU.EXTENSION, VALUE.STRING, "Spectrum coordinate type"),
/**
* Coordinate type for image world coordinates. The IRAF WCS standards are
* used (which is generally the FITS standard).
*
* default value = 'LINEAR' CTYPE1
*
*
* index = none 1-9999
*
*/
CTY2nnn(HDU.EXTENSION, VALUE.STRING, "Spectrum coordinate type"),
/**
* Coordinate type for image world coordinates. The IRAF WCS standards are
* used (which is generally the FITS standard).
*
* default value = 'LINEAR' CTYPE2
*
*
* index = none 1-9999
*
*/
CTYP2nnn(HDU.EXTENSION, VALUE.STRING, "Coordinate type"),
/**
* Spectrum dispersion coordinate type. These are the FITS defined types.
*
* default value = 'LINEAR' CTYPE1
*
*
* index = none 1-9999
*
*/
CTYPE1(HDU.EXTENSION, VALUE.STRING, "Spectrum coordinate type"),
/**
* Coordinate type for image world coordinates. The IRAF WCS standards are
* used (which is generally the FITS standard).
*
* default value = 'LINEAR' CTYPE1
*
*
* index = none 1-9999
*
*/
CTYPE2(HDU.EXTENSION, VALUE.STRING, "Spectrum coordinate type"),
/**
* Coordinate type for image world coordinates. The IRAF WCS standards are
* used (which is generally the FITS standard).
*
* default value = 'LINEAR' CTYPE2
*
*
* index = none 1-9999
*
*/
CUN1nnn(HDU.EXTENSION, VALUE.STRING, "Spectrum coordinate unit"),
/**
* Coordinate reference unit for direct imaging world coordinates.
*
* default value = RAUNIT CUNIT1
*
*
* index = none 1-9999
*
*/
CUN2nnn(HDU.EXTENSION, VALUE.STRING, "Spectrum coordinate unit"),
/**
* Coordinate reference unit for direct imaging world coordinates.
*
* default value = DECUNIT CUNIT2
*
*
* index = none 1-9999
*
*/
CUNIT1(HDU.EXTENSION, VALUE.STRING, "Spectrum coordinate unit"),
/**
* Coordinate reference unit for direct imaging world coordinates.
*
* default value = RAUNIT CUNIT1
*
*
* index = none 1-9999
*
*/
CUNIT2(HDU.EXTENSION, VALUE.STRING, "Coordinate reference unit"),
/**
* Total dark time of the observation. This is the total time during which
* dark current is collected by the detector. If the times in the extension
* are different the primary HDU gives one of the extension times.
*
* units = UNITTIME
*
*
* default value = EXPTIME
*
*
* index = none
*
*/
DARKTIME(HDU.PRIMARY_EXTENSION, VALUE.REAL, "Dark time"),
/**
* Mapping of the CCD section to image coordinates.
*
* default value = none
*
*
* index = none
*
*/
DATASEC(HDU.EXTENSION, VALUE.STRING, "Image data section"),
/**
* Date at the end of the exposure. The format follows the FITS standard.
*
* default value = none
*
*
* index = none
*
*/
DATEEND(HDU.PRIMARY_EXTENSION, VALUE.STRING, "Date at end of exposure"),
/**
* Date header creation. The format follows the FITS 'date' standard.
*
* default value = DATE-OBS
*
*
* index = none
*
*/
DATEHDR(HDU.PRIMARY_EXTENSION, VALUE.STRING, "Date of header creation"),
/**
* Default date for the observation. This keyword is generally not used and
* is DATE-OBS keyword for the start of the exposure on the detector is
* used.
*
* default value = DATE-OBS
*
*
* index = none
*
*/
DATEOBS(HDU.PRIMARY_EXTENSION, VALUE.STRING, "Date of observation"),
/**
* Projected position angle of the positive declination axis on the
* detector. The position angle is measured clockwise from the image y axis.
*
* units = UNITPA
*
*
* default value = none
*
*
* index = none
*
*/
DECPANGL(HDU.PRIMARY, VALUE.REAL, "Position angle of Dec axis"),
/**
* Default declination units.
*
* default value = UNITDEC
*
*
* index = none
*
*/
DECUNIT(HDU.PRIMARY_EXTENSION, VALUE.STRING, "Declination unit"),
/**
* Detector configuration.
*
* default value = none
*
*
* index = none
*
*/
DETCONF(HDU.PRIMARY, VALUE.STRING, "Detector Configuration"),
/**
* Declination of the detector center.
*
* units = DETDECU
*
*
* default value = TELDEC
*
*
* index = none
*
*/
DETDEC(HDU.PRIMARY, VALUE.STRING, "Detector delination"),
/**
* Declination unit.
*
* default value = TELDECU
*
*
* index = none
*
*/
DETDECU(HDU.PRIMARY, VALUE.STRING, "Delination unit"),
/**
* Detector name.
*
* default value = none
*
*
* index = none
*
*/
DETECTOR(HDU.PRIMARY, VALUE.STRING, "Detector name"),
/**
* Epoch of the detector center coordinates.
*
* units = 'yr'
*
*
* default value = TELEPOCH
*
*
* index = none
*
*/
DETEPOCH(HDU.PRIMARY, VALUE.REAL, "Detector coordinate epoch"),
/**
* Detector coordinate system equinox. A value before 1984 is Besselian
* otherwise it is Julian.
*
* units = 'yr'
*
*
* default value = TELEQUIN
*
*
* index = none
*
*/
DETEQUIN(HDU.PRIMARY, VALUE.REAL, "Detector coordinate equinox"),
/**
* Detector hardware version.
*
* default value = none
*
*
* index = none
*
*/
DETHWV(HDU.PRIMARY, VALUE.STRING, "Detector version"),
/**
* Times for the detector sensor measurements given as modified Julian
* dates. The MJDHDR keyword may be used for the time at which the image
* header is created or the MJD-OBS keyword may be used for the time of
* observation.
*
* units = 'd'
*
*
* default value = MJD-OBS DETMJD
*
*
* index = none 1-999
*
*/
DETMJD(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Times for the detector sensor measurements given as modified Julian
* dates. The MJDHDR keyword may be used for the time at which the image
* header is created or the MJD-OBS keyword may be used for the time of
* observation.
*
* units = 'd'
*
*
* default value = MJD-OBS DETMJD
*
*
* index = none 1-999
*
*/
DETMJDn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Detector position angle measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
DETPAN(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Detector position angle measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
DETPANn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Detector linear position sensor measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
DETPOS(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Detector linear position sensor measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
DETPOSn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Detector pressure sensor measurements in appropriate units.
*
* units = UNITPRES
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
DETPRE(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Detector pressure sensor measurements in appropriate units.
*
* units = UNITPRES
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
DETPREn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Right ascension of the detector center.
*
* units = DETRAU
*
*
* default value = TELRA
*
*
* index = none
*
*/
DETRA(HDU.PRIMARY_EXTENSION, VALUE.STRING, "Detector right ascension"),
/**
* Detector coordinate system type.
*
* default value = TELRADEC
*
*
* index = none
*
*/
DETRADEC(HDU.PRIMARY, VALUE.STRING, "Detector coordinate system"),
/**
* Right ascension unit.
*
* default value = TELRAU
*
*
* index = none
*
*/
DETRAU(HDU.PRIMARY_EXTENSION, VALUE.STRING, "Right ascension unit"),
/**
* Mapping of the CCD section to detector coordinates.
*
* default value = none
*
*
* index = none
*
*/
DETSEC(HDU.EXTENSION, VALUE.STRING, "Detector data section"),
/**
* The logical unbinned size of the detector in section notation. This is
* the full pixel raster size including, if applicable, drift scanning or a
* mosaic format. This is the full size even when subraster readouts are
* done.
*
* default value = none
*
*
* index = none
*
*/
DETSIZE(HDU.PRIMARY, VALUE.STRING, "Detector size"),
/**
* Detector status.
*
* default value = none
*
*
* index = none
*
*/
DETSTAT(HDU.PRIMARY, VALUE.STRING, "Detector status"),
/**
* Detector software version. This will not generally be used and the
* controller software version will apply.
*
* default value = none
*
*
* index = none
*
*/
DETSWV(HDU.PRIMARY, VALUE.STRING, "Detector software version"),
/**
* Detector temperature sensor measurements in degrees Celsius.
*
* units = UNITTEMP
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
DETTEM(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Detector temperature sensor measurements in degrees Celsius.
*
* units = UNITTEMP
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
DETTEMn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Detector voltage sensor measurements in volts.
*
* units = UNITVOLT
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
DETVOL(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Detector voltage sensor measurements in volts.
*
* units = UNITVOLT
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
DETVOLn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Dewar identification.
*
* default value = none
*
*
* index = none
*
*/
DEWAR(HDU.PRIMARY, VALUE.STRING, "Dewar"),
/**
* Dewar hardware version.
*
* default value = none
*
*
* index = none
*
*/
DEWHWV(HDU.PRIMARY_EXTENSION, VALUE.STRING, "Dewar hardware"),
/**
* Times for the dewar sensor measurements given as modified Julian dates.
* The MJDHDR keyword may be used for the time at which the image header is
* created or the MJD-OBS keyword may be used for the time of observation.
*
* units = 'd'
*
*
* default value = MJD-OBS DEWMJD
*
*
* index = none 1-999
*
*/
DEWMJD(HDU.PRIMARY_EXTENSION, VALUE.REAL, ""),
/**
* Times for the dewar sensor measurements given as modified Julian dates.
* The MJDHDR keyword may be used for the time at which the image header is
* created or the MJD-OBS keyword may be used for the time of observation.
*
* units = 'd'
*
*
* default value = MJD-OBS DEWMJD
*
*
* index = none 1-999
*
*/
DEWMJDn(HDU.PRIMARY_EXTENSION, VALUE.REAL, ""),
/**
* Dewar position angle measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
DEWPAN(HDU.PRIMARY_EXTENSION, VALUE.REAL, ""),
/**
* Dewar position angle measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
DEWPANn(HDU.PRIMARY_EXTENSION, VALUE.REAL, ""),
/**
* Dewar linear position sensor measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
DEWPOS(HDU.PRIMARY_EXTENSION, VALUE.REAL, ""),
/**
* Dewar linear position sensor measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
DEWPOSn(HDU.PRIMARY_EXTENSION, VALUE.REAL, ""),
/**
* Dewar pressure sensor measurements in appropriate units.
*
* units = UNITPRES
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
DEWPRE(HDU.PRIMARY_EXTENSION, VALUE.REAL, ""),
/**
* Dewar pressure sensor measurements in appropriate units.
*
* units = UNITPRES
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
DEWPREn(HDU.PRIMARY_EXTENSION, VALUE.REAL, ""),
/**
* Dewar status.
*
* default value = none
*
*
* index = none
*
*/
DEWSTAT(HDU.PRIMARY_EXTENSION, VALUE.STRING, "Dewar status"),
/**
* Dewar software version.
*
* default value = none
*
*
* index = none
*
*/
DEWSWV(HDU.PRIMARY_EXTENSION, VALUE.STRING, "Dewar software version"),
/**
* Dewar temperature sensor measurements in degrees Celsius.
*
* units = UNITTEMP
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
DEWTEM(HDU.PRIMARY_EXTENSION, VALUE.REAL, "Dewar temperature"),
/**
* Dewar temperature sensor measurements in degrees Celsius.
*
* units = UNITTEMP
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
DEWTEMn(HDU.PRIMARY_EXTENSION, VALUE.REAL, "Dewar temperature"),
/**
* Dewar voltage sensor measurements in volts.
*
* units = UNITVOLT
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
DEWVOL(HDU.PRIMARY_EXTENSION, VALUE.REAL, ""),
/**
* Dewar voltage sensor measurements in volts.
*
* units = UNITVOLT
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
DEWVOLn(HDU.PRIMARY_EXTENSION, VALUE.REAL, ""),
/**
* Times for the disperser sensor measurements given as modified Julian
* dates.
*
* units = 'd'
*
*
* default value = MJD-OBS DISMJD
*
*
* index = none 1-999
*
*/
DISMJD(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Times for the disperser sensor measurements given as modified Julian
* dates.
*
* units = 'd'
*
*
* default value = MJD-OBS DISMJD
*
*
* index = none 1-999
*
*/
DISMJDn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Disperser position angle measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
DISPAN(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Disperser position angle measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
DISPANn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* The detector axis along which the dispersion is most closely aligned.
*
* default value = none
*
*
* index = none
*
*/
DISPAXIS(HDU.PRIMARY, VALUE.INTEGER, "Dispersion axis"),
/**
* Approximate central dispersion/pixel on the detector.
*
* units = DISPUNIT
*
*
* default value = none
*
*
* index = none
*
*/
DISPDW(HDU.PRIMARY, VALUE.REAL, "Dispersion"),
/**
* Disperser identification names.
*
* default value = none none
*
*
* index = none 1-999
*
*/
DISPER(HDU.PRIMARY, VALUE.STRING, "Disperser"),
/**
* Disperser identification names.
*
* default value = none none
*
*
* index = none 1-999
*
*/
DISPERn(HDU.PRIMARY, VALUE.STRING, "Disperser"),
/**
* Disperser linear position sensor measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
DISPOS(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Disperser linear position sensor measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
DISPOSn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Disperser pressure sensor measurements in appropriate units.
*
* units = UNITPRES
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
DISPRE(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Disperser pressure sensor measurements in appropriate units.
*
* units = UNITPRES
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
DISPREn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Default dispersion coordinate unit.
*
* default value = 'Angstrom'
*
*
* index = none
*
*/
DISPUNIT(HDU.PRIMARY_EXTENSION, VALUE.STRING, "Dispersion coordinate unit"),
/**
* Default dispersion coordinate value.
*
* units = DISPUNIT
*
*
* default value = none
*
*
* index = none
*
*/
DISPVAL(HDU.PRIMARY_EXTENSION, VALUE.REAL, "Dispersion coordinate"),
/**
* Approximate central dispersion coordinate on the detector.
*
* units = DISPUNIT
*
*
* default value = none
*
*
* index = none
*
*/
DISPWC(HDU.PRIMARY, VALUE.REAL, "Central dispersion coordinate"),
/**
* Disperser temperature sensor measurements in degrees Celsius.
*
* units = UNITTEMP
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
DISTEM(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Disperser temperature sensor measurements in degrees Celsius.
*
* units = UNITTEMP
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
DISTEMn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Disperser voltage sensor measurements in volts.
*
* units = UNITVOLT
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
DISVOL(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Disperser voltage sensor measurements in volts.
*
* units = UNITVOLT
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
DISVOLn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Average wind direction measurements measured east of north over the
* sampling period inside the dome.
*
* units = UNITPA
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
DMEDIR(HDU.PRIMARY, VALUE.REAL, "Average wind direction"),
/**
* Average wind direction measurements measured east of north over the
* sampling period inside the dome.
*
* units = UNITPA
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
DMEDIRn(HDU.PRIMARY, VALUE.REAL, "Average wind direction"),
/**
* Maximum wind speed over the sampling period inside the dome.
*
* units = UNITVEL
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
DMEGUS(HDU.PRIMARY, VALUE.REAL, "Maximum dome wind speed"),
/**
* Maximum wind speed over the sampling period inside the dome.
*
* units = UNITVEL
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
DMEGUSn(HDU.PRIMARY, VALUE.REAL, "Maximum dome wind speed"),
/**
* Times for the dome environment measurements given as modified Julian. For
* the wind measurements this is the start of the sampling period.
*
* units = 'd'
*
*
* default value = MJDHDR DMEMJD
*
*
* index = none 1-999
*
*/
DMEMJD(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Times for the dome environment measurements given as modified Julian. For
* the wind measurements this is the start of the sampling period.
*
* units = 'd'
*
*
* default value = MJDHDR DMEMJD
*
*
* index = none 1-999
*
*/
DMEMJDn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Wind sampling period for the wind measurements inside the dome. If no
* value is given then the measurements are assumed to be 'instantaneous'.
*
* units = UNITTIME
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
DMEPER(HDU.PRIMARY, VALUE.REAL, "Dome wind sampling"),
/**
* Wind sampling period for the wind measurements inside the dome. If no
* value is given then the measurements are assumed to be 'instantaneous'.
*
* units = UNITTIME
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
DMEPERn(HDU.PRIMARY, VALUE.REAL, "Dome wind sampling"),
/**
* Temperatures Celsius inside the dome.
*
* units = UNITTEMP
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
DMETEM(HDU.PRIMARY, VALUE.REAL, "Dome temperature"),
/**
* Temperatures Celsius inside the dome.
*
* units = UNITTEMP
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
DMETEMn(HDU.PRIMARY, VALUE.REAL, "Dome temperature"),
/**
* Average wind speeds over the sampling period inside the dome.
*
* units = UNITVEL
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
DMEWIN(HDU.PRIMARY, VALUE.REAL, "Average dome wind speed"),
/**
* Average wind speeds over the sampling period inside the dome.
*
* units = UNITVEL
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
DMEWINn(HDU.PRIMARY, VALUE.REAL, "Average dome wind speed"),
/**
* Times for the dome sensor measurements given as modified Julian dates.
*
* units = 'd'
*
*
* default value = MJDHDR DOMMJD
*
*
* index = none 1-999
*
*/
DOMMJD(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Times for the dome sensor measurements given as modified Julian dates.
*
* units = 'd'
*
*
* default value = MJDHDR DOMMJD
*
*
* index = none 1-999
*
*/
DOMMJDn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Dome position angle sensor measurements. This should be in degrees east
* of north for the center of the dome slit.
*
* default value = none none
*
*
* index = none 1-999
*
*/
DOMPAN(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Dome position angle sensor measurements. This should be in degrees east
* of north for the center of the dome slit.
*
* default value = none none
*
*
* index = none 1-999
*
*/
DOMPANn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Dome linear position sensor measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
DOMPOS(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Dome linear position sensor measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
DOMPOSn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Dome pressure sensor measurements in appropriate units.
*
* units = UNITPRES
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
DOMPRE(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Dome pressure sensor measurements in appropriate units.
*
* units = UNITPRES
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
DOMPREn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Dome status.
*
* default value = none
*
*
* index = none
*
*/
DOMSTAT(HDU.PRIMARY, VALUE.STRING, "Dome status"),
/**
* Dome temperature sensor measurements in degrees Celsius.
*
* units = UNITTEMP
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
DOMTEM(HDU.PRIMARY, VALUE.REAL, "Dome temperature"),
/**
* Dome temperature sensor measurements in degrees Celsius.
*
* units = UNITTEMP
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
DOMTEMn(HDU.PRIMARY, VALUE.REAL, "Dome temperature"),
/**
* Dome voltage sensor measurements in volts.
*
* units = UNITVOLT
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
DOMVOL(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Dome voltage sensor measurements in volts.
*
* units = UNITVOLT
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
DOMVOLn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Transformation matrix between CCD and detector coordinates. If missing
* the default is an identify matrix.
*
* default value = 0.(i!=j),1.(i=j)
*
*
* index = 1-9,1-9
*
*/
DTMn_n(HDU.EXTENSION, VALUE.REAL, "Detector transformation matrix"),
/**
* Transformation origin vector between CCD and detector coordinates.
*
* default value = 0.
*
*
* index = 1-9
*
*/
DTVn(HDU.EXTENSION, VALUE.REAL, "Detector transformation vector"),
/**
* Average wind direction measurements measured east of north over the
* sampling period outside the dome at times given by ENVMJDn keywords.
*
* units = UNITPA
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
ENVDIR(HDU.PRIMARY, VALUE.REAL, "Average wind direction"),
/**
* Average wind direction measurements measured east of north over the
* sampling period outside the dome at times given by ENVMJDn keywords.
*
* units = UNITPA
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
ENVDIRn(HDU.PRIMARY, VALUE.REAL, "Average wind direction"),
/**
* Maximum wind speed in km/s over the sampling period outside the dome at
* times given by ENVMJDn keywords.
*
* units = UNITVEL
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
ENVGUS(HDU.PRIMARY, VALUE.REAL, "Maximum gust speed"),
/**
* Maximum wind speed in km/s over the sampling period outside the dome at
* times given by ENVMJDn keywords.
*
* units = UNITVEL
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
ENVGUSn(HDU.PRIMARY, VALUE.REAL, "Maximum gust speed"),
/**
* Relative humidity measurements at times given by ENVMJDn keywords.
*
* units = '%'
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
ENVHUM(HDU.PRIMARY, VALUE.REAL, "Relative humidity"),
/**
* Relative humidity measurements at times given by ENVMJDn keywords.
*
* units = '%'
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
ENVHUMn(HDU.PRIMARY, VALUE.REAL, "Relative humidity"),
/**
* Times for the site environment measurements given as modified Julian. For
* the wind measurements this is the start of the sampling period.
*
* units = 'd'
*
*
* default value = MJDHDR ENVMJD
*
*
* index = none 1-999
*
*/
ENVMJD(HDU.PRIMARY, VALUE.REAL, "Environment measurement time"),
/**
* Times for the site environment measurements given as modified Julian. For
* the wind measurements this is the start of the sampling period.
*
* units = 'd'
*
*
* default value = MJDHDR ENVMJD
*
*
* index = none 1-999
*
*/
ENVMJDn(HDU.PRIMARY, VALUE.REAL, "Environment measurement time"),
/**
* Wind sampling period for the wind measurements outside the dome at times
* given by ENVMJDn keywords. If no value is given then the measurements are
* assumed to be 'instantaneous'.
*
* units = UNITTIME
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
ENVPER(HDU.PRIMARY, VALUE.REAL, "Wind sampling period"),
/**
* Wind sampling period for the wind measurements outside the dome at times
* given by ENVMJDn keywords. If no value is given then the measurements are
* assumed to be 'instantaneous'.
*
* units = UNITTIME
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
ENVPERn(HDU.PRIMARY, VALUE.REAL, "Wind sampling period"),
/**
* Atmospheric pressure measurements at times given by ENVMJDn keywords.
*
* units = UNITPRES
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
ENVPRE(HDU.PRIMARY, VALUE.REAL, "Air pressure"),
/**
* Atmospheric pressure measurements at times given by ENVMJDn keywords.
*
* units = UNITPRES
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
ENVPREn(HDU.PRIMARY, VALUE.REAL, "Air pressure"),
/**
* Temperatures outside the dome at times given by ENVMJDn keywords.
*
* units = UNITTEMP
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
ENVTEM(HDU.PRIMARY, VALUE.REAL, "Site temperature"),
/**
* Temperatures outside the dome at times given by ENVMJDn keywords.
*
* units = UNITTEMP
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
ENVTEMn(HDU.PRIMARY, VALUE.REAL, "Site temperature"),
/**
* Precipitable water vapor measurements at times given by ENVMJDn keywords.
*
* units = 'mm'
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
ENVWAT(HDU.PRIMARY, VALUE.REAL, "Precipitable water vapor"),
/**
* Precipitable water vapor measurements at times given by ENVMJDn keywords.
*
* units = 'mm'
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
ENVWATn(HDU.PRIMARY, VALUE.REAL, "Precipitable water vapor"),
/**
* Average wind speeds over the sampling period outside the dome at times
* given by ENVMJDn keywords.
*
* units = UNITVEL
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
ENVWIN(HDU.PRIMARY, VALUE.REAL, "Average wind speed"),
/**
* Average wind speeds over the sampling period outside the dome at times
* given by ENVMJDn keywords.
*
* units = UNITVEL
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
ENVWINn(HDU.PRIMARY, VALUE.REAL, "Average wind speed"),
/**
* Error information. The sequence numbers are used to order the
* information.
*
* default value = none
*
*
* index = 1-999
*
*/
ERRORnnn(HDU.PRIMARY, VALUE.STRING, ""),
/**
* Requested exposure time of the observation.
*
* units = UNITTIME
*
*
* default value = EXPTIME
*
*
* index = none
*
*/
EXPREQ(HDU.PRIMARY_EXTENSION, VALUE.REAL, "Requested exposure time"),
/**
* Fiber identification for the fiber(s). The string consists of a fiber
* number, an object type number (0=sky, 1=object, etc.), the right
* ascension and declination, and the object name or title. This can replace
* OBJNAME, APRA/OBJRA, and APDEC/OBJDEC.
*
* default value = none none
*
*
* index = none 1-9999
*
*/
FIBER(HDU.PRIMARY, VALUE.STRING, ""),
/**
* Fiber identification for the fiber(s). The string consists of a fiber
* number, an object type number (0=sky, 1=object, etc.), the right
* ascension and declination, and the object name or title. This can replace
* OBJNAME, APRA/OBJRA, and APDEC/OBJDEC.
*
* default value = none none
*
*
* index = none 1-9999
*
*/
FIBnnn(HDU.PRIMARY, VALUE.STRING, ""),
/**
* Filter position given as filter wheel number or other filter system
* position measurement.
*
* units = 'instrumental'
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
FILPOS(HDU.PRIMARY, VALUE.REAL, "Filter system position"),
/**
* Filter position given as filter wheel number or other filter system
* position measurement.
*
* units = 'instrumental'
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
FILPOSn(HDU.PRIMARY, VALUE.REAL, "Filter system position"),
/**
* Filter type. This is the technical specification or observatory
* identification name.
*
* default value = none none
*
*
* index = none 1-999
*
*/
FILTYP(HDU.PRIMARY, VALUE.STRING, "Filter type"),
/**
* Filter type. This is the technical specification or observatory
* identification name.
*
* default value = none none
*
*
* index = none 1-999
*
*/
FILTYPn(HDU.PRIMARY, VALUE.STRING, "Filter type"),
/**
* Number of focus exposures in a focus sequence.
*
* default value = none
*
*
* index = none
*
*/
FOCNEXPO(HDU.PRIMARY, VALUE.INTEGER, "Number of focus exposures"),
/**
* Pixel shift on the detector between exposures in a focus sequence.
*
* units = 'pixel'
*
*
* default value = none
*
*
* index = none
*
*/
FOCSHIFT(HDU.PRIMARY, VALUE.REAL, "Shift between focus exposures"),
/**
* Starting focus value in focus sequence.
*
* units = 'instrumental'
*
*
* default value = none
*
*
* index = none
*
*/
FOCSTART(HDU.PRIMARY, VALUE.REAL, "Starting focus"),
/**
* Focus increment step in focus sequence.
*
* units = 'instrumental'
*
*
* default value = none
*
*
* index = none
*
*/
FOCSTEP(HDU.PRIMARY, VALUE.REAL, "Focus step"),
/**
* Amplifier gain in electrons per analog unit. This is the most current
* estimate of the gain.
*
* units = 'e/count'
*
*
* default value = none
*
*
* index = none
*
*/
GAIN(HDU.EXTENSION, VALUE.REAL, "Amplifier gain"),
/**
* Guider TV name.
*
* default value = TV
*
*
* index = none
*
*/
GTV(HDU.PRIMARY, VALUE.STRING, "Guider TV"),
/**
* Guider TV filter names. This name is the astronomical standard name if
* applicable; i.e. U, B, Gunn I, etc. The filter type and filter device
* position are given by other keywords.
*
* default value = TVFILT GTVFIL
*
*
* index = none 1-999
*
*/
GTVFIL(HDU.PRIMARY, VALUE.STRING, "Filter name"),
/**
* Guider TV filter names. This name is the astronomical standard name if
* applicable; i.e. U, B, Gunn I, etc. The filter type and filter device
* position are given by other keywords.
*
* default value = TVFILT GTVFIL
*
*
* index = none 1-999
*
*/
GTVFILn(HDU.PRIMARY, VALUE.STRING, "Filter name"),
/**
* Guider TV filter position given as filter wheel number or other filter
* system position measurement.
*
* units = 'instrumental'
*
*
* default value = TVFPOS TVFPO%d
*
*
* index = none 1-999
*
*/
GTVFPO(HDU.PRIMARY, VALUE.REAL, "Filter system position"),
/**
* Guider TV filter position given as filter wheel number or other filter
* system position measurement.
*
* units = 'instrumental'
*
*
* default value = TVFPOS TVFPO%d
*
*
* index = none 1-999
*
*/
GTVFPOn(HDU.PRIMARY, VALUE.REAL, "Filter system position"),
/**
* Guider TV filter type. This is the technical specification or observatory
* identification name.
*
* default value = TVFTYP TVFTYP%d
*
*
* index = none 1-999
*
*/
GTVFTY(HDU.PRIMARY, VALUE.STRING, "Filter type"),
/**
* Guider TV filter type. This is the technical specification or observatory
* identification name.
*
* default value = TVFTYP TVFTYP%d
*
*
* index = none 1-999
*
*/
GTVFTYn(HDU.PRIMARY, VALUE.STRING, "Filter type"),
/**
* Guider TV identification and hardware version.
*
* default value = TVHWV
*
*
* index = none
*
*/
GTVHWV(HDU.PRIMARY, VALUE.STRING, ""),
/**
* Times for the guider television sensor measurements given as modified
* Julian dates.
*
* units = 'd'
*
*
* default value = TVMJD%d none
*
*
* index = none 1-999
*
*/
GTVMJD(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Times for the guider television sensor measurements given as modified
* Julian dates.
*
* units = 'd'
*
*
* default value = TVMJD%d none
*
*
* index = none 1-999
*
*/
GTVMJDn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Guider television position angle measurements in appropriate units.
*
* default value = TVPAN TVPAN%d
*
*
* index = none 1-999
*
*/
GTVPAN(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Guider television position angle measurements in appropriate units.
*
* default value = TVPAN TVPAN%d
*
*
* index = none 1-999
*
*/
GTVPANn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Guider television linear position sensor measurements in appropriate
* units.
*
* default value = TVPOS TVPOS%d
*
*
* index = none 1-999
*
*/
GTVPOS(HDU.PRIMARY, VALUE.REAL, "Television position ()"),
/**
* Guider television linear position sensor measurements in appropriate
* units.
*
* default value = TVPOS TVPOS%d
*
*
* index = none 1-999
*
*/
GTVPOSn(HDU.PRIMARY, VALUE.REAL, "Television position ()"),
/**
* Guider television pressure sensor measurements in appropriate units.
*
* units = UNITPRES
*
*
* default value = TVPRE TVPRE%d
*
*
* index = none 1-999
*
*/
GTVPRE(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Guider television pressure sensor measurements in appropriate units.
*
* units = UNITPRES
*
*
* default value = TVPRE TVPRE%d
*
*
* index = none 1-999
*
*/
GTVPREn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Guider TV status.
*
* default value = TVSTAT
*
*
* index = none
*
*/
GTVSTAT(HDU.PRIMARY, VALUE.STRING, ""),
/**
* Guider TV software version.
*
* default value = TVSWV
*
*
* index = none
*
*/
GTVSWV(HDU.PRIMARY, VALUE.NONE, ""),
/**
* Guider television temperature sensor measurements in degrees Celsius.
*
* units = UNITTEMP
*
*
* default value = TVTEMP TVTEMP%d
*
*
* index = none 1-999
*
*/
GTVTEM(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Guider television temperature sensor measurements in degrees Celsius.
*
* units = UNITTEMP
*
*
* default value = TVTEMP TVTEMP%d
*
*
* index = none 1-999
*
*/
GTVTEMn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Guider television voltage sensor measurements in volts.
*
* units = UNITVOLT
*
*
* default value = TVVOL TVVOL%d
*
*
* index = none 1-999
*
*/
GTVVOL(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Guider television voltage sensor measurements in volts.
*
* units = UNITVOLT
*
*
* default value = TVVOL TVVOL%d
*
*
* index = none 1-999
*
*/
GTVVOLn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Guide object declination.
*
* units = GUIDECU
*
*
* default value = none
*
*
* index = none
*
*/
GUIDEC(HDU.PRIMARY, VALUE.STRING, "Guider declination"),
/**
* Declination unit.
*
* default value = none
*
*
* index = none
*
*/
GUIDECU(HDU.PRIMARY, VALUE.STRING, "Declination unit"),
/**
* Guider identification and hardware version.
*
* default value = none
*
*
* index = none
*
*/
GUIDEHWV(HDU.PRIMARY, VALUE.NONE, ""),
/**
* Guider name. Two of the names are 'manual' and 'none' for manual guiding
* or no guider, respectively.
*
* default value = none
*
*
* index = none
*
*/
GUIDER(HDU.PRIMARY, VALUE.STRING, "Guider name"),
/**
* Guider software version.
*
* default value = none
*
*
* index = none
*
*/
GUIDESWV(HDU.PRIMARY, VALUE.NONE, ""),
/**
* Epoch of the guide object coordinates.
*
* default value = TELEPOCH
*
*
* index = none
*
*/
GUIEPOCH(HDU.PRIMARY, VALUE.NONE, ""),
/**
* Guide object coordinate system equinox. A value before 1984 is Besselian
* otherwise it is Julian.
*
* default value = TELEQUIN
*
*
* index = none
*
*/
GUIEQUIN(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Times for the guider sensor measurements given as modified Julian dates.
*
* units = 'd'
*
*
* default value = MJDHDR GUIMJD
*
*
* index = none 1-999
*
*/
GUIMJD(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Times for the guider sensor measurements given as modified Julian dates.
*
* units = 'd'
*
*
* default value = MJDHDR GUIMJD
*
*
* index = none 1-999
*
*/
GUIMJDn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Guider position angle measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
GUIPAN(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Guider position angle measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
GUIPANn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Guider linear position sensor measurements in appropriate units. This
* might be used for guide probe positions.
*
* default value = none none
*
*
* index = none 1-999
*
*/
GUIPOS(HDU.PRIMARY, VALUE.REAL, "Guider position ()"),
/**
* Guider linear position sensor measurements in appropriate units. This
* might be used for guide probe positions.
*
* default value = none none
*
*
* index = none 1-999
*
*/
GUIPOSn(HDU.PRIMARY, VALUE.REAL, "Guider position ()"),
/**
* Guider pressure sensor measurements in appropriate units.
*
* units = UNITPRES
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
GUIPRE(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Guider pressure sensor measurements in appropriate units.
*
* units = UNITPRES
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
GUIPREn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Guide object right ascension.
*
* units = GUIRAU
*
*
* default value = none
*
*
* index = none
*
*/
GUIRA(HDU.PRIMARY, VALUE.STRING, "Guider right ascension"),
/**
* Guide object coordinate system type.
*
* default value = TELRADEC
*
*
* index = none
*
*/
GUIRADEC(HDU.PRIMARY, VALUE.STRING, ""),
/**
* Guider correction rate.
*
* units = UNITFREQ
*
*
* default value = none
*
*
* index = none
*
*/
GUIRATE(HDU.PRIMARY, VALUE.REAL, "Guider rate"),
/**
* Right ascension unit.
*
* default value = none
*
*
* index = none
*
*/
GUIRAU(HDU.PRIMARY, VALUE.STRING, "Right ascension unit"),
/**
* Guider status.
*
* default value = none
*
*
* index = none
*
*/
GUISTAT(HDU.PRIMARY, VALUE.STRING, ""),
/**
* Guider temperature sensor measurements in degrees Celsius.
*
* units = UNITTEMP
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
GUITEM(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Guider temperature sensor measurements in degrees Celsius.
*
* units = UNITTEMP
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
GUITEMn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Guider voltage sensor measurements in volts.
*
* units = UNITVOLT
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
GUIVOL(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Guider voltage sensor measurements in volts.
*
* units = UNITVOLT
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
GUIVOLn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Hour angle at TELMJD.
*
* units = UNITRA
*
*
* default value = none
*
*
* index = none
*
*/
HA(HDU.PRIMARY, VALUE.STRING, "Hour angle"),
/**
* Image creation system hardware version.
*
* default value = none
*
*
* index = none
*
*/
IMAGEHWV(HDU.PRIMARY, VALUE.STRING, "Image creation hardware version"),
/**
* The image identification when there are multiple images within an
* observation. For detectors with CCDs this would be a unique number
* assigned to each amplifier in the detector.
*
* default value = none
*
*
* index = none
*
*/
IMAGEID(HDU.EXTENSION, VALUE.INTEGER, "Image identification"),
/**
* Image creation system software version.
*
* default value = none
*
*
* index = none
*
*/
IMAGESWV(HDU.PRIMARY, VALUE.STRING, "Image creation software version"),
/**
* Instrument focus.
*
* units = 'instrumental'
*
*
* default value = none
*
*
* index = none
*
*/
INSFOCUS(HDU.PRIMARY, VALUE.REAL, "Instrument focus"),
/**
* Times for the instrument sensor measurements given as modified Julian
* dates.
*
* units = 'd'
*
*
* default value = MJD-OBS INSMJD
*
*
* index = none 1-999
*
*/
INSMJD(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Times for the instrument sensor measurements given as modified Julian
* dates.
*
* units = 'd'
*
*
* default value = MJD-OBS INSMJD
*
*
* index = none 1-999
*
*/
INSMJDn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Instrument position angle measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
INSPAN(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Instrument position angle measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
INSPANn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Instrument linear position sensor measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
INSPOS(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Instrument linear position sensor measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
INSPOSn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Instrument pressure sensor measurements in appropriate units.
*
* units = UNITPRES
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
INSPRE(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Instrument pressure sensor measurements in appropriate units.
*
* units = UNITPRES
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
INSPREn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Instrument status.
*
* default value = none
*
*
* index = none
*
*/
INSSTAT(HDU.PRIMARY, VALUE.STRING, "Instrument status"),
/**
* Instrument configuration.
*
* default value = none
*
*
* index = none
*
*/
INSTCONF(HDU.PRIMARY, VALUE.STRING, "Instrument configuration"),
/**
* Instrument temperature sensor measurements in degrees Celsius.
*
* units = UNITTEMP
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
INSTEM(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Instrument temperature sensor measurements in degrees Celsius.
*
* units = UNITTEMP
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
INSTEMn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Instrument hardware version.
*
* default value = none
*
*
* index = none
*
*/
INSTHWV(HDU.PRIMARY, VALUE.STRING, "Instrument hardware version"),
/**
* Instrument software version.
* ------------------------------------------------------------------
*
* default value = none
*
*
* index = none
*
*/
INSTSWV(HDU.PRIMARY, VALUE.STRING, "Instrument software version"),
/**
* Instrument voltage sensor measurements in volts.
*
* units = UNITVOLT
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
INSVOL(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Instrument voltage sensor measurements in volts.
*
* units = UNITVOLT
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
INSVOLn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* The keyword dictionary defining the keywords. This dictionary should be
* archived with the data.
*
* default value = none
*
*
* index = none
*
*/
KWDICT(HDU.PRIMARY, VALUE.STRING, "Keyword dictionary"),
/**
* Calibration lamp name
*
* default value = none
*
*
* index = none
*
*/
LAMP(HDU.PRIMARY, VALUE.STRING, "Calibration lamp"),
/**
* Calibration lamp type.
*
* default value = none
*
*
* index = none
*
*/
LAMPTYPE(HDU.PRIMARY, VALUE.STRING, "Lamp type"),
/**
* Times for the lamp sensor measurements given as modified Julian dates.
* The MJDHDR keyword may be used for the time at which the image header is
* created or the MJD-OBS keyword may be used for the time of observation.
*
* units = 'd'
*
*
* default value = MJD-OBS LMPMJD
*
*
* index = none 1-999
*
*/
LMPMJD(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Times for the lamp sensor measurements given as modified Julian dates.
* The MJDHDR keyword may be used for the time at which the image header is
* created or the MJD-OBS keyword may be used for the time of observation.
*
* units = 'd'
*
*
* default value = MJD-OBS LMPMJD
*
*
* index = none 1-999
*
*/
LMPMJDn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Calibration lamp position angle measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
LMPPAN(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Calibration lamp position angle measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
LMPPANn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Calibration lamp linear position sensor measurements in appropriate
* units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
LMPPOS(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Calibration lamp linear position sensor measurements in appropriate
* units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
LMPPOSn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Calibration lamp pressure sensor measurements in appropriate units.
*
* units = UNITPRES
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
LMPPRE(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Calibration lamp pressure sensor measurements in appropriate units.
*
* units = UNITPRES
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
LMPPREn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Calibration lamp temperature sensor measurements in degrees Celsius.
*
* units = UNITTEMP
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
LMPTEM(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Calibration lamp temperature sensor measurements in degrees Celsius.
*
* units = UNITTEMP
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
LMPTEMn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Calibration lamp voltage sensor measurements in volts.
*
* units = UNITVOLT
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
LMPVOL(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Calibration lamp voltage sensor measurements in volts.
*
* units = UNITVOLT
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
LMPVOLn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Local siderial time at the start of the exposure.
*
* units = UNITHOUR
*
*
* default value = none
*
*
* index = none
*
*/
LST_OBS("LST-OBS", HDU.PRIMARY_EXTENSION, VALUE.STRING, "LST of exposure start"),
/**
* Local siderial time at the end of the exposure.
*
* units = UNITHOUR
*
*
* default value = none
*
*
* index = none
*
*/
LSTEND(HDU.PRIMARY_EXTENSION, VALUE.STRING, "LST at end of exposure"),
/**
* Local siderial time of the header creation.
*
* units = UNITHOUR
*
*
* default value = LST-OBS
*
*
* index = none
*
*/
LSTHDR(HDU.PRIMARY_EXTENSION, VALUE.STRING, "LST of header creation"),
/**
* Default local siderial time for the observation. This keyword is
* generally not used and is LST-OBS keyword for the start of the exposure
* on the detector is used.
*
* units = UNITHOUR
*
*
* default value = LST-OBS
*
*
* index = none
*
*/
LSTOBS(HDU.PRIMARY_EXTENSION, VALUE.STRING, "LST of observation"),
/**
* Transformation matrix between CCD and image coordinates. If missing the
* default is an identify matrix.
*
* default value = 0.(i!=j),1.(i=j)
*
*
* index = 1-9,1-9
*
*/
LTMn_n(HDU.EXTENSION, VALUE.REAL, "Image transformation matrix"),
/**
* Transformation origin vector between CCD and image coordinates.
*
* default value = 0.
*
*
* index = 1-9
*
*/
LTVn(HDU.EXTENSION, VALUE.REAL, "Image transformation vector"),
/**
* The maximum number of scanned (unbinned) lines used to form an output
* line. This is used with drift scanning or a scan table. For long drift
* scans this will be the number of lines in the CCD.
*
* default value = none
*
*
* index = none
*
*/
MAXNSCAN(HDU.EXTENSION, VALUE.INTEGER, "Maximum number of scanned lines"),
/**
* The minimum number of scanned (unbinned) lines used to form an output
* line. This is used with drift scanning or a scan table. This will only
* differ from MAXNSCAN if the initial lines in the output image are from
* the initial ramp-up.
*
* default value = MAXNSCAN
*
*
* index = none
*
*/
MINNSCAN(HDU.EXTENSION, VALUE.INTEGER, "Minimum number of scanned lines"),
/**
* Modified Julian date when the image header was created by the software.
* The fractional part of the date is given to better than a second of time.
* Many header keywords may be sampled or computed at this time and this
* keyword is the default for these.
*
* units = 'd'
*
*
* default value = MJD-OBS
*
*
* index = none
*
*/
MJDHDR(HDU.PRIMARY_EXTENSION, VALUE.REAL, "MJD of header creation"),
/**
* Default modified Julian date for the observation. The fractional part of
* the date is given to better than a second of time. This keyword is
* generally not used and is MJD-OBS keyword for the start of the exposure
* on the detector is used.
*
* units = 'd'
*
*
* default value = MJD-OBS
*
*
* index = none
*
*/
MJDOBS(HDU.PRIMARY_EXTENSION, VALUE.REAL, "MJD of observation"),
/**
* The number of amplifiers in the detector. When there is only a single
* amplifier used it may be absent since the default value is 1.
*
* default value = 1
*
*
* index = none
*
*/
NAMPS(HDU.PRIMARY, VALUE.INTEGER, "Number of Amplifiers"),
/**
* The number of CCDs in the detector. This is used with mosaics of CCD
* detectors. For a single CCD it may be absent since the default value is
* 1.
*
* default value = 1
*
*
* index = none
*
*/
NCCDS(HDU.PRIMARY, VALUE.INTEGER, "Number of CCDs"),
/**
*
* default value = none
*
*
* index = none
*
*/
NODANGLE(HDU.PRIMARY, VALUE.NONE, ""),
/**
*
* default value = none
*
*
* index = none
*
*/
NODDIST(HDU.PRIMARY, VALUE.NONE, ""),
/**
*
* default value = none
*
*
* index = none
*
*/
NODFREQ(HDU.PRIMARY, VALUE.NONE, ""),
/**
*
* default value = none
*
*
* index = none
*
*/
NODHWV(HDU.PRIMARY, VALUE.NONE, ""),
/**
* Times for the nodding system sensor measurements given as modified Julian
* dates.
*
* units = 'd'
*
*
* default value = MJDHDR NODMJD
*
*
* index = none 1-999
*
*/
NODMJD(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Times for the nodding system sensor measurements given as modified Julian
* dates.
*
* units = 'd'
*
*
* default value = MJDHDR NODMJD
*
*
* index = none 1-999
*
*/
NODMJDn(HDU.PRIMARY, VALUE.REAL, ""),
/**
*
* default value = none
*
*
* index = none
*
*/
NODNCHOP(HDU.PRIMARY, VALUE.NONE, ""),
/**
* Nodding position angle measurements in appropriate units. Note that
* NODANGLE should be used for the nodding angle and these keywords are for
* other system position angle measurements.
*
* default value = none none
*
*
* index = none 1-999
*
*/
NODPAN(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Nodding position angle measurements in appropriate units. Note that
* NODANGLE should be used for the nodding angle and these keywords are for
* other system position angle measurements.
*
* default value = none none
*
*
* index = none 1-999
*
*/
NODPANn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Nodding system linear position sensor measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
NODPOS(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Nodding system linear position sensor measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
NODPOSn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Nodding system pressure sensor measurements in appropriate units.
*
* units = UNITPRES
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
NODPRE(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Nodding system pressure sensor measurements in appropriate units.
*
* units = UNITPRES
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
NODPREn(HDU.PRIMARY, VALUE.REAL, ""),
/**
*
* default value = none
*
*
* index = none
*
*/
NODSTAT(HDU.PRIMARY, VALUE.NONE, ""),
/**
*
* default value = none
*
*
* index = none
*
*/
NODSWV(HDU.PRIMARY, VALUE.NONE, ""),
/**
* Nodding system temperature sensor measurements in degrees Celsius.
*
* units = UNITTEMP
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
NODTEM(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Nodding system temperature sensor measurements in degrees Celsius.
*
* units = UNITTEMP
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
NODTEMn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Nodding system voltage sensor measurements in volts.
*
* units = UNITVOLT
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
NODVOL(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Nodding system voltage sensor measurements in volts.
*
* units = UNITVOLT
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
NODVOLn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Number of coadded subexposures. When charge shuffling this gives the
* number of charge shuffled exposures.
*
* default value = 1
*
*
* index = none
*
*/
NSUBEXPS(HDU.PRIMARY_EXTENSION, VALUE.INTEGER, "Number of subexposures"),
/**
* Declination of the target astronomical object(s).
*
* units = OBJDECU ODEU%d
*
*
* default value = DEC none
*
*
* index = none 1-9999
*
*/
OBJDEC(HDU.PRIMARY, VALUE.STRING, "Declination of object"),
/**
* Declination unit.
*
* default value = DECUNIT OBJDECU
*
*
* index = none 1-9999
*
*/
OBJDECU(HDU.PRIMARY, VALUE.STRING, "Declination unit"),
/**
* Epoch of the target astronomical object coordinate(s). This is given in
* years.
*
* units = 'yr'
*
*
* default value = EPOCH OBJEPOCH
*
*
* index = none 1-9999
*
*/
OBJEPOCH(HDU.PRIMARY, VALUE.REAL, "Epoch of object coordinates"),
/**
* Coordinate system equinox for the target astronomical object(s). A value
* before 1984 is Besselian otherwise it is Julian.
*
* units = 'yr'
*
*
* default value = EQUINOX OBJEQUIN
*
*
* index = none 1-9999
*
*/
OBJEQUIN(HDU.PRIMARY, VALUE.REAL, "Object coordinate equinox"),
/**
* Standard reference or catalog name for the target astronomical object(s).
* The name should follow IAU standards. These keywords differ from the
* OBJECT keyword which is used to identify the observation.
*
* default value = OBJECT OBJNAME
*
*
* index = none 1-9999
*
*/
OBJnnn(HDU.PRIMARY, VALUE.STRING, "Target object"),
/**
* Right ascension of the target astronomical object(s).
*
* units = OBJRAU ORAU%4d
*
*
* default value = RA none
*
*
* index = none 1-9999
*
*/
OBJRA(HDU.PRIMARY, VALUE.STRING, "Right ascension of object"),
/**
* Coordinate system type for the target astronomical object(s).
*
* default value = RADECSYS OBJRADEC
*
*
* index = none 1-9999
*
*/
OBJRADEC(HDU.PRIMARY, VALUE.STRING, "Object coordinate system"),
/**
* Right ascension unit.
*
* default value = RAUNIT OBJRAU
*
*
* index = none 1-9999
*
*/
OBJRAU(HDU.PRIMARY, VALUE.STRING, "Right ascension unit"),
/**
* Type of target astronomical object(s). This is taken from a dictionary of
* names yet to be defined. Some common types are 'galaxy', 'star', and
* 'sky'. If not particular object is targeted the type 'field' may be used.
*
* default value = none OBJTYPE
*
*
* index = none 1-9999
*
*/
OBJTnnn(HDU.PRIMARY, VALUE.STRING, "Type of object"),
/**
* Type of target astronomical object(s). This is taken from a dictionary of
* names yet to be defined. Some common types are 'galaxy', 'star', and
* 'sky'. If not particular object is targeted the type 'field' may be used.
*
* default value = none OBJTYPE
*
*
* index = none 1-9999
*
*/
OBJTYPE(HDU.PRIMARY, VALUE.STRING, "Type of object"),
/**
* Declination of the observation. This may be distinct from the object
* coordinates and the telescope coordinates. It may be used to indicate the
* requested observation coordinates.
*
* units = OBSDECU
*
*
* default value = DETDEC
*
*
* index = none
*
*/
OBSDEC(HDU.PRIMARY, VALUE.STRING, "Observation declination"),
/**
* Declination unit.
*
* default value = DETDECU
*
*
* index = none
*
*/
OBSDECU(HDU.PRIMARY, VALUE.STRING, "Declination unit"),
/**
* Epoch of the coordinates used in observation coordinates.
*
* units = 'yr'
*
*
* default value = TELEPOCH
*
*
* index = none
*
*/
OBSEPOCH(HDU.PRIMARY, VALUE.REAL, "Observation coordinate epoch"),
/**
* Equinox of coordinates used in observation coordinates. A value before
* 1984 is Besselian otherwise it is Julian.
*
* units = 'yr'
*
*
* default value = TELEQUIN
*
*
* index = none
*
*/
OBSEQUIN(HDU.PRIMARY, VALUE.REAL, "Observation coordinate equinox"),
/**
* Observatory identification for the site of the observation.
*
* default value = none
*
*
* index = none
*
*/
OBSERVAT(HDU.PRIMARY, VALUE.STRING, "Observatory"),
/**
* The unique observatory observation identification. This serves to
* identify all data from the same observation.
*
* default value = none
*
*
* index = none
*
*/
OBSID(HDU.PRIMARY_EXTENSION, VALUE.STRING, "Observation identification"),
/**
* Right ascension of the observation. This may be distinct from the object
* coordinates and the telescope coordinates. It may be used to indicate the
* requested observation coordinates.
*
* units = OBSRAU
*
*
* default value = DETRA
*
*
* index = none
*
*/
OBSRA(HDU.PRIMARY, VALUE.STRING, "Observation right ascension"),
/**
* Coordinate system used in observation coordinates.
*
* default value = TELRADEC
*
*
* index = none
*
*/
OBSRADEC(HDU.PRIMARY, VALUE.STRING, "Observation coordinate system"),
/**
* Right ascension unit.
*
* default value = DETRAU
*
*
* index = none
*
*/
OBSRAU(HDU.PRIMARY, VALUE.STRING, "Right ascension unit"),
/**
* Name(s) of the observers.
*
* default value = none none
*
*
* index = none 1-9999
*
*/
OBSRVRnn(HDU.PRIMARY, VALUE.STRING, "Observer(s)"),
/**
* Status of the observation.
* -----------------------------------------------------------------
*
* default value = none
*
*
* index = none
*
*/
OBSSTAT(HDU.PRIMARY, VALUE.STRING, "Observation status"),
/**
* The type of observation such as an astronomical exposure or a particular
* type of calibration exposure.
*
* default value = none
*
*
* index = none
*
*/
OBSTYPE(HDU.PRIMARY_EXTENSION, VALUE.STRING, "Observation type"),
/**
* Declination of the target astronomical object(s).
*
* units = OBJDECU ODEU%d
*
*
* default value = DEC none
*
*
* index = none 1-9999
*
*/
ODECnnn(HDU.PRIMARY, VALUE.STRING, "Declination of object"),
/**
* Declination unit.
*
* default value = DECUNIT OBJDECU
*
*
* index = none 1-9999
*
*/
ODEUnnn(HDU.PRIMARY, VALUE.STRING, "Declination unit"),
/**
* Epoch of the target astronomical object coordinate(s). This is given in
* years.
*
* units = 'yr'
*
*
* default value = EPOCH OBJEPOCH
*
*
* index = none 1-9999
*
*/
OEPOnnn(HDU.PRIMARY, VALUE.REAL, "Epoch of object coordinates"),
/**
* Coordinate system equinox for the target astronomical object(s). A value
* before 1984 is Besselian otherwise it is Julian.
*
* units = 'yr'
*
*
* default value = EQUINOX OBJEQUIN
*
*
* index = none 1-9999
*
*/
OEQUnnn(HDU.PRIMARY, VALUE.REAL, "Object coordinate equinox"),
/**
* Right ascension of the target astronomical object(s).
*
* units = OBJRAU ORAU%4d
*
*
* default value = RA none
*
*
* index = none 1-9999
*
*/
ORAnnn(HDU.PRIMARY, VALUE.STRING, "Right ascension of object"),
/**
* Right ascension unit.
*
* default value = RAUNIT OBJRAU
*
*
* index = none 1-9999
*
*/
ORAUnnn(HDU.PRIMARY, VALUE.STRING, "Right ascension unit"),
/**
* Coordinate system type for the target astronomical object(s).
*
* default value = RADECSYS OBJRADEC
*
*
* index = none 1-9999
*
*/
ORDSnnn(HDU.PRIMARY, VALUE.STRING, "Object coordinate system"),
/**
* Status of calibration to data proportional to photons. For CCD data this
* means bias section correction, zero level calibration, dark count
* calibration, and flat field calibration.
*
* default value = F
*
*
* index = none
*
*/
PHOTCAL(HDU.PRIMARY_EXTENSION, VALUE.LOGICAL, "Data proportional to photons?"),
/**
* Photometric conditions during the observation.
*
* default value = none
*
*
* index = none
*
*/
PHOTOMET(HDU.PRIMARY, VALUE.STRING, "Photometric conditions"),
/**
* Processing hardware used.
*
* default value = none none
*
*
* index = none 1-99
*
*/
PIPEHW(HDU.PRIMARY_EXTENSION, VALUE.STRING, "Processing hardware"),
/**
* Processing hardware used.
*
* default value = none none
*
*
* index = none 1-99
*
*/
PIPEHWn(HDU.PRIMARY_EXTENSION, VALUE.STRING, "Processing hardware"),
/**
* Name of processing pipeline applied.
*
* default value = none
*
*
* index = none
*
*/
PIPELINE(HDU.PRIMARY_EXTENSION, VALUE.STRING, "Pipeline used"),
/**
* Processing software version.
*
* default value = none none
*
*
* index = none 1-99
*
*/
PIPESW(HDU.PRIMARY_EXTENSION, VALUE.STRING, "Processing software"),
/**
* Processing software version.
*
* default value = none none
*
*
* index = none 1-99
*
*/
PIPESWn(HDU.PRIMARY_EXTENSION, VALUE.STRING, "Processing software"),
/**
* Projected pixel scale along axis n.
*
* units = UNITSEP/pixel
*
*
* default value = none
*
*
* index = 1-9
*
*/
PIXSCALn(HDU.PRIMARY, VALUE.REAL, "Pixel scale"),
/**
* Unbinned pixel size along each dimension given in appropriate units. The
* units should be indicated in the comment. The projected pixel size in arc
* seconds or wavelength are given by other parameters.
*
* units = 'um'
*
*
* default value = none
*
*
* index = 1-9
*
*/
PIXSIZEn(HDU.PRIMARY_EXTENSION, VALUE.REAL, "Pixel size"),
/**
* Pixel limit for region occupied by the spectrum.
*
* units = 'pixel' 'pixel'
*
*
* default value = none PMAX1
*
*
* index = none 1-9999
*
*/
PMAX1(HDU.EXTENSION, VALUE.REAL, "Spectrum pixel limit"),
/**
* Pixel limit for region occupied by the spectrum.
*
* units = 'pixel' 'pixel'
*
*
* default value = none PMAX2
*
*
* index = none 1-9999
*
*/
PMAX2(HDU.EXTENSION, VALUE.REAL, "Spectrum pixel limit"),
/**
* Pixel limit for region occupied by the spectrum.
*
* units = 'pixel' 'pixel'
*
*
* default value = none PMIN1
*
*
* index = none 1-9999
*
*/
PMIN1(HDU.EXTENSION, VALUE.REAL, "Spectrum pixel limit"),
/**
* Pixel limit for region occupied by the spectrum.
*
* units = 'pixel' 'pixel'
*
*
* default value = none CMIN2
*
*
* index = none 1-9999
*
*/
PMIN2(HDU.EXTENSION, VALUE.REAL, "Spectrum pixel limit"),
/**
* Pixel limit for region occupied by the spectrum.
*
* units = 'pixel' 'pixel'
*
*
* default value = none PMIN1
*
*
* index = none 1-9999
*
*/
PMN1nnn(HDU.EXTENSION, VALUE.REAL, "Spectrum pixel limit"),
/**
* Pixel limit for region occupied by the spectrum.
*
* units = 'pixel' 'pixel'
*
*
* default value = none CMIN2
*
*
* index = none 1-9999
*
*/
PMN2n(HDU.EXTENSION, VALUE.REAL, "Spectrum pixel limit"),
/**
* Pixel limit for region occupied by the spectrum.
*
* units = 'pixel' 'pixel'
*
*
* default value = none PMAX1
*
*
* index = none 1-9999
*
*/
PMX1n(HDU.EXTENSION, VALUE.REAL, "Spectrum pixel limit"),
/**
* Pixel limit for region occupied by the spectrum.
*
* units = 'pixel' 'pixel'
*
*
* default value = none PMAX2
*
*
* index = none 1-9999
*
*/
PMX2n(HDU.EXTENSION, VALUE.REAL, "Spectrum pixel limit"),
/**
* CCD preflash time. If the times in the extension are different the
* primary HDU gives one of the extension times.
*
* units = UNITTIME
*
*
* default value = 0.
*
*
* index = none
*
*/
PREFLASH(HDU.PRIMARY_EXTENSION, VALUE.REAL, "Preflash time"),
/**
* Processing log information formatted as FITS comments.
*
* default value = none
*
*
* index = 1-9999
*
*/
PROCnnn(HDU.PRIMARY_EXTENSION, VALUE.STRING, ""),
/**
* Processing status.
*
* default value = none
*
*
* index = none
*
*/
PROCSTAT(HDU.PRIMARY_EXTENSION, VALUE.STRING, "Processing status"),
/**
* The unique observatory proposal identification.
*
* default value = none
*
*
* index = none
*
*/
PROPID(HDU.PRIMARY, VALUE.STRING, "Proposal identification"),
/**
* The name or title of the proposal.
*
* default value = none
*
*
* index = none
*
*/
PROPOSAL(HDU.PRIMARY, VALUE.STRING, "Proposal title"),
/**
* Name(s) of the proposers.
*
* default value = none none
*
*
* index = none 1-9999
*
*/
PROPOSER(HDU.PRIMARY, VALUE.STRING, "Proposer(s)"),
/**
* Name(s) of the proposers.
*
* default value = none none
*
*
* index = none 1-9999
*
*/
PROPSRnn(HDU.PRIMARY, VALUE.STRING, "Proposer(s)"),
/**
* Default coordinate system equinox. A value before 1984 is Besselian
* otherwise it is Julian. If absent the default is J2000.
*
* units = 'yr'
*
*
* default value = 2000.
*
*
* index = none
*
*/
RADECEQ(HDU.PRIMARY_EXTENSION, VALUE.REAL, "Default coordinate equinox"),
/**
* Projected position angle of the positive right ascension axis on the
* detector. The position angle is measured clockwise from the image y axis.
*
* units = UNITPA
*
*
* default value = none
*
*
* index = none
*
*/
RAPANGL(HDU.PRIMARY, VALUE.REAL, "Position angle of RA axis"),
/**
* Default right ascension units.
*
* default value = UNITRA
*
*
* index = none
*
*/
RAUNIT(HDU.PRIMARY_EXTENSION, VALUE.STRING, "Right ascension unit"),
/**
* CCD readout noise in rms electrons. This is the most current estimate.
*
* units = 'e'
*
*
* default value = none
*
*
* index = none
*
*/
RDNOISE(HDU.EXTENSION, VALUE.REAL, "Readout noise"),
/**
* Amplifier unbinned pixel read time.
*
* units = 'ns'
*
*
* default value = none none
*
*
* index = none none
*
*/
READTIME(HDU.PRIMARY_EXTENSION, VALUE.REAL, "Unbinned pixel read time"),
/**
* Archive identification. This may be the same as the observation
* identification.
*
* default value = OBSID none
*
*
* index = none none
*
*/
RECNO(HDU.PRIMARY, VALUE.STRING, "Archive identification"),
/**
* Seeing estimates specified as the stellar full-width at half-maximum in
* arc seconds. There may be more than one estimate. The times of the
* estimates are given by the SEEMJDn keyword.
*
* units = UNITSEP
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
SEEING(HDU.PRIMARY, VALUE.REAL, "FWHM"),
/**
* Seeing estimates specified as the stellar full-width at half-maximum in
* arc seconds. There may be more than one estimate. The times of the
* estimates are given by the SEEMJDn keyword.
*
* units = UNITSEP
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
SEEINGn(HDU.PRIMARY, VALUE.REAL, "FWHM"),
/**
* Times for the seeing estimates given as modified Julian dates.
*
* units = 'd'
*
*
* default value = MJDHDR SEEMJD
*
*
* index = none 1-999
*
*/
SEEMJD(HDU.PRIMARY, VALUE.REAL, "MJD for seeing estimate"),
/**
* Times for the seeing estimates given as modified Julian dates.
*
* units = 'd'
*
*
* default value = MJDHDR SEEMJD
*
*
* index = none 1-999
*
*/
SEEMJDn(HDU.PRIMARY, VALUE.REAL, "MJD for seeing estimate"),
/**
* Exposure time of the nth subexposure. If all subexposures are the same
* length then only the first keyword, SEXP, is needed. For charge shuffling
* the subexposure time is the total time for each charge shuffled exposure.
* There is no finer division of the exposure times. Comments would be used
* to describe the subexposures of each charge shuffled subexposure.
*
* units = UNITTIME
*
*
* default value = none SEXP
*
*
* index = none 1-9999
*
*/
SEXP(HDU.PRIMARY_EXTENSION, VALUE.REAL, "Subexposure time"),
/**
* Exposure time of the nth subexposure. If all subexposures are the same
* length then only the first keyword, SEXP, is needed. For charge shuffling
* the subexposure time is the total time for each charge shuffled exposure.
* There is no finer division of the exposure times. Comments would be used
* to describe the subexposures of each charge shuffled subexposure.
*
* units = UNITTIME
*
*
* default value = none SEXP
*
*
* index = none 1-9999
*
*/
SEXPnnn(HDU.PRIMARY_EXTENSION, VALUE.REAL, "Subexposure time"),
/**
* Time for the shutter to close fully.
*
* units = 'ms'
*
*
* default value = none
*
*
* index = none
*
*/
SHUTCLOS(HDU.PRIMARY, VALUE.REAL, "Shutter close time"),
/**
* Shutter identification and hardware version.
*
* default value = none
*
*
* index = none
*
*/
SHUTHWV(HDU.PRIMARY, VALUE.STRING, "Shutter hardware version"),
/**
* Time for the shutter to open fully.
*
* units = 'ms'
*
*
* default value = none
*
*
* index = none
*
*/
SHUTOPEN(HDU.PRIMARY, VALUE.REAL, "Shutter open time"),
/**
* Shutter status.
*
* default value = none
*
*
* index = none
*
*/
SHUTSTAT(HDU.PRIMARY, VALUE.STRING, "Shutter status"),
/**
* Shutter software version.
*
* default value = none
*
*
* index = none
*
*/
SHUTSWV(HDU.PRIMARY, VALUE.STRING, "Shutter software version"),
/**
* Slit or mask hole identification for the aperture(s). The string consists
* of a number, an object type number (0=sky, 1=object, etc.), the right
* ascension and declination, and the object name or title. declination, and
* the object name or title. This can replace OBJNAME, APRA/OBJRA, and
* APDEC/OBJDEC.
*
* default value = none none
*
*
* index = none 1-9999
*
*/
SLIT(HDU.PRIMARY, VALUE.STRING, ""),
/**
* Slit or mask hole identification for the aperture(s). The string consists
* of a number, an object type number (0=sky, 1=object, etc.), the right
* ascension and declination, and the object name or title. declination, and
* the object name or title. This can replace OBJNAME, APRA/OBJRA, and
* APDEC/OBJDEC.
*
* default value = none none
*
*
* index = none 1-9999
*
*/
SLITnnn(HDU.PRIMARY, VALUE.STRING, ""),
/**
* FWHM of the object spectrum profile on the detector. The width is in the
* units of the spatial world coordinate system. This may be approximate. It
* is particularly useful for specifying the profile width of fiber fed
* spectra.
*
* units = CUNIT2 CUN2%4d
*
*
* default value = none SPECFWHM
*
*
* index = none 1-9999
*
*/
SPECFWHM(HDU.EXTENSION, VALUE.REAL, "FWHM of spectrum"),
/**
* UTC of the start of each subexposure.
*
* units = UNITHOUR
*
*
* default value = none SUT
*
*
* index = none 1-9999
*
*/
SUT(HDU.PRIMARY_EXTENSION, VALUE.STRING, "UTC of subexposure start"),
/**
* UTC of the start of each subexposure.
*
* units = UNITHOUR
*
*
* default value = none SUT
*
*
* index = none 1-9999
*
*/
SUTn(HDU.PRIMARY_EXTENSION, VALUE.STRING, "UTC of subexposure start"),
/**
* FWHM of the object spectrum profile on the detector. The width is in the
* units of the spatial world coordinate system. This may be approximate. It
* is particularly useful for specifying the profile width of fiber fed
* spectra.
*
* units = CUNIT2 CUN2%4d
*
*
* default value = none SPECFWHM
*
*
* index = none 1-9999
*
*/
SWIDnnn(HDU.EXTENSION, VALUE.REAL, "FWHM of spectrum"),
/**
* Modified Julian date at the time of the altitude/azimuth keywords.
*
* units = 'd'
*
*
* default value = MJDHDR
*
*
* index = none
*
*/
TELAAMJD(HDU.PRIMARY, VALUE.REAL, "MJD at for alt/az"),
/**
* Telescope pointing altitude at the time given by TELAAMJD.
*
* units = UNITALT
*
*
* default value = none
*
*
* index = none
*
*/
TELALT(HDU.PRIMARY, VALUE.STRING, "Telescope altitude"),
/**
* Telescope pointing azimuth at the time given by TELAAMJD.
*
* units = UNITAZ
*
*
* default value = none
*
*
* index = none
*
*/
TELAZ(HDU.PRIMARY, VALUE.STRING, "Telescope azimuth"),
/**
* Telescope configuration. The configuration defines the mirrors,
* correctors, light paths, etc.
*
* default value = none
*
*
* index = none
*
*/
TELCONF(HDU.PRIMARY, VALUE.STRING, "Telescope configuration"),
/**
* Telescope pointing declination.
*
* units = TELDECU
*
*
* default value = DEC
*
*
* index = none
*
*/
TELDEC(HDU.PRIMARY, VALUE.STRING, "Telescope declination"),
/**
* Declination unit.
*
* default value = DECUNIT
*
*
* index = none
*
*/
TELDECU(HDU.PRIMARY, VALUE.STRING, "Declination unit"),
/**
* Telescope pointing coordinate epoch.
*
* units = 'yr'
*
*
* default value = EPOCH
*
*
* index = none
*
*/
TELEPOCH(HDU.PRIMARY, VALUE.REAL, "Telescope coordinate epoch"),
/**
* Telescope pointing coordinate system equinox. A value before 1984 is
* Besselian otherwise it is Julian.
*
* units = 'yr'
*
*
* default value = EQUINOX
*
*
* index = none
*
*/
TELEQUIN(HDU.PRIMARY, VALUE.REAL, "Telescope coordinate equinox"),
/**
* Telescope focus value in available units.
*
* units = 'instrumental'
*
*
* default value = none
*
*
* index = none
*
*/
TELFOCUS(HDU.PRIMARY, VALUE.REAL, "Telescope focus"),
/**
* Time of zenith distance and hour angle
*
* units = 'd'
*
*
* default value = MJDHDR
*
*
* index = none
*
*/
TELMJD(HDU.PRIMARY, VALUE.REAL, "Time of zenith distance and hour angle"),
/**
* Times for the telescope sensor measurements given as modified Julian
* dates.
*
* units = 'd'
*
*
* default value = MJDHDR TELMJD
*
*
* index = none 1-999
*
*/
TELMJDn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Telescope position angle measurements in appropriate units. This could
* include altitude and azimuth measurements.
*
* default value = none none
*
*
* index = none 1-999
*
*/
TELPAN(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Telescope position angle measurements in appropriate units. This could
* include altitude and azimuth measurements.
*
* default value = none none
*
*
* index = none 1-999
*
*/
TELPANn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Telescope linear position sensor measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
TELPOS(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Telescope linear position sensor measurements in appropriate units.
*
* default value = none none
*
*
* index = none 1-999
*
*/
TELPOSn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Telescope pressure sensor measurements in appropriate units.
*
* units = UNITPRES
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
TELPRE(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Telescope pressure sensor measurements in appropriate units.
*
* units = UNITPRES
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
TELPREn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Telescope pointing right ascension.
*
* units = TELRAU
*
*
* default value = RA
*
*
* index = none
*
*/
TELRA(HDU.PRIMARY, VALUE.STRING, "Telescope right ascension"),
/**
* Telescope pointing coordinate system type.
*
* default value = RADECSYS
*
*
* index = none
*
*/
TELRADEC(HDU.PRIMARY, VALUE.STRING, "Telescope coordinate system"),
/**
* Right ascension unit.
*
* default value = RAUNIT
*
*
* index = none
*
*/
TELRAU(HDU.PRIMARY, VALUE.STRING, "Right ascension unit"),
/**
* Telescope status.
*
* default value = none
*
*
* index = none
*
*/
TELSTAT(HDU.PRIMARY, VALUE.STRING, "Telescope status"),
/**
* Telescope control system software version.
*
* default value = none
*
*
* index = none
*
*/
TELTCS(HDU.PRIMARY, VALUE.STRING, "Telescope control system"),
/**
* Telescope temperature sensor measurements in degrees Celsius. The comment
* string may be modified to indicate the location of the measurement.
*
* units = UNITTEMP
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
TELTEM(HDU.PRIMARY, VALUE.REAL, "Telescope temperature"),
/**
* Telescope temperature sensor measurements in degrees Celsius. The comment
* string may be modified to indicate the location of the measurement.
*
* units = UNITTEMP
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
TELTEMn(HDU.PRIMARY, VALUE.REAL, "Telescope temperature"),
/**
* Declination telescope tracking rate in arc seconds per second.
*
* units = UNITRATE
*
*
* default value = none
*
*
* index = none
*
*/
TELTKDEC(HDU.PRIMARY, VALUE.REAL, "Tracking rate from siderial"),
/**
* Right ascension telescope tracking rate from siderial in arc seconds per
* second.
*
* units = UNITRATE
*
*
* default value = none
*
*
* index = none
*
*/
TELTKRA(HDU.PRIMARY, VALUE.REAL, "Tracking rate from siderial"),
/**
* Telescope hardware version.
*
* default value = none
*
*
* index = none
*
*/
TELVER(HDU.PRIMARY, VALUE.STRING, "Telescope version"),
/**
* Telescope voltage sensor measurements in volts.
*
* units = UNITVOLT
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
TELVOL(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Telescope voltage sensor measurements in volts.
*
* units = UNITVOLT
*
*
* default value = none none
*
*
* index = none 1-999
*
*/
TELVOLn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Time of exposure end in the TSYSEND system.
*
* units = UNITHOUR
*
*
* default value = none
*
*
* index = none
*
*/
TIMEEND(HDU.PRIMARY_EXTENSION, VALUE.STRING, "Time of exposure end"),
/**
* Time of header creation.
*
* units = UNITHOUR
*
*
* default value = TIMESYS
*
*
* index = none
*
*/
TIMEHDR(HDU.PRIMARY_EXTENSION, VALUE.STRING, "Time of header creation"),
/**
* Default time system. All times which do not have a "timesys" element
* associated with them in this dictionary default to this keyword. .
*
* default value = 'UTC'
*
*
* index = none
*
*/
TIMESYS(HDU.PRIMARY, VALUE.STRING, "Default time system"),
/**
* Section of the recorded image to be kept after calibration processing.
* This is generally the part of the data section containing useful data.
* The section is in in binned pixels if binning is done.
*
* default value = DATASEC
*
*
* index = none
*
*/
TRIMSEC(HDU.EXTENSION, VALUE.STRING, "Section of useful data"),
/**
* Time system for the TIMEEND keyword.
*
* default value = TIMESYS
*
*
* index = none
*
*/
TSYSEND(HDU.PRIMARY_EXTENSION, VALUE.STRING, "Time system for TIMEEND"),
/**
* Time system for the header creation keywords.
*
* default value = TIMESYS
*
*
* index = none
*
*/
TSYSHDR(HDU.PRIMARY_EXTENSION, VALUE.STRING, "Time system for header creation"),
/**
* Time system for the TIME-OBS keyword.
*
* default value = TIMESYS
*
*
* index = none
*
*/
TSYSOBS(HDU.PRIMARY_EXTENSION, VALUE.STRING, "Time system for TIME-OBS"),
/**
* TV name.
*
* default value = none none
*
*
* index = none 1-9
*
*/
TV(HDU.PRIMARY, VALUE.STRING, "TV"),
/**
* TV filter names. This name is the astronomical standard name if
* applicable; i.e. U, B, Gunn I, etc. The filter type and filter device
* position are given by other keywords.
*
* default value = none none
*
*
* index = 1-9 1-9,1-9
*
*/
TVFILTn(HDU.PRIMARY, VALUE.STRING, "Filter name"),
/**
* Television focus value in available units.
*
* units = 'instrumental'
*
*
* default value = none none
*
*
* index = 1-9 1-9,1-9
*
*/
TVFOCn(HDU.PRIMARY, VALUE.REAL, "Television focus"),
/**
* TV filter position given as filter wheel number or other filter system
* position measurement.
*
* units = 'instrumental'
*
*
* default value = none none
*
*
* index = 1-9 1-9,1-9
*
*/
TVFPOSn(HDU.PRIMARY, VALUE.REAL, "Filter system position"),
/**
* TV filter type. This is the technical specification or observatory
* identification name.
*
* default value = none none
*
*
* index = 1-9 1-9,1-9
*
*/
TVFTYPn(HDU.PRIMARY, VALUE.STRING, "Filter type"),
/**
* TV identification and hardware version.
*
* default value = none none
*
*
* index = none 1-9
*
*/
TVHWV(HDU.PRIMARY, VALUE.STRING, "TV Hardware"),
/**
* Times for the guider television sensor measurements given as modified
* Julian dates.
*
* units = 'd'
*
*
* default value = MJDHDR TVMJD%d
*
*
* index = 1-9 1-9,1-9
*
*/
TVMJDn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* TV name.
*
* default value = none none
*
*
* index = none 1-9
*
*/
TVn(HDU.PRIMARY, VALUE.STRING, "TV"),
/**
* TV filter names. This name is the astronomical standard name if
* applicable; i.e. U, B, Gunn I, etc. The filter type and filter device
* position are given by other keywords.
*
* default value = none none
*
*
* index = 1-9 1-9,1-9
*
*/
TVnFILTn(HDU.PRIMARY, VALUE.STRING, "Filter name"),
/**
* Television focus value in available units.
*
* units = 'instrumental'
*
*
* default value = none none
*
*
* index = 1-9 1-9,1-9
*
*/
TVnFOCn(HDU.PRIMARY, VALUE.REAL, "Television focus"),
/**
* TV filter position given as filter wheel number or other filter system
* position measurement.
*
* units = 'instrumental'
*
*
* default value = none none
*
*
* index = 1-9 1-9,1-9
*
*/
TVnFPOSn(HDU.PRIMARY, VALUE.REAL, "Filter system position"),
/**
* TV filter type. This is the technical specification or observatory
* identification name.
*
* default value = none none
*
*
* index = 1-9 1-9,1-9
*
*/
TVnFTYPn(HDU.PRIMARY, VALUE.STRING, "Filter type"),
/**
* TV identification and hardware version.
*
* default value = none none
*
*
* index = none 1-9
*
*/
TVnHWV(HDU.PRIMARY, VALUE.STRING, "TV Hardware"),
/**
* Times for the guider television sensor measurements given as modified
* Julian dates.
*
* units = 'd'
*
*
* default value = MJDHDR TVMJD%d
*
*
* index = 1-9 1-9,1-9
*
*/
TVnMJDn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Television position angle measurements in appropriate units.
*
* default value = none none
*
*
* index = 1-9 1-9,1-9
*
*/
TVnPANn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Television linear position sensor measurements in appropriate units.
*
* default value = none none
*
*
* index = 1-9 1-9,1-9
*
*/
TVnPOSn(HDU.PRIMARY, VALUE.REAL, "Television position ()"),
/**
* Television pressure sensor measurements in appropriate units.
*
* units = UNITPRES
*
*
* default value = none none
*
*
* index = 1-9 1-9,1-9
*
*/
TVnPREn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* TV status.
*
* default value = none none
*
*
* index = none 1-9
*
*/
TVnSTAT(HDU.PRIMARY, VALUE.STRING, ""),
/**
* TV software version.
*
* default value = none none
*
*
* index = none 1-9
*
*/
TVnSWV(HDU.PRIMARY, VALUE.NONE, ""),
/**
* Television temperature sensor measurements in degrees Celsius.
*
* units = UNITTEMP
*
*
* default value = none none
*
*
* index = 1-9 1-9,1-9
*
*/
TVnTEMn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Television voltage sensor measurements in volts.
*
* units = UNITVOLT
*
*
* default value = none none
*
*
* index = 1-9 1-9,1-9
*
*/
TVnVOLn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Television position angle measurements in appropriate units.
*
* default value = none none
*
*
* index = 1-9 1-9,1-9
*
*/
TVPANn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Television linear position sensor measurements in appropriate units.
*
* default value = none none
*
*
* index = 1-9 1-9,1-9
*
*/
TVPOSn(HDU.PRIMARY, VALUE.REAL, "Television position ()"),
/**
* Television pressure sensor measurements in appropriate units.
*
* units = UNITPRES
*
*
* default value = none none
*
*
* index = 1-9 1-9,1-9
*
*/
TVPREn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* TV status.
*
* default value = none none
*
*
* index = none 1-9
*
*/
TVSTAT(HDU.PRIMARY, VALUE.STRING, ""),
/**
* TV software version.
*
* default value = none none
*
*
* index = none 1-9
*
*/
TVSWV(HDU.PRIMARY, VALUE.NONE, ""),
/**
* Television temperature sensor measurements in degrees Celsius.
*
* units = UNITTEMP
*
*
* default value = none none
*
*
* index = 1-9 1-9,1-9
*
*/
TVTEMn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Television voltage sensor measurements in volts.
*
* units = UNITVOLT
*
*
* default value = none none
*
*
* index = 1-9 1-9,1-9
*
*/
TVVOLn(HDU.PRIMARY, VALUE.REAL, ""),
/**
* Altitude unit.
*
* default value = UNITANG
*
*
* index = none
*
*/
UNITALT(HDU.PRIMARY, VALUE.STRING, "Altitude unit"),
/**
* Plane angle unit.
*
* default value = 'deg'
*
*
* index = none
*
*/
UNITANG(HDU.PRIMARY, VALUE.STRING, "Plane angle unit"),
/**
* Focal plane aperture size unit.
*
* default value = 'arcsec'
*
*
* index = none
*
*/
UNITAP(HDU.PRIMARY, VALUE.STRING, "Aperture size unit"),
/**
* Area unit.
*
* default value = 'pixel'
*
*
* index = none
*
*/
UNITAREA(HDU.PRIMARY, VALUE.STRING, "Area unit"),
/**
* Azimuth unit.
*
* default value = UNITANG
*
*
* index = none
*
*/
UNITAZ(HDU.PRIMARY, VALUE.STRING, "Azimuth unit"),
/**
* Capacitance unit.
*
* default value = 'F'
*
*
* index = none
*
*/
UNITCAP(HDU.PRIMARY, VALUE.STRING, "Capacitance unit"),
/**
* Charge unit.
*
* default value = 'C'
*
*
* index = none
*
*/
UNITCHAR(HDU.PRIMARY, VALUE.STRING, "Charge unit"),
/**
* Conductance unit.
*
* default value = 'S'
*
*
* index = none
*
*/
UNITCOND(HDU.PRIMARY, VALUE.STRING, "Conductance unit"),
/**
* Current unit.
*
* default value = 'A'
*
*
* index = none
*
*/
UNITCUR(HDU.PRIMARY, VALUE.STRING, "Current unit"),
/**
* Delination unit.
*
* default value = 'deg'
*
*
* index = none
*
*/
UNITDEC(HDU.PRIMARY, VALUE.STRING, "Declination unit"),
/**
* Energy unit.
*
* default value = 'J'
*
*
* index = none
*
*/
UNITENER(HDU.PRIMARY, VALUE.STRING, "Energy unit"),
/**
* Event unit.
*
* default value = 'count'
*
*
* index = none
*
*/
UNITEVNT(HDU.PRIMARY, VALUE.STRING, "Event unit"),
/**
* Flux unit.
*
* default value = 'Jy'
*
*
* index = none
*
*/
UNITFLUX(HDU.PRIMARY, VALUE.STRING, "Flux unit"),
/**
* Force unit.
*
* default value = 'N'
*
*
* index = none
*
*/
UNITFORC(HDU.PRIMARY, VALUE.STRING, "Force unit"),
/**
* Frequency unit.
*
* default value = 'Hz'
*
*
* index = none
*
*/
UNITFREQ(HDU.PRIMARY, VALUE.STRING, "Frequency unit"),
/**
* Time of day unit.
*
* default value = h
*
*
* index = none
*
*/
UNITHOUR(HDU.PRIMARY, VALUE.STRING, "Time of day unit"),
/**
* Illuminance unit.
*
* default value = 'lux'
*
*
* index = none
*
*/
UNITILLU(HDU.PRIMARY, VALUE.STRING, "Illuminance unit"),
/**
* Inductance unit.
*
* default value = 'H'
*
*
* index = none
*
*/
UNITINDU(HDU.PRIMARY, VALUE.STRING, "Inductance unit"),
/**
* Latitude unit.
*
* default value = UNITANG
*
*
* index = none
*
*/
UNITLAT(HDU.PRIMARY, VALUE.STRING, "Latitude unit"),
/**
* Length unit. A wavelength unit is also provided so this unit is primarily
* used to instrumental descriptions.
*
* default value = 'm'
*
*
* index = none
*
*/
UNITLEN(HDU.PRIMARY, VALUE.STRING, "Length unit"),
/**
* Luminous flux unit.
*
* default value = 'lm'
*
*
* index = none
*
*/
UNITLFLX(HDU.PRIMARY, VALUE.STRING, "Luminous flux unit"),
/**
* Luminous intensity unit.
*
* default value = 'cd'
*
*
* index = none
*
*/
UNITLINT(HDU.PRIMARY, VALUE.STRING, "Luminous intensity unit"),
/**
* Longitude unit.
*
* default value = UNITANG
*
*
* index = none
*
*/
UNITLONG(HDU.PRIMARY, VALUE.STRING, "Longitude unit"),
/**
* Mass unit.
*
* default value = 'kg'
*
*
* index = none
*
*/
UNITMASS(HDU.PRIMARY, VALUE.STRING, "Mass unit"),
/**
* Magnetic density unit.
*
* default value = 'T'
*
*
* index = none
*
*/
UNITMDEN(HDU.PRIMARY, VALUE.STRING, "Magnetic density unit"),
/**
* Magnetic field unit.
*
* default value = 'G'
*
*
* index = none
*
*/
UNITMFLD(HDU.PRIMARY, VALUE.STRING, "Magnetic field unit"),
/**
* Magnetic flux unit.
*
* default value = 'Wb'
*
*
* index = none
*
*/
UNITMFLX(HDU.PRIMARY, VALUE.STRING, "Magnetic flux unit"),
/**
* Position angle unit.
*
* default value = UNITANG
*
*
* index = none
*
*/
UNITPA(HDU.PRIMARY, VALUE.STRING, "Position angle unit"),
/**
* Power unit.
*
* default value = 'W'
*
*
* index = none
*
*/
UNITPOW(HDU.PRIMARY, VALUE.STRING, "Wavelength unit"),
/**
* Pressure unit.
*
* default value = 'Pa'
*
*
* index = none
*
*/
UNITPRES(HDU.PRIMARY, VALUE.STRING, "Pressure unit"),
/**
* Right ascension unit.
*
* default value = 'hr'
*
*
* index = none
*
*/
UNITRA(HDU.PRIMARY, VALUE.STRING, "Right ascension unit"),
/**
* Celestial rate of motion.
*
* default value = arcsec/sec
*
*
* index = none
*
*/
UNITRATE(HDU.PRIMARY, VALUE.STRING, "Celestial rate of motion"),
/**
* Resistance unit.
*
* default value = 'Ohm'
*
*
* index = none
*
*/
UNITRES(HDU.PRIMARY, VALUE.STRING, "Resistance unit"),
/**
* Solid angle unit.
*
* default value = 'sr'
*
*
* index = none
*
*/
UNITSANG(HDU.PRIMARY, VALUE.STRING, "Solid angle unit"),
/**
* Celestial separation unit.
*
* default value = 'arcsec'
*
*
* index = none
*
*/
UNITSEP(HDU.PRIMARY, VALUE.STRING, "Separation unit"),
/**
* Temperature unit.
*
* default value = 'K'
*
*
* index = none
*
*/
UNITTEMP(HDU.PRIMARY, VALUE.STRING, "Temperature unit"),
/**
* Time unit.
*
* default value = 's'
*
*
* index = none
*
*/
UNITTIME(HDU.PRIMARY, VALUE.STRING, "Time unit"),
/**
* Velocity unit.
*
* default value = 'km/s'
*
*
* index = none
*
*/
UNITVEL(HDU.PRIMARY, VALUE.STRING, "Velocity unit"),
/**
* Voltage unit.
*
* default value = 'V'
*
*
* index = none
*
*/
UNITVOLT(HDU.PRIMARY, VALUE.STRING, "Voltage unit"),
/**
* UTC time at the start of the exposure.
*
* units = UNITHOUR
*
*
* default value = none
*
*
* index = none
*
*/
UTC_OBS("UTC-OBS", HDU.PRIMARY_EXTENSION, VALUE.STRING, "UTC of exposure start"),
/**
* UTC at the end of the exposure.
*
* units = UNITHOUR
*
*
* default value = none
*
*
* index = none
*
*/
UTCEND(HDU.PRIMARY_EXTENSION, VALUE.STRING, "UTC at end of exposure"),
/**
* UTC of header creation.
*
* units = UNITHOUR
*
*
* default value = UTC-OBS
*
*
* index = none
*
*/
UTCHDR(HDU.PRIMARY_EXTENSION, VALUE.STRING, "UTC of header creation"),
/**
* Default UTC time for the observation. This keyword is generally not used
* and is UTC-OBS keyword for the start of the exposure on the detector is
* used.
*
* units = UNITHOUR
*
*
* default value = UTC-OBS
*
*
* index = none
*
*/
UTCOBS(HDU.PRIMARY_EXTENSION, VALUE.STRING, "UTC of observation"),
/**
* IRAF WCS attribute strings for all axes. These are defined by the IRAF
* WCS system.
*
* default value = none
*
*
* index = 1-999
*
*/
WAT_nnn(HDU.PRIMARY_EXTENSION, VALUE.STRING, ""),
/**
* IRAF WCS attribute strings. These are defined by the IRAF WCS system.
*
* default value = none
*
*
* index = 1-9,1-999
*
*/
WATn_nnn(HDU.PRIMARY_EXTENSION, VALUE.STRING, ""),
/**
* Descriptive string identifying the source of the astrometry used to
* derive the WCS. One example is the exposure used to derive a WCS apart
* from the reference coordinate.
*
* default value = none WCSASTRM
*
*
* index = none 1-9999
*
*/
WCSAnnn(HDU.PRIMARY_EXTENSION, VALUE.STRING, "WCS Source"),
/**
* Descriptive string identifying the source of the astrometry used to
* derive the WCS. One example is the exposure used to derive a WCS apart
* from the reference coordinate.
*
* default value = none WCSASTRM
*
*
* index = none 1-9999
*
*/
WCSASTRM(HDU.PRIMARY_EXTENSION, VALUE.STRING, "WCS Source"),
/**
* Dimensionality of the WCS physical system. In IRAF a WCS can have a
* higher dimensionality than the image.
*
* default value = none
*
*
* index = none
*
*/
WCSDIM(HDU.PRIMARY_EXTENSION, VALUE.INTEGER, "WCS dimensionality"),
/**
* Epoch of the coordinates used in the world coordinate system.
*
* units = 'yr' 'yr'
*
*
* default value = CCDEPOCH WCSEPOCH
*
*
* index = none 1-9999
*
*/
WCSEnnn(HDU.PRIMARY_EXTENSION, VALUE.REAL, "WCS coordinate epoch"),
/**
* Equinox when equatorial coordinates are used in the world coordinate
* system. A value before 1984 is Besselian otherwise it is Julian.
*
* units = 'yr' 'yr'
*
*
* default value = CCDEQUIN EQUINOX
*
*
* index = none 1-9999
*
*/
WCSEPOCH(HDU.PRIMARY_EXTENSION, VALUE.REAL, "WCS coordinate epoch"),
/**
* Coordinate system type when equatorial coordinates are used in the world
* coordinate system.
*
* default value = CCDRADEC WCSRADEC
*
*
* index = none 1-9999
*
*/
WCSRADEC(HDU.PRIMARY_EXTENSION, VALUE.STRING, "WCS coordinate system"),
/**
* Coordinate system type when equatorial coordinates are used in the world
* coordinate system.
*
* default value = CCDRADEC WCSRADEC
*
*
* index = none 1-9999
*
*/
WCSRnnn(HDU.PRIMARY_EXTENSION, VALUE.STRING, "WCS coordinate system"),
/**
* Weather condition description. Generally this would be either 'clear' or
* 'partly cloudy'.
*
* default value = none
*
*
* index = none
*
*/
WEATHER(HDU.PRIMARY, VALUE.STRING, "Weather conditions"),
/**
* Zenith distance of telescope pointing at TELMJD.
*
* units = UNITANG
*
*
* default value = none
*
*
* index = none
*
*/
ZD(HDU.PRIMARY, VALUE.REAL, "Zenith distance"),
/**
* Modified Julian date at the start of the exposure. The fractional part of
* the date is given to better than a second of time.
*
* units = 'd'
*
*
* default value = none
*
*
* index = none
*
*/
MJD_OBS("MJD-OBS", HDU.PRIMARY_EXTENSION, VALUE.REAL, "MJD of exposure start");
@SuppressWarnings("CPD-START")
private final IFitsHeader key;
NOAOExt(HDU hdu, VALUE valueType, String comment) {
this.key = new FitsHeaderImpl(name(), IFitsHeader.SOURCE.NOAO, hdu, valueType, comment);
}
NOAOExt(String key, HDU hdu, VALUE valueType, String comment) {
this.key = new FitsHeaderImpl(name(), IFitsHeader.SOURCE.NOAO, hdu, valueType, comment);
}
@Override
public String comment() {
return this.key.comment();
}
@Override
public HDU hdu() {
return this.key.hdu();
}
@Override
public String key() {
return this.key.key();
}
@Override
public IFitsHeader n(int... number) {
return this.key.n(number);
}
@Override
public SOURCE status() {
return this.key.status();
}
@Override
@SuppressWarnings("CPD-END")
public VALUE valueType() {
return this.key.valueType();
}
}
nom/tam/fits/header/extra/CXCStclSharedExt.java 0000664 0000000 0000000 00000006544 12755570700 020407 0 ustar root root package nom.tam.fits.header.extra;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import nom.tam.fits.header.FitsHeaderImpl;
import nom.tam.fits.header.IFitsHeader;
/**
* This is the file represents the common keywords between CXC and STSclExt
*
* @author Richard van Nieuwenhoven
*/
public enum CXCStclSharedExt implements IFitsHeader {
/**
* Clock correction applied
*
* T
*
*/
CLOCKAPP("Clock correction applied"),
/**
* 1998-01-01T00:00:00 (TT) expressed in MJD (TT)
*/
MJDREF("1998-01-01T00:00:00 (TT) expressed in MJD"),
/**
* Spacecraft clock
*/
TASSIGN("Spacecraft clock"),
/**
* Time resolution of data (in seconds)
*/
TIMEDEL("Time resolution of data (in seconds)"),
/**
* No pathlength corrections
*/
TIMEREF("No pathlength corrections"),
/**
* Units of time e.g. 's'
*/
TIMEUNIT("Units of time "),
/**
* AXAF FITS design document
*/
TIMVERSN("AXAF FITS design document"),
/**
* Clock correction (if not zero)
*/
TIMEZERO("Clock correction (if not zero)"),
/**
* As in the "TIME" column: raw space craft clock;
*/
TSTART("As in the \"TIME\" column: raw space craft clock;"),
/**
* add TIMEZERO and MJDREF for absolute TT
*/
TSTOP("add TIMEZERO and MJDREF for absolute TT");
@SuppressWarnings("CPD-START")
private final IFitsHeader key;
CXCStclSharedExt(String comment) {
this.key = new FitsHeaderImpl(name(), IFitsHeader.SOURCE.CXC, HDU.ANY, VALUE.STRING, comment);
}
@Override
public String comment() {
return this.key.comment();
}
@Override
public HDU hdu() {
return this.key.hdu();
}
@Override
public String key() {
return this.key.key();
}
@Override
public IFitsHeader n(int... number) {
return this.key.n(number);
}
@Override
public SOURCE status() {
return this.key.status();
}
@Override
@SuppressWarnings("CPD-END")
public VALUE valueType() {
return this.key.valueType();
}
}
nom/tam/fits/header/extra/SBFitsExt.java 0000664 0000000 0000000 00000021736 12755570700 017147 0 ustar root root package nom.tam.fits.header.extra;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import nom.tam.fits.header.FitsHeaderImpl;
import nom.tam.fits.header.IFitsHeader;
/**
* A Set of FITS Standard Extensions for Amateur Astronomical Processing
* Software Packages published by SBIG.
*
* Please note that SBIG has published a FITS Standard SBIGFITSEXT that SBIG
* with CCDOps , Software Bisque with CCDSoft and Diffraction Limited with
* MaximDl all agreed to and implemented.
*
*
*
* @see http://archive.sbig.com/pdffiles/SBFITSEXT_1r0.pdf
*
*
* @author Richard van Nieuwenhoven.
*/
public enum SBFitsExt implements IFitsHeader {
/**
* Aperture Area of the Telescope used in square millimeters. Note that we
* are specifying the area as well as the diameter because we want to be
* able to correct for any central obstruction.
*/
APTAREA(VALUE.REAL, "Aperture Area of the Telescope"),
/**
* Aperture Diameter of the Telescope used in millimeters.
*/
APTDIA(VALUE.REAL, "Aperture Diameter of the Telescope"),
/**
* Upon initial display of this image use this ADU level for the Black
* level.
*/
CBLACK(VALUE.INTEGER, "use this ADU level for the Black"),
/**
* Temperature of CCD when exposure taken.
*/
CCD_TEMP("CCD-TEMP", VALUE.REAL, "Temperature of CCD"),
/**
* Altitude in degrees of the center of the image in degrees. Format is the
* same as the OBJCTDEC keyword.
*/
CENTALT(VALUE.STRING, "Altitude of the center of the image"),
/**
* Azimuth in degrees of the center of the image in degrees. Format is the
* same as the OBJCTDEC keyword.
*/
CENTAZ(VALUE.STRING, "Azimuth of the center of the image"),
/**
* Upon initial display of this image use this ADU level as the White level.
* For the SBIG method of displaying images using Background and Range the
* following conversions would be used: Background = CBLACK Range = CWHITE -
* CBLACK.
*/
CWHITE(VALUE.INTEGER, "use this ADU level for the White"),
/**
* Total dark time of the observation. This is the total time during which
* dark current is collected by the detector. If the times in the extension
* are different the primary HDU gives one of the extension times.
*
* units = UNITTIME
*
*
* default value = EXPTIME
*
*
* index = none
*
*/
DARKTIME(VALUE.REAL, "Dark time"),
/**
* Electronic gain in e-/ADU.
*/
EGAIN(VALUE.REAL, "Electronic gain in e-/ADU"),
/*
* Optional Keywords The following Keywords are not defined in the FITS
* Standard but are defined in this Standard. They may or may not be
* included by AIP Software Packages adhering to this Standard. Any of these
* keywords read by an AIP Package must be preserved in files written.
*/
/**
* Focal Length of the Telescope used in millimeters.
*/
FOCALLEN(VALUE.REAL, "Focal Length of the Telescope"),
/**
* This indicates the type of image and should be one of the following:
* Light Frame Dark Frame Bias Frame Flat Field.
*/
IMAGETYP(VALUE.STRING, "type of image"),
/**
* This is the Declination of the center of the image in degrees. The format
* for this is ‘+25 12 34.111’ (SDD MM SS.SSS) using a space as the
* separator. For the sign, North is + and South is -.
*/
OBJCTDEC(VALUE.STRING, "Declination of the center of the image"),
/**
* This is the Right Ascension of the center of the image in hours, minutes
* and secon ds. The format for this is ’12 24 23.123’ (HH MM SS.SSS) using
* a space as the separator.
*/
OBJCTRA(VALUE.STRING, "Right Ascension of the center of the image"),
/**
* Add this ADU count to each pixel value to get to a zero - based ADU. For
* example in SBIG images we add 100 ADU to each pixel to stop underflow at
* Zero ADU from noise. We would set PEDESTAL to - 100 in this case.
*/
PEDESTAL(VALUE.INTEGER, "ADU count to each pixel value to get to a zero"),
/**
* This string indicates the version of this standard that the image was
* created to ie ‘SBFITSEXT Version 1.0’.
*/
SBSTDVER(VALUE.STRING, "version of this standard"),
/**
* This is the setpoint of the cooling in degrees C. If it is not specified
* the setpoint is assumed to be the
*/
SET_TEMP("SET-TEMP", VALUE.REAL, "setpoint of the cooling in degrees C"),
/**
* Latitude of the imaging location in degrees. Format is the same as the
* OBJCTDEC key word.
*/
SITELAT(VALUE.STRING, "Latitude of the imaging location"),
/**
* Longitude of the imaging location in degrees. Format is the same as the
* OBJCTDEC keyword.
*/
SITELONG(VALUE.STRING, "Longitude of the imaging location"),
/**
* Number of images combined to make this image as in Track and Accumulate
* or Co - Added images.
*/
SNAPSHOT(VALUE.INTEGER, "Number of images combined"),
/**
* This indicates the name and version of the Software that initially
* created this file ie ‘SBIGs CCDOps Version 5.10’.
*/
SWCREATE(VALUE.STRING, "created version of the Software"),
/**
* This indicates the name and version of the Software that modified this
* file ie ‘SBIGs CCDOps Version 5.10’ and the re can be multiple copies of
* this keyword. Only add this keyword if you actually modified the image
* and we suggest placing this above the HISTORY keywords corresponding to
* the modifications made to the image.
*/
SWMODIFY(VALUE.STRING, "modified version of the Software"),
/**
* If the image was auto-guided this is the exposure time in seconds of the
* tracker used to acquire this image. If this keyword is not present then
* the image was unguided or hand guided.
*/
TRAKTIME(VALUE.REAL, "exposure time in seconds of the tracker"),
/**
* Binning factor in width.
*/
XBINNING(VALUE.INTEGER, "Binning factor in width"),
/**
* Sub frame X position of upper left pixel relative to whole frame in
* binned pixel units.
*/
XORGSUBF(VALUE.INTEGER, "Sub frame X position"),
/**
* Pixel width in microns (after binning).
*/
XPIXSZ(VALUE.REAL, "Pixel width in microns"),
/**
* Binning factor in height.
*/
YBINNING(VALUE.INTEGER, "Binning factor in height"),
/**
* Sub frame Y position of upper left pixel relative to whole frame in
* binned pixel units.
*/
YORGSUBF(VALUE.INTEGER, "Sub frame Y position"),
/**
* Pixel height in microns (after binning).
*/
YPIXSZ(VALUE.REAL, "Pixel height in microns");
@SuppressWarnings("CPD-START")
private final IFitsHeader key;
SBFitsExt(String key, VALUE valueType, String comment) {
this.key = new FitsHeaderImpl(key, IFitsHeader.SOURCE.SBIG, HDU.IMAGE, valueType, comment);
}
SBFitsExt(VALUE valueType, String comment) {
this.key = new FitsHeaderImpl(name(), IFitsHeader.SOURCE.SBIG, HDU.IMAGE, valueType, comment);
}
@Override
public String comment() {
return this.key.comment();
}
@Override
public HDU hdu() {
return this.key.hdu();
}
@Override
public String key() {
return this.key.key();
}
@Override
public IFitsHeader n(int... number) {
return this.key.n(number);
}
@Override
public SOURCE status() {
return this.key.status();
}
@Override
@SuppressWarnings("CPD-END")
public VALUE valueType() {
return this.key.valueType();
}
}
nom/tam/fits/header/extra/MaxImDLExt.java 0000664 0000000 0000000 00000020332 12755570700 017237 0 ustar root root package nom.tam.fits.header.extra;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import nom.tam.fits.header.FitsHeaderImpl;
import nom.tam.fits.header.IFitsHeader;
/**
* The Fits extension as defined by Maxim DL.Extension keywords that may be
* added or read by MaxIm DL, depending on the current equipment and software
* configuration.
*
* This standard extends the @see {@link SBFitsExt} all that fields are
* included.
*
*
*
* http://www.cyanogen.com/help/maximdl/FITS_File_Header_Definitions.htm
*
*
* @author Richard van Nieuwenhoven
*/
public enum MaxImDLExt implements IFitsHeader {
/**
* if present the image has a valid Bayer color pattern.
*/
BAYERPAT(VALUE.REAL, "image Bayer color pattern"),
/**
* Boltwood Cloud Sensor ambient temperature in degrees C.
*/
BOLTAMBT(VALUE.REAL, "ambient temperature in degrees C"),
/**
* Boltwood Cloud Sensor cloud condition.
*/
BOLTCLOU(VALUE.REAL, "Boltwood Cloud Sensor cloud condition."),
/**
* Boltwood Cloud Sensor daylight level.
*/
BOLTDAY(VALUE.REAL, "Boltwood Cloud Sensor daylight level."),
/**
* Boltwood Cloud Sensor dewpoint in degrees C.
*/
BOLTDEW(VALUE.REAL, "Boltwood Cloud Sensor dewpoint in degrees C."),
/**
* Boltwood Cloud Sensor humidity in percent.
*/
BOLTHUM(VALUE.REAL, "Boltwood Cloud Sensor humidity in percent."),
/**
* Boltwood Cloud Sensor rain condition.
*/
BOLTRAIN(VALUE.REAL, "Boltwood Cloud Sensor rain condition."),
/**
* Boltwood Cloud Sensor sky minus ambient temperature in degrees C.
*/
BOLTSKYT(VALUE.REAL, "Boltwood Cloud Sensor sky minus ambient temperature in degrees C."),
/**
* Boltwood Cloud Sensor wind speed in km/h.
*/
BOLTWIND(VALUE.REAL, "Boltwood Cloud Sensor wind speed in km/h."),
/**
* indicates calibration state of the image; B indicates bias corrected, D
* indicates dark corrected, F indicates flat corrected.
*/
CALSTAT(VALUE.REAL, "calibration state of the image"),
/**
* type of color sensor Bayer array or zero for monochrome.
*/
COLORTYP(VALUE.REAL, "type of color sensor"),
/**
* initial display screen stretch mode.
*/
CSTRETCH(VALUE.REAL, "initial display screen stretch mode"),
/**
* dark current integration time, if recorded. May be longer than exposure
* time.
*/
DARKTIME(VALUE.REAL, "dark current integration time"),
/**
* Davis Instruments Weather Station ambient temperature in deg C
*/
DAVAMBT(VALUE.REAL, "ambient temperature"),
/**
* Davis Instruments Weather Station barometric pressure in hPa
*/
DAVBAROM(VALUE.REAL, "barometric pressure"),
/**
* Davis Instruments Weather Station dewpoint in deg C
*/
DAVDEW(VALUE.REAL, "dewpoint in deg C"),
/**
* Davis Instruments Weather Station humidity in percent
*/
DAVHUM(VALUE.REAL, "humidity in percent"),
/**
* Davis Instruments Weather Station solar radiation in W/m^2
*/
DAVRAD(VALUE.REAL, "solar radiation"),
/**
* Davis Instruments Weather Station accumulated rainfall in mm/day
*/
DAVRAIN(VALUE.REAL, "accumulated rainfall"),
/**
* Davis Instruments Weather Station wind speed in km/h
*/
DAVWIND(VALUE.REAL, "wind speed"),
/**
* Davis Instruments Weather Station wind direction in deg
*/
DAVWINDD(VALUE.REAL, "wind direction"),
/**
* status of pier flip for German Equatorial mounts.
*/
FLIPSTAT(VALUE.REAL, "status of pier flip"),
/**
* Focuser position in steps, if focuser is connected.
*/
FOCUSPOS(VALUE.REAL, "Focuser position in steps"),
/**
* Focuser step size in microns, if available.
*/
FOCUSSZ(VALUE.REAL, "Focuser step size in microns"),
/**
* Focuser temperature readout in degrees C, if available.
*/
FOCUSTEM(VALUE.REAL, "Focuser temperature readout"),
/**
* format of file from which image was read.
*/
INPUTFMT(VALUE.REAL, "format of file"),
/**
* ISO camera setting, if camera uses ISO speeds.
*/
ISOSPEED(VALUE.REAL, "ISO camera setting"),
/**
* records the geocentric Julian Day of the start of exposure.
*/
JD(VALUE.REAL, "geocentric Julian Day"),
/**
* records the geocentric Julian Day of the start of exposure.
*/
JD_GEO(VALUE.REAL, "geocentric Julian Da"),
/**
* records the Heliocentric Julian Date at the exposure midpoint.
*/
JD_HELIO(VALUE.REAL, "Heliocentric Julian Date"),
/**
* records the Heliocentric Julian Date at the exposure midpoint.
*/
JD_HELIO2("JD-HELIO", VALUE.REAL, "Heliocentric Julian Date"),
/**
* UT of midpoint of exposure.
*/
MIDPOINT(VALUE.REAL, "midpoint of exposure"),
/**
* user-entered information; free-form notes.
*/
NOTES(VALUE.REAL, "free-form note"),
/**
* nominal altitude of center of image
*/
OBJCTALT(VALUE.REAL, "altitude of center of image"),
/**
* nominal azimuth of center of image
*/
OBJCTAZ(VALUE.REAL, "nominal azimuth of center of image"),
/**
* nominal hour angle of center of image
*/
OBJCTHA(VALUE.REAL, "nominal hour angle of center of image"),
/**
* indicates side-of-pier status when connected to a German Equatorial
* mount.
*/
PIERSIDE(VALUE.REAL, "side-of-pier status"),
/**
* records the selected Readout Mode (if any) for the camera.
*/
READOUTM(VALUE.REAL, "Readout Mode for the camera"),
/**
* Rotator angle in degrees, if focal plane rotator is connected.
*/
ROTATANG(VALUE.REAL, "Rotator angle in degrees"),
/**
* indicates tile position within a mosaic.
*/
TILEXY(VALUE.REAL, "tile position within a mosaic"),
/**
* X offset of Bayer array on imaging sensor.
*/
XBAYROFF(VALUE.REAL, "X offset of Bayer array"),
/**
* Y offset of Bayer array on imaging sensor.
*/
YBAYROFF(VALUE.REAL, "Y offset of Bayer array");
@SuppressWarnings("CPD-START")
private final IFitsHeader key;
MaxImDLExt(String key, VALUE valueType, String comment) {
this.key = new FitsHeaderImpl(key, IFitsHeader.SOURCE.MaxImDL, HDU.IMAGE, valueType, comment);
}
MaxImDLExt(VALUE valueType, String comment) {
this.key = new FitsHeaderImpl(name(), IFitsHeader.SOURCE.MaxImDL, HDU.IMAGE, valueType, comment);
}
@Override
public String comment() {
return this.key.comment();
}
@Override
public HDU hdu() {
return this.key.hdu();
}
@Override
public String key() {
return this.key.key();
}
@Override
public IFitsHeader n(int... number) {
return this.key.n(number);
}
@Override
public SOURCE status() {
return this.key.status();
}
@Override
@SuppressWarnings("CPD-END")
public VALUE valueType() {
return this.key.valueType();
}
}
nom/tam/fits/header/Checksum.java 0000664 0000000 0000000 00000010452 12755570700 015744 0 ustar root root package nom.tam.fits.header;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
/**
* File checksum keywords. This data dictionary contains FITS keywords that have
* been widely used within the astronomical community. It is recommended that
* these keywords only be used as defined here.
*
*
* @see http://heasarc.gsfc.nasa.gov/docs/fcg/common_dict.html
*
*
* @author Richard van Nieuwenhoven
*/
public enum Checksum implements IFitsHeader {
/**
* The value field of the CHECKSUM keyword shall contain a 16 character
* string, left justified starting in column 12, containing the ASCII
* encoded complement of the checksum of the FITS HDU (Header and Data
* Unit). The algorithm shall be the 32-bit 1's complement checksum and the
* ASCII encoding that are described in the checksum proposal. The checksum
* is accumulated in FITS datastream order on the same HDU, identical in all
* respects, except that the value of the CHECKSUM keyword shall be set to
* the string '0000000000000000' (ASCII 0's, hex 30) before the checksum is
* computed.
*/
CHECKSUM(HDU.ANY, VALUE.STRING, "checksum for the current HDU"),
/**
* The value field of the CHECKVER keyword shall contain a string, unique in
* the first 8 characters, which distinguishes between any future
* alternative checksum algorithms which may be defined. The default value
* for a missing keyword shall be 'COMPLEMENT' which will represent the
* algorithm defined in the current proposal. It is recommended that this
* keyword be omitted from headers which implement the default ASCII encoded
* 32-bit 1's complement algorithm.
*/
CHECKVER(HDU.ANY, VALUE.STRING, "version of checksum algorithm"),
/**
* The value field of the DATASUM keyword shall be a character string
* containing the unsigned integer value of the checksum of the data records
* of the HDU. For dataless HDU's, this keyword may either be omitted, or
* the value field shall contain the string value '0', which is preferred. A
* missing DATASUM keyword asserts no knowledge of the checksum of the data
* records.
*/
DATASUM(HDU.ANY, VALUE.STRING, "checksum of the data records");
@SuppressWarnings("CPD-START")
private final IFitsHeader key;
Checksum(HDU hdu, VALUE valueType, String comment) {
this.key = new FitsHeaderImpl(name(), IFitsHeader.SOURCE.CHECKSUM, hdu, valueType, comment);
}
@Override
public String comment() {
return this.key.comment();
}
@Override
public HDU hdu() {
return this.key.hdu();
}
@Override
public String key() {
return this.key.key();
}
@Override
public IFitsHeader n(int... number) {
return this.key.n(number);
}
@Override
public SOURCE status() {
return this.key.status();
}
@Override
@SuppressWarnings("CPD-END")
public VALUE valueType() {
return this.key.valueType();
}
}
nom/tam/fits/header/HierarchicalGrouping.java 0000664 0000000 0000000 00000005667 12755570700 020307 0 ustar root root package nom.tam.fits.header;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
/**
* This data dictionary contains FITS keywords that have been widely used within
* the astronomical community. It is recommended that these keywords only be
* used as defined here. These are the Hierarchical file grouping keywords.
*
*
* @see http://heasarc.gsfc.nasa.gov/docs/fcg/common_dict.html
*
*
* @author Richard van Nieuwenhoven
*/
public enum HierarchicalGrouping implements IFitsHeader {
/**
* TODO: find description?
*/
GRPIDn(SOURCE.HEASARC, HDU.TABLE, VALUE.STRING, ""),
/**
* TODO: find description?
*/
GRPLCn(SOURCE.HEASARC, HDU.TABLE, VALUE.STRING, ""),
/**
* the grouping table name. TODO: find description?
*/
GRPNAME(SOURCE.HEASARC, HDU.TABLE, VALUE.STRING, "the grouping table name");
@SuppressWarnings("CPD-START")
private final IFitsHeader key;
HierarchicalGrouping(IFitsHeader.SOURCE status, HDU hdu, VALUE valueType, String comment) {
this.key = new FitsHeaderImpl(name(), status, hdu, valueType, comment);
}
@Override
public String comment() {
return this.key.comment();
}
@Override
public HDU hdu() {
return this.key.hdu();
}
@Override
public String key() {
return this.key.key();
}
@Override
public IFitsHeader n(int... number) {
return this.key.n(number);
}
@Override
public SOURCE status() {
return this.key.status();
}
@Override
@SuppressWarnings("CPD-END")
public VALUE valueType() {
return this.key.valueType();
}
}
nom/tam/fits/header/FitsHeaderImpl.java 0000664 0000000 0000000 00000005316 12755570700 017045 0 ustar root root package nom.tam.fits.header;
import java.io.Serializable;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
public class FitsHeaderImpl implements IFitsHeader, Serializable {
/**
* Serialization id.
*/
private static final long serialVersionUID = 1L;
private final String comment;
private final HDU hdu;
private final String key;
private final SOURCE status;
private final VALUE valueType;
public FitsHeaderImpl(String headerName, SOURCE status, HDU hdu, VALUE valueType, String comment) {
this.key = headerName;
this.status = status;
this.hdu = hdu;
this.valueType = valueType;
this.comment = comment;
}
@Override
public String comment() {
return this.comment;
}
@Override
public HDU hdu() {
return this.hdu;
}
@Override
public String key() {
return this.key;
}
@Override
public IFitsHeader n(int... numbers) {
StringBuffer headerName = new StringBuffer(this.key);
for (int number : numbers) {
int indexOfN = headerName.indexOf("n");
headerName.replace(indexOfN, indexOfN + 1, Integer.toString(number));
}
return new FitsHeaderImpl(headerName.toString(), this.status, this.hdu, this.valueType, this.comment);
}
@Override
public SOURCE status() {
return this.status;
}
@Override
public VALUE valueType() {
return this.valueType;
}
}
nom/tam/fits/header/GenericKey.java 0000664 0000000 0000000 00000011765 12755570700 016237 0 ustar root root package nom.tam.fits.header;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import nom.tam.fits.header.IFitsHeader.HDU;
import nom.tam.fits.header.IFitsHeader.SOURCE;
import nom.tam.fits.header.IFitsHeader.VALUE;
/**
* generic key interface, create an IFitsHeader from a key.
*
* @author ritchie
*/
public final class GenericKey {
private static final int NUMBER_BASE = 10;
/**
* cache of all standard keys, for reusing the standards.
*/
private static final Map STANDARD_KEYS;
static {
Map headers = new HashMap();
for (IFitsHeader key : Standard.values()) {
headers.put(key.key(), key);
}
for (IFitsHeader key : Checksum.values()) {
headers.put(key.key(), key);
}
for (IFitsHeader key : Compression.values()) {
headers.put(key.key(), key);
}
for (IFitsHeader key : DataDescription.values()) {
headers.put(key.key(), key);
}
for (IFitsHeader key : InstrumentDescription.values()) {
headers.put(key.key(), key);
}
for (IFitsHeader key : NonStandard.values()) {
headers.put(key.key(), key);
}
for (IFitsHeader key : ObservationDescription.values()) {
headers.put(key.key(), key);
}
STANDARD_KEYS = Collections.unmodifiableMap(headers);
}
/**
* create a fits header key from a free string
*
* @param key
* the string to create the key for
* @return the IFitsHeader implementation for the key.
*/
public static IFitsHeader create(String key) {
IFitsHeader result = STANDARD_KEYS.get(key);
if (result == null) {
result = new FitsHeaderImpl(key, SOURCE.UNKNOWN, HDU.ANY, VALUE.ANY, "");
}
return result;
}
/**
* create a array of generic fits header keys from a array of string keys.
*
* @param keys
* the array of string keys
* @return the array of IFitsHeaderKeys.
*/
public static IFitsHeader[] create(String[] keys) {
IFitsHeader[] result = new IFitsHeader[keys.length];
for (int index = 0; index < result.length; index++) {
result[index] = create(keys[index]);
}
return result;
}
public static int getN(String card) {
int index = card.length() - 1;
int n = 0;
int numberBase = 1;
while (index >= 0 && Character.isDigit(card.charAt(index))) {
n = n + (card.charAt(index) - '0') * numberBase;
numberBase *= NUMBER_BASE;
index--;
}
return n;
}
/**
* lookup a string key in the standard key sets.
*
* @param key
* the fits key to search.
* @return the found fits key or null
*/
public static IFitsHeader lookup(String key) {
int keyLength = key.length();
if (keyLength > 0 && Character.isDigit(key.charAt(keyLength - 1))) {
StringBuilder builder = new StringBuilder();
for (int index = 0; index < keyLength; index++) {
char character = key.charAt(index);
if (Character.isDigit(character)) {
if (builder.charAt(builder.length() - 1) != 'n') {
builder.append('n');
}
} else {
builder.append(character);
}
}
return STANDARD_KEYS.get(builder.toString());
}
return STANDARD_KEYS.get(key);
}
/**
* utility class do not instanciate it.
*/
private GenericKey() {
}
}
nom/tam/fits/header/NonStandard.java 0000664 0000000 0000000 00000013607 12755570700 016422 0 ustar root root package nom.tam.fits.header;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
/**
* This data dictionary contains FITS keywords that have been widely used within
* the astronomical community. It is recommended that these keywords only be
* used as defined here. These are the Keywords that denote non-standard FITS
* keyword format conventions.
*
*
* @see http://heasarc.gsfc.nasa.gov/docs/fcg/common_dict.html
*
*
* @author Richard van Nieuwenhoven
*/
public enum NonStandard implements IFitsHeader {
/**
* The CONTINUE keyword, when followed by spaces in columns 9 and 10 of the
* card image and a character string enclosed in single quotes starting in
* column 11 or higher, indicates that the quoted string should be treated
* as a continuation of the character string value in the previous key
* keyword. To conform to this convention, the character string value on the
* previous keyword must end with the ampersand character ('&'), but the
* ampersand is not part of the value string and should be deleted before
* concatenating the strings together. The character string value may be
* continued on any number of consecutive CONTINUE keywords, thus
* effectively allowing arbitrarily long strings to be written as keyword
* values.
*/
CONTINUE(SOURCE.HEASARC, HDU.ANY, VALUE.NONE, "denotes the CONTINUE long string keyword convention"),
/**
* The HIERARCH keyword, when followed by spaces in columns 9 and 10 of the
* FITS card image, indicates that the ESO HIERARCH keyword convention
* should be used to interpret the name and value of the keyword. The
* HIERARCH keyword formally has no value because it is not followed by an
* equals sign in column 9. Under the HIERARCH convention the actual name of
* the keyword begins in column 11 of the card image and is terminated by
* the equal sign ('=') character. The name can contain any number of
* characters as long as it fits within columns 11 and 80 of the card image
* and also leaves enough space for the equal sign separator and the value
* field. The name can contain any printable ASCII text character, including
* spaces and lower-case characters, except for the equal sign character
* which serves as the terminator of the name field. Leading and trailing
* spaces in the name field are not significant, but embedded spaces within
* the name are significant. The value field follows the equals sign and
* must conform to the syntax for a free-format value field as defined in
* the FITS Standard. The value field may be null, in which case it contains
* only space characters, otherwise it may contain either a character string
* enclosed in single quotes, the logical constant T or F, an integer
* number, a floating point number, a complex integer number, or a complex
* floating point number. The value field may be followed by an optional
* comment string. The comment field must be separated from the value field
* by a slash character ('/'). It is recommended that the slash character be
* preceeded and followed by a space character. Example: "HIERARCH Filter
* Wheel = 12 / filter position". In this example the logical name of the
* keyword is 'Filter Wheel' and the value is 12.
*/
HIERARCH(SOURCE.ESO, HDU.ANY, VALUE.NONE, "denotes the HIERARCH keyword convention"),
/**
* The presence of this keyword with a value = T in an extension key
* indicates that the keywords contained in the primary key (except the FITS
* Mandatory keywords, and any COMMENT, HISTORY or 'blank' keywords) are to
* be inherited, or logically included in that extension key.
*/
INHERIT(SOURCE.STScI, HDU.EXTENSION, VALUE.LOGICAL, "denotes the INHERIT keyword convention");
@SuppressWarnings("CPD-START")
private final IFitsHeader key;
NonStandard(IFitsHeader.SOURCE status, HDU hdu, VALUE valueType, String comment) {
this.key = new FitsHeaderImpl(name(), status, hdu, valueType, comment);
}
@Override
public String comment() {
return this.key.comment();
}
@Override
public HDU hdu() {
return this.key.hdu();
}
@Override
public String key() {
return this.key.key();
}
@Override
public IFitsHeader n(int... number) {
return this.key.n(number);
}
@Override
public SOURCE status() {
return this.key.status();
}
@Override
@SuppressWarnings("CPD-END")
public VALUE valueType() {
return this.key.valueType();
}
}
nom/tam/fits/header/ObservationDescription.java 0000664 0000000 0000000 00000031456 12755570700 020710 0 ustar root root package nom.tam.fits.header;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
/**
* This data dictionary contains FITS keywords that have been widely used within
* the astronomical community. It is recommended that these keywords only be
* used as defined here. These are the Keywords that describe the observation.
*
*
* @see http://heasarc.gsfc.nasa.gov/docs/fcg/common_dict.html
*
*
* @author Richard van Nieuwenhoven
*/
public enum ObservationDescription implements IFitsHeader {
/**
* The value field shall contain a floating point number giving the air mass
* during the observation by a ground based telescope. The value of the
* airmass is often approximated by the secant of the elevation angle and
* has a value of 1.0 at the zenith and increases towards the horizon. This
* value is assumed to correspond to the start of the observation unless
* another interpretation is clearly explained in the comment field.
*/
AIRMASS(SOURCE.NOAO, HDU.ANY, VALUE.REAL, "air mass"),
/**
* The value field gives the declination of the observation. It may be
* expressed either as a floating point number in units of decimal degrees,
* or as a character string in 'dd:mm:ss.sss' format where the decimal point
* and number of fractional digits are optional. The coordinate reference
* frame is given by the RADECSYS keyword, and the coordinate epoch is given
* by the EQUINOX keyword. Example: -47.25944 or '-47:15:34.00'.
*/
DEC(SOURCE.NOAO, HDU.ANY, VALUE.STRING, "declination of the observed object"),
/**
* The value field shall contain a floating point number giving the nominal
* declination of the pointing direction in units of decimal degrees. The
* coordinate reference frame is given by the RADECSYS keyword, and the
* coordinate epoch is given by the EQUINOX keyword. The precise definition
* of this keyword is instrument-specific, but typically the nominal
* direction corresponds to the direction to which the instrument was
* requested to point. The DEC_PNT keyword should be used to give the actual
* pointed direction.
*/
DEC_NOM(SOURCE.HEASARC, HDU.ANY, VALUE.REAL, "nominal declination of the observation"),
/**
* The value field shall contain a floating point number giving the
* declination of the observed object in units of decimal degrees. The
* coordinate reference frame is given by the RADECSYS keyword, and the
* coordinate epoch is given by the EQUINOX keyword.
*/
DEC_OBJ(SOURCE.HEASARC, HDU.ANY, VALUE.REAL, "declination of the observed object"),
/**
* The value field shall contain a floating point number giving the
* declination of the pointing direction in units of decimal degrees. The
* coordinate reference frame is given by the RADECSYS keyword, and the
* coordinate epoch is given by the EQUINOX keyword. The precise definition
* of this keyword is instrument-specific, but typically the pointed
* direction corresponds to the optical axis of the instrument. This keyword
* gives a mean value in cases where the pointing axis was not fixed during
* the entire observation.
*/
DEC_PNT(SOURCE.HEASARC, HDU.ANY, VALUE.REAL, "declination of the pointed direction of the instrument"),
/**
* The value field shall contain a floating point number giving the
* declination of the space craft (or telescope platform) X axis during the
* observation in decimal degrees. The coordinate reference frame is given
* by the RADECSYS keyword, and the coordinate epoch is given by the EQUINOX
* keyword. This keyword gives a mean value in cases where the axis was not
* fixed during the entire observation.
*/
DEC_SCX(SOURCE.HEASARC, HDU.ANY, VALUE.REAL, "declination of the X spacecraft axis"),
/**
* The value field shall contain a floating point number giving the
* declination of the space craft (or telescope platform) Z axis during the
* observation in decimal degrees. The coordinate reference frame is given
* by the RADECSYS keyword, and the coordinate epoch is given by the EQUINOX
* keyword. This keyword gives a mean value in cases where the axis was not
* fixed during the entire observation.
*/
DEC_SCZ(SOURCE.HEASARC, HDU.ANY, VALUE.REAL, "declination of the Z spacecraft axis"),
/**
* The value field shall contain a floating point number giving the
* geographic latitude from which the observation was made in units of
* degrees.
*/
LATITUDE(SOURCE.UCOLICK, HDU.ANY, VALUE.REAL, "geographic latitude of the observation"),
/**
* The value field shall contain a floating point number giving the angle
* between the direction of the observation (e.g., the optical axis of the
* telescope or the position of the target) and the moon, measured in
* degrees.
*/
MOONANGL(SOURCE.STScI, HDU.ANY, VALUE.REAL, "angle between the observation and the moon"),
/**
* The value field shall contain a character string giving a name for the
* observed object that conforms to the IAU astronomical object naming
* conventions. The value of this keyword is more strictly constrained than
* for the standard OBJECT keyword which in practice has often been used to
* record other ancillary information about the observation (e.g. filter,
* exposure time, weather conditions, etc.).
*/
OBJNAME(SOURCE.NOAO, HDU.ANY, VALUE.STRING, "AU name of observed object"),
/**
* The value field shall contain a character string which uniquely
* identifies the dataset contained in the FITS file. This is typically a
* sequence number that can contain a mixture of numerical and character
* values. Example: '10315-01-01-30A'
*/
OBS_ID(SOURCE.HEASARC, HDU.ANY, VALUE.STRING, "unique observation ID"),
/**
* The value field shall contain a floating point number giving the position
* angle of the y axis of the detector projected on the sky, in degrees east
* of north. This keyword is synonymous with the CROTA2 WCS keyword.
*/
ORIENTAT(SOURCE.STScI, HDU.IMAGE, VALUE.REAL, "position angle of image y axis (deg. E of N)"),
/**
* The value field shall contain a floating point number giving the position
* angle of the relevant aspect of telescope pointing axis and/or instrument
* on the sky in units of degrees east of north. It commonly applies to the
* orientation of a slit mask.
*/
PA_PNT(SOURCE.UCOLICK, HDU.ANY, VALUE.REAL, "position angle of the pointing"),
/**
* The value field gives the Right Ascension of the observation. It may be
* expressed either as a floating point number in units of decimal degrees,
* or as a character string in 'HH:MM:SS.sss' format where the decimal point
* and number of fractional digits are optional. The coordinate reference
* frame is given by the RADECSYS keyword, and the coordinate epoch is given
* by the EQUINOX keyword. Example: 180.6904 or '12:02:45.7'.
*/
RA(SOURCE.NOAO, HDU.ANY, VALUE.STRING, "R.A. of the observation"),
/**
* The value field shall contain a floating point number giving the nominal
* Right Ascension of the pointing direction in units of decimal degrees.
* The coordinate reference frame is given by the RADECSYS keyword, and the
* coordinate epoch is given by the EQUINOX keyword. The precise definition
* of this keyword is instrument-specific, but typically the nominal
* direction corresponds to the direction to which the instrument was
* requested to point. The RA_PNT keyword should be used to give the actual
* pointed direction.
*/
RA_NOM(SOURCE.HEASARC, HDU.ANY, VALUE.REAL, "nominal R.A. of the observation"),
/**
* The value field shall contain a floating point number giving the Right
* Ascension of the observed object in units of decimal degrees. The
* coordinate reference frame is given by the RADECSYS keyword, and the
* coordinate epoch is given by the EQUINOX keyword.
*/
RA_OBJ(SOURCE.HEASARC, HDU.ANY, VALUE.REAL, "R.A. of the observed object"),
/**
* The value field shall contain a floating point number giving the Right
* Ascension of the pointing direction in units of decimal degrees. The
* coordinate reference frame is given by the RADECSYS keyword, and the
* coordinate epoch is given by the EQUINOX keyword. The precise definition
* of this keyword is instrument-specific, but typically the pointed
* direction corresponds to the optical axis of the instrument. This keyword
* gives a mean value in cases where the pointing axis was not fixed during
* the entire observation.
*/
RA_PNT(SOURCE.HEASARC, HDU.ANY, VALUE.REAL, "R.A. of the pointed direction of the instrument"),
/**
* The value field shall contain a floating point number giving the Right
* Ascension of the space craft (or telescope platform) X axis during the
* observation in decimal degrees. The coordinate reference frame is given
* by the RADECSYS keyword, and the coordinate epoch is given by the EQUINOX
* keyword. This keyword gives a mean value in cases where the axis was not
* fixed during the entire observation.
*/
RA_SCX(SOURCE.HEASARC, HDU.ANY, VALUE.REAL, "R.A. of the X spacecraft axis"),
/**
* The value field shall contain a floating point number giving the Right
* Ascension of the space craft (or telescope platform) Y axis during the
* observation in decimal degrees. The coordinate reference frame is given
* by the RADECSYS keyword, and the coordinate epoch is given by the EQUINOX
* keyword. This keyword gives a mean value in cases where the axis was not
* fixed during the entire observation.
*/
RA_SCY(SOURCE.HEASARC, HDU.ANY, VALUE.REAL, "R.A. of the Y spacecraft axis"),
/**
* The value field shall contain a floating point number giving the Right
* Ascension of the space craft (or telescope platform) Z axis during the
* observation in decimal degrees. The coordinate reference frame is given
* by the RADECSYS keyword, and the coordinate epoch is given by the EQUINOX
* keyword. This keyword gives a mean value in cases where the axis was not
* fixed during the entire observation.
*/
RA_SCZ(SOURCE.HEASARC, HDU.ANY, VALUE.REAL, "R.A. of the Z spacecraft axis"),
/**
* The value field shall contain a floating point number giving the angle
* between the direction of the observation (e.g., the optical axis of the
* telescope or the position of the target) and the sun, measured in
* degrees.
*/
SUNANGLE(SOURCE.STScI, HDU.ANY, VALUE.REAL, "angle between the observation and the sun");
@SuppressWarnings("CPD-START")
private final IFitsHeader key;
ObservationDescription(IFitsHeader.SOURCE status, HDU hdu, VALUE valueType, String comment) {
this.key = new FitsHeaderImpl(name(), status, hdu, valueType, comment);
}
@Override
public String comment() {
return this.key.comment();
}
@Override
public HDU hdu() {
return this.key.hdu();
}
@Override
public String key() {
return this.key.key();
}
@Override
public IFitsHeader n(int... number) {
return this.key.n(number);
}
@Override
public SOURCE status() {
return this.key.status();
}
@Override
@SuppressWarnings("CPD-END")
public VALUE valueType() {
return this.key.valueType();
}
}
nom/tam/fits/header/StandardCommentReplacement.java 0000664 0000000 0000000 00000004227 12755570700 021450 0 ustar root root package nom.tam.fits.header;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
/**
* Specify user defined comments for standard keywords.
*
* @author ritchie
*/
class StandardCommentReplacement {
private String comment;
private final Class context;
private final String ref;
protected StandardCommentReplacement(String ref, Class context) {
this.ref = ref;
this.context = context;
this.comment = null;
}
protected StandardCommentReplacement(String ref, Class context, String comment) {
this.ref = ref;
this.context = context;
this.comment = comment;
}
public String getComment() {
return this.comment;
}
public Class getContext() {
return this.context;
}
public String getRef() {
return this.ref;
}
public void setComment(String comment) {
this.comment = comment;
}
}
nom/tam/fits/header/Synonyms.java 0000664 0000000 0000000 00000006123 12755570700 016041 0 ustar root root package nom.tam.fits.header;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import nom.tam.fits.header.extra.NOAOExt;
import nom.tam.fits.header.extra.SBFitsExt;
import nom.tam.fits.header.extra.STScIExt;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
/**
* This enum wil try to list synonyms inside or over different dictionaries. So
* please use always the higest level keyword you can find.
*
* @author Richard van Nieuwenhoven
*/
public enum Synonyms {
EQUINOX(Standard.EQUINOX, Standard.EPOCH),
TIMESYS(NOAOExt.TIMESYS, STScIExt.TIMESYS),
RADESYS(Standard.RADESYS, Standard.RADECSYS),
DARKTIME(NOAOExt.DARKTIME, SBFitsExt.DARKTIME);
private final IFitsHeader primaryKeyword;
private final IFitsHeader[] synonyms;
Synonyms(IFitsHeader primaryKeyword, IFitsHeader... synonyms) {
this.primaryKeyword = primaryKeyword;
this.synonyms = synonyms;
}
@SuppressFBWarnings(value = "EI_EXPOSE_REP", justification = "by convention the array may not be changed.")
public IFitsHeader[] getSynonyms() {
return this.synonyms;
}
public IFitsHeader primaryKeyword() {
return this.primaryKeyword;
}
public static IFitsHeader primaryKeyword(IFitsHeader header) {
for (Synonyms synonym : values()) {
for (IFitsHeader synHeader : synonym.synonyms) {
if (synHeader.equals(header)) {
return synonym.primaryKeyword();
}
}
}
return header;
}
public static String primaryKeyword(String header) {
for (Synonyms synonym : values()) {
for (IFitsHeader synHeader : synonym.synonyms) {
if (synHeader.key().equals(header)) {
return synonym.primaryKeyword().key();
}
}
}
return header;
}
}
nom/tam/fits/header/hierarch/ 0000775 0000000 0000000 00000000000 12755570710 015123 5 ustar root root nom/tam/fits/header/hierarch/IHierarchKeyFormatter.java 0000664 0000000 0000000 00000002734 12755570700 022166 0 ustar root root package nom.tam.fits.header.hierarch;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2016 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import nom.tam.fits.utilities.FitsLineAppender;
public interface IHierarchKeyFormatter {
void append(String key, FitsLineAppender buffer);
}
nom/tam/fits/header/hierarch/StandardIHierarchKeyFormatter.java 0000664 0000000 0000000 00000003115 12755570700 023641 0 ustar root root package nom.tam.fits.header.hierarch;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2016 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import nom.tam.fits.utilities.FitsLineAppender;
public class StandardIHierarchKeyFormatter implements IHierarchKeyFormatter {
@Override
public void append(String key, FitsLineAppender buffer) {
buffer.appendReplacing(key, '.', ' ');
}
}
nom/tam/fits/header/hierarch/BlanksDotHierarchKeyFormatter.java 0000664 0000000 0000000 00000004200 12755570700 023645 0 ustar root root package nom.tam.fits.header.hierarch;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2016 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import nom.tam.fits.header.NonStandard;
import nom.tam.fits.utilities.FitsLineAppender;
public class BlanksDotHierarchKeyFormatter implements IHierarchKeyFormatter {
private static final String HIERARCH_TEXT = NonStandard.HIERARCH.key();
private static final int HIERARCH_KEY_OFFSET = HIERARCH_TEXT.length() + 1;
private final String blanks;
public BlanksDotHierarchKeyFormatter(int count) {
StringBuilder builder = new StringBuilder();
for (int index = 0; index < count; index++) {
builder.append(' ');
}
blanks = builder.toString();
}
@Override
public void append(String key, FitsLineAppender buffer) {
buffer.append(HIERARCH_TEXT);
buffer.append(blanks);
buffer.append(key, HIERARCH_KEY_OFFSET, key.length());
}
}
nom/tam/fits/header/Compression.java 0000664 0000000 0000000 00000062557 12755570700 016520 0 ustar root root package nom.tam.fits.header;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
/**
* The following keywords are defined by the compression convention for use in
* the header of the FITS binary table extension to describe the structure of
* the compressed image.
*/
public enum Compression implements IFitsHeader {
/**
* (required keyword) This keyword must have the logical value T. The value
* field of this keyword shall be ’T’ to indicate that the FITS binary table
* extension contains a compressed BINTABLE, and that logically this
* extension should be interpreted as a tile-compressed binary table.
*/
ZTABLE(HDU.ANY, VALUE.LOGICAL, ""),
/**
* (required keyword) This keyword must have the logical value T. It
* indicates that the FITS binary table extension contains a compressed
* image and that logically this extension should be interpreted as an image
* and not as a table.
*/
ZIMAGE(HDU.ANY, VALUE.LOGICAL, ""),
/**
* (required keyword) The value field of this keyword shall contain a
* character string giving the name of the algorithm that must be used to
* decompress the image. Currently, values of GZIP 1 , GZIP 2 , RICE 1 ,
* PLIO 1 , and HCOMPRESS 1 are reserved, and the corresponding algorithms
* are described in a later section of this document . The value RICE ONE is
* also reserved as an alias for RICE 1 .
*/
ZCMPTYPE(HDU.ANY, VALUE.STRING, ""),
/**
* (required keyword) The value field of this keyword shall contain an
* integer that gives the value of the BITPIX keyword in the uncompressed
* FITS image. 1
*/
ZBITPIX(HDU.ANY, VALUE.INTEGER, "", Standard.BITPIX),
/**
* (required keyword) The value field of this keyword shall contain an
* integer that gives the value of the NAXIS keyword in the uncompressed
* FITS image.
*/
ZNAXIS(HDU.ANY, VALUE.INTEGER, "", Standard.NAXIS),
/**
* (required keywords) The value field of these keywords shall contain a
* positive integer that gives the value of the NAXISn keywords in the
* uncompressed FITS image.
*/
ZNAXISn(HDU.ANY, VALUE.INTEGER, "", Standard.NAXISn),
/**
* (optional keywords) The value of these indexed keywords (where n ranges
* from 1 to ZNAXIS ) shall contain a positive integer representing the
* number o f pixels along axis n of the compression tiles. Each tile of
* pixels is compressed separately and stored in a row of a variable-length
* vector column in the binary table. The size of each image dimension
* (given by ZNAXISn ) is not required to be an integer multiple of ZTILEn,
* and if it is not, then the last tile along that dimension of the image
* will contain fewer image pixels than the other tiles. If the ZTILEn
* keywords are not present then the default ’row by row’ tiling will be
* assumed such that ZTILE1 = ZNAXIS1 , and the value of all the other
* ZTILEn keywords equals 1. The compressed image tiles are stored in the
* binary table in t he same order that the first pixel in each tile appears
* in the FITS image; the tile containing the first pixel in the image
* appears in the first row of the table, and the tile containing the last
* pixel in the image appears in the last row of the binary table.
*/
ZTILEn(HDU.ANY, VALUE.INTEGER, ""),
/**
* (optional keywords) These pairs of optional array keywords (where n is an
* integer index number starting with 1) supply the name and value,
* respectively, of any algorithm-specific parameters that are needed to
* compress o r uncompress the image. The value of ZVALn may have any valid
* FITS datatype. The order of the compression parameters may be
* significant, and may be defined as part of the description of the
* specific decompression algorithm.
*/
ZNAMEn(HDU.ANY, VALUE.STRING, ""),
/**
* (optional keywords) These pairs of optional array keywords (where n is an
* integer index number starting with 1) supply the name and value,
* respectively, of any algorithm-specific parameters that are needed to
* compress o r uncompress the image. The value of ZVALn may have any valid
* FITS datatype. The order of the compression parameters may be
* significant, and may be defined as part of the description of the
* specific decompression algorithm.
*/
ZVALn(HDU.ANY, VALUE.ANY, ""),
/**
* (optional keyword) Used to record the name of the image compression
* algorithm that was used to compress the optional null pixel data mask.
* See the “Preserving undefined pixels with lossy compression” section for
* more details.
*/
ZMASKCMP(HDU.ANY, VALUE.STRING, ""),
/**
* The following optional keyword is defined to store a verbatim copy of the
* the value and comment field of the corresponding keyword in the original
* uncompressed FITS image. These keywords can be used to reconstruct an
* identical copy of the original FITS file when the image is
* uncompressed.preserves the original SIMPLE keyword.may only be used if
* the original uncompressed image was contained in the primary array of the
* FITS file.
*/
ZSIMPLE(HDU.PRIMARY, VALUE.LOGICAL, "", Standard.SIMPLE),
/**
* The following optional keyword is defined to store a verbatim copy of the
* the value and comment field of the corresponding keyword in the original
* uncompressed FITS image. These keywords can be used to reconstruct an
* identical copy o f the original FITS file when the image is
* uncompressed.preserves the original XTENSION keyword.may only be used if
* the original uncompressed image was contained in in IMAGE extension.
*/
ZTENSION(HDU.ANY, VALUE.STRING, "", Standard.XTENSION),
/**
* The following optional keyword is defined to store a verbatim copy of the
* the value and comment field of the corresponding keyword in the original
* uncompressed FITS image. These keywords can be used to reconstruct an
* identical copy of the original FITS file when the image is
* uncompressed.preserves the original EXTEND keyword.may only be used if
* the original uncompressed image was contained in the primary array of the
* FITS file.
*/
ZEXTEND(HDU.PRIMARY, VALUE.LOGICAL, "", Standard.EXTEND),
/**
* The following optional keyword is defined to store a verbatim copy of the
* the value and comment field of the corresponding keyword in the original
* uncompressed FITS image. These keywords can be used to reconstruct an
* identical copy o f the original FITS file when the image is
* uncompressed.preserves the original BLOCKED keyword.may only be used if
* the original uncompressed image was contained in the primary array of the
* FITS file,
*/
@Deprecated ZBLOCKED(HDU.PRIMARY, VALUE.LOGICAL, "", Standard.BLOCKED),
/**
* The following optional keyword is defined to store a verbatim copy of the
* the value and comment field of the corresponding keyword in the original
* uncompressed FITS image. These keywords can be used to reconstruct an
* identical copy o f the original FITS file when the image is
* uncompressed.preserves the original PCOUNT keyword.may only be used if
* the original uncompressed image was contained in in IMAGE extension.
*/
ZPCOUNT(HDU.EXTENSION, VALUE.INTEGER, "", Standard.PCOUNT),
/**
* The following optional keyword is defined to store a verbatim copy of the
* the value and comment field of the corresponding keyword in the original
* uncompressed FITS image. These keywords can be used to reconstruct an
* identical copy o f the original FITS file when the image is
* uncompressed.preserves the original GCOUNT keyword.may only be used if
* the original uncompressed image was contained in in IMAGE extension.
*/
ZGCOUNT(HDU.EXTENSION, VALUE.INTEGER, "", Standard.GCOUNT),
/**
* The following optional keyword is defined to store a verbatim copy of the
* the value and comment field of the corresponding keyword in the original
* uncompressed FITS image. These keywords can be used to reconstruct an
* identical copy o f the original FITS file when the image is
* uncompressed.preserves the original CHECKSUM keyword.
*/
ZHECKSUM(HDU.ANY, VALUE.STRING, "", Checksum.CHECKSUM),
/**
* The following optional keyword is defined to store a verbatim copy of the
* the value and comment field of the corresponding keyword in the original
* uncompressed FITS image. These keywords can be used to reconstruct an
* identical copy o f the original FITS file when the image is
* uncompressed.preserves the original DATASUM
*/
ZDATASUM(HDU.ANY, VALUE.STRING, "", Checksum.DATASUM),
/**
* (optional keyword) This keyword records the name of the algorithm that
* was used to quantize floating-point image pixels into integer values
* which are then passed to the compression algorithm.
*/
ZQUANTIZ(HDU.ANY, VALUE.STRING, ""),
/**
* (optional keyword) The value field of this keyword shall contain an
* integer that gives the seed value for the random dithering pattern that
* was used when quantizing the floating-point pixel values. The value may
* range from 1 to 100.00, inclusive.
*/
ZDITHER0(HDU.ANY, VALUE.INTEGER, ""),
/**
* When using the quantization method to compress floating-point images,
* this header is used to store the integer value that represents undefined
* pixels (if any) in the scaled integer pixel values. These pixels have an
* IEEE NaN value (Not a Number) in the uncompressed floating-point image.
* The recommended value for ZBLANK is -2147483648 (the largest negative
* 32-bit integer).
*/
ZBLANK(HDU.ANY, VALUE.INTEGER, ""),
/**
* The value field of this keyword shall contain an integer representing the
* number of rows of data from the original binary table that are contained
* in each tile of the compressed table. The number of rows in the last tile
* may be less than in the previous tiles. Note that if the entire table is
* compressed as a single tile, then the compressed table will only contains
* a single row, and the ZTILELEN and ZNAXIS2 keywords will have the same
* value.
*/
ZTILELEN(HDU.ANY, VALUE.INTEGER, ""),
/**
* The value field of these keywords shall contain the character string
* values of the corresponding TFORMn keywords that defines the data type of
* column n in the original uncompressed FITS table.
*/
ZFORMn(HDU.ANY, VALUE.STRING, "", Standard.TFORMn),
/**
* The value field of these keywords shall contain a charac- ter string
* giving the mnemonic name of the algorithm that was used to compress
* column n of the table. The current allowed values are GZIP_1, GZIP_2, and
* RICE_1, and the corresponding algorithms
*/
ZCTYPn(HDU.ANY, VALUE.STRING, "");
/**
* This is the simplest option in which no dithering is performed. The
* floating-point pixels are simply quantized using Eq. 1. This option
* should be assumed if the ZQUANTIZ keyword is not present in the header of
* the compressed floating-point image.
*/
public static final String ZQUANTIZ_NO_DITHER = "NO_DITHER";
/**
* It should be noted that an image that is quantized using this technique
* can stil l be unquantized using the simple linear scaling function given
* by Eq. 1. The only side effect in this ca se is to introduce slightly
* more noise in the image than if the full subtractive dithering algorith m
* were applied.
*/
public static final String ZQUANTIZ_SUBTRACTIVE_DITHER_1 = "SUBTRACTIVE_DITHER_1";
/**
* This dithering algorithm is identical to the SUBTRACTIVE DITHER 1
* algorithm described above, ex- cept that any pixels in the floating-point
* image that are equa l to 0.0 are represented by the reserved value
* -2147483647 in the quantized integer array. When the i mage is
* subsequently uncompressed and unscaled, these pixels are restored to
* their original va lue of 0.0. This dithering option is useful if the
* zero-valued pixels have special significance to the da ta analysis
* software, so that the value of these pixels must not be dithered.
*/
public static final String ZQUANTIZ_SUBTRACTIVE_DITHER_2 = "SUBTRACTIVE_DITHER_2";
/**
* Gzip is the compression algorithm used in the free GN U software utility
* of the same name. It was created by Jean-loup Gailly and Mark Adler and
* is based on the DEFLATE algorithm, which is a combination of LZ77 and
* Huffman coding. DEFLATE was intended as a replacement for LZW and other
* patent-encumbered data compression algor ithms which, at the time,
* limited the usability of compress and other popular archivers. Furt her
* information about this compression technique is readily available on the
* Internet. The gzip alg orithm has no associated parameters that need to
* be specified with the ZNAMEn and ZVALn keywords.
*/
public static final String ZCMPTYPE_GZIP_1 = "GZIP_1";
/**
* If ZCMPTYPE = ’GZIP 2’ then the bytes in the array of image pixel values
* are shuffled in to decreasing order of significance before being
* compressed with the gzip algorithm. In other words, bytes are shuffled so
* that the most significant byte of every pixel occurs first, in order,
* followed by the next most significant byte, and so on for every byte.
* Since the most significan bytes of the pixel values often have very
* similar values, grouping them together in this way often achieves better
* net compression of the array. This is usually especially effective when
* compressing floating-point arrays.
*/
public static final String ZCMPTYPE_GZIP_2 = "GZIP_2";
/**
* If ZCMPTYPE = ’RICE 1’ then the Rice algorithm is used to compress and
* uncompress the image pixels. The Rice algorithm (Rice, R. F., Yeh, P.-S.,
* and Miller, W. H. 1993, in Proc. of the 9th AIAA Computing in Aerospace
* Conf., AIAA-93-4541-CP, American Institute of Aeronautics and
* Astronautics) is simple and very fast, compressing or decompressing 10 7
* pixels/sec on modern workstations. It requires only enough memory to hold
* a single block of 16 or 32 pixels at a time. It codes the pixels in small
* blocks and so is able to adapt very quickly to changes in the input image
* statistics (e.g., Rice has no problem handling cosmic rays, bright stars,
* saturated pixels, etc.).
*/
public static final String ZCMPTYPE_RICE_1 = "RICE_1";
/**
* If ZCMPTYPE = ’PLIO 1’ then the IRAF PLIO (Pixel List) algorithm is used
* to compress and uncompress the image pixels. The PLIO algorithm was
* developed to store integer-valued image masks in a compressed form.
* Typical uses of image masks are to segment images into regions, or to
* mark bad pixels. Such masks often have large regions of constant value
* hence are highly compressible. The compression algorithm used is based on
* run-length encoding, with the ability to dynamically follow level changes
* in the image, allowing a 16-bit encoding to be used regardless of the
* image depth. The worst case performance occurs when successive pixels
* have different values. Even in this case the encoding will only require
* one word (16 bits) per mask pixel, provided either the delta intensity
* change between pixels is usually less than 12 bits, or the mask
* represents a zero floored step function of constant height. The worst
* case cannot exceed npix*2 words provided the mask depth is 24 bits or
* less.
*/
public static final String ZCMPTYPE_PLIO_1 = "PLIO_1";
/**
* Hcompress is an the image compression package written by Richard L. White
* for use at the Space Telescope Science Institute. Hcompress was used to
* compress the STScI Digitized Sky Survey and has also been used to
* compress the preview images in the Hubble Data Archive. Briefly, the
* method used is:
* The null pixels in integer images are flagged by a reserved BLANK value
* and will be preserved if a lossless compression algorithm is used. If the
* image is compressed with a lossy algorithm, however (e.g., H-Compress
* with a scale factor greater than 1), then some other technique must be
* used to identify the null pixels in the image.
*
*
* The recommended method of recording the null pixels when a lossy
* compression algorithm is used is to create an integer data mask with the
* same dimensions as the image tile. Set the null pixels to 1 and all the
* other pixels to 0, then compress the mask array using a lossless
* algorithm such as PLIO or GZIP. Store the compressed byte stream in a
* variable-length array column called ’NULL PIXEL MASK’ in the row
* corresponding to that image tile. The ZMASKCMP keyword should be used to
* record the name of the algorithm used to compress the data mask (e.g.,
* RICE 1). The data mask array pixels will be assumed to have the shortest
* integer datatype that is supported by the compression algorithm (i.e.,
* usually 8-bit bytes).
*
*
* When uncompressing the image tile, the software must check if the
* corresponding compressed data mask exists with a length greater than 0,
* and if so, then uncompress the mask and set the corresponding undefined
* pixels in the image array to the appropriate value (as given by the BLANK
* keyword).
*
*/
public static final String NULL_PIXEL_MASK_COLUMN = "NULL_PIXEL_MASK_COLUMN";
/**
* The number of 8-bit bytes in each original integer pixel value.
*/
public static final String BYTEPIX = "BYTEPIX";
/**
* The blocksize parameter for the rise algorithm.
*/
public static final String BLOCKSIZE = "BLOCKSIZE";
/**
* The integer scale parameter determines the amount of compression. Scale =
* 0 or 1 leads to lossless compression, i.e. the decompressed image has
* exactly the same pixel values as the original image. If the scale factor
* is greater than 1 then the compression is lossy: the decompressed image
* will not be exactly the same as the original.
*/
public static final String SCALE = "SCALE";
/**
* At high compressions factors the decompressed image begins to appear
* blocky because of the way information is discarded. This blockiness is
* greatly reduced, producing more pleasing images, if the image is smoothed
* slightly during decompression. When done properly, the smoothing will not
* affect any quantitative photometric or astrometric measurements derived
* from the compressed image. Of course, the smoothing should never be
* applied when the image has been losslessly compressed with a scale factor
* (defined above) of 0 or 1.
*/
public static final String SMOOTH = "SMOOTH";
@SuppressWarnings("CPD-START")
private final IFitsHeader key;
private final IFitsHeader uncompressedKey;
Compression(HDU hdu, VALUE valueType, String comment) {
this(hdu, valueType, comment, null);
}
Compression(HDU hdu, VALUE valueType, String comment, IFitsHeader uncompressedKey) {
this.key = new FitsHeaderImpl(name(), IFitsHeader.SOURCE.HEASARC, hdu, valueType, comment);
this.uncompressedKey = uncompressedKey;
}
@Override
public String comment() {
return this.key.comment();
}
public IFitsHeader getUncompressedKey() {
return this.uncompressedKey;
}
@Override
public HDU hdu() {
return this.key.hdu();
}
@Override
public String key() {
return this.key.key();
}
@Override
public IFitsHeader n(int... number) {
return this.key.n(number);
}
@Override
public SOURCE status() {
return this.key.status();
}
@Override
@SuppressWarnings("CPD-END")
public VALUE valueType() {
return this.key.valueType();
}
}
nom/tam/fits/RandomGroupsHDU.java 0000664 0000000 0000000 00000024130 12755570700 015731 0 ustar root root package nom.tam.fits;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import static nom.tam.fits.header.Standard.BITPIX;
import static nom.tam.fits.header.Standard.GCOUNT;
import static nom.tam.fits.header.Standard.GROUPS;
import static nom.tam.fits.header.Standard.NAXIS;
import static nom.tam.fits.header.Standard.NAXISn;
import static nom.tam.fits.header.Standard.PCOUNT;
import static nom.tam.fits.header.Standard.SIMPLE;
import static nom.tam.fits.header.Standard.XTENSION;
import static nom.tam.fits.header.Standard.XTENSION_IMAGE;
import java.io.PrintStream;
import java.util.logging.Logger;
import nom.tam.util.ArrayFuncs;
/**
* Random groups HDUs. Note that the internal storage of random groups is a
* Object[ngroup][2] array. The first element of each group is the parameter
* data from that group. The second element is the data. The parameters should
* be a one dimensional array of the primitive types byte, short, int, long,
* float or double. The second element is a n-dimensional array of the same
* type. When analyzing group data structure only the first group is examined,
* but for a valid FITS file all groups must have the same structure.
*/
public class RandomGroupsHDU extends BasicHDU {
private static final Logger LOG = Logger.getLogger(RandomGroupsHDU.class.getName());
public static RandomGroupsData encapsulate(Object o) throws FitsException {
if (o instanceof Object[][]) {
return new RandomGroupsData((Object[][]) o);
} else {
throw new FitsException("Attempt to encapsulate invalid data in Random Group");
}
}
static Object[] generateSampleRow(Header h) throws FitsException {
int ndim = h.getIntValue(NAXIS, 0) - 1;
int[] dims = new int[ndim];
int bitpix = h.getIntValue(BITPIX, 0);
Class baseClass;
switch (bitpix) {
case BasicHDU.BITPIX_BYTE:
baseClass = Byte.TYPE;
break;
case BasicHDU.BITPIX_SHORT:
baseClass = Short.TYPE;
break;
case BasicHDU.BITPIX_INT:
baseClass = Integer.TYPE;
break;
case BasicHDU.BITPIX_LONG:
baseClass = Long.TYPE;
break;
case BasicHDU.BITPIX_FLOAT:
baseClass = Float.TYPE;
break;
case BasicHDU.BITPIX_DOUBLE:
baseClass = Double.TYPE;
break;
default:
throw new FitsException("Invalid BITPIX:" + bitpix);
}
// Note that we have to invert the order of the axes
// for the FITS file to get the order in the array we
// are generating. Also recall that NAXIS1=0, so that
// we have an 'extra' dimension.
for (int i = 0; i < ndim; i += 1) {
long cdim = h.getIntValue(NAXISn.n(i + 2), 0);
if (cdim < 0) {
throw new FitsException("Invalid array dimension:" + cdim);
}
dims[ndim - i - 1] = (int) cdim;
}
Object[] sample = new Object[2];
sample[0] = ArrayFuncs.newInstance(baseClass, h.getIntValue(PCOUNT));
sample[1] = ArrayFuncs.newInstance(baseClass, dims);
return sample;
}
/**
* Check if this data is compatible with Random Groups structure. Must be an
* Object[ngr][2] structure with both elements of each group having the same
* base type and the first element being a simple primitive array. We do not
* check anything but the first row.
*
* @param potentialData
* data to check
* @return is this data compatible with Random Groups structure
*/
public static boolean isData(Object potentialData) {
if (potentialData instanceof Object[][]) {
Object[][] o = (Object[][]) potentialData;
if (o.length > 0 && o[0].length == 2 && //
ArrayFuncs.getBaseClass(o[0][0]) == ArrayFuncs.getBaseClass(o[0][1])) {
String cn = o[0][0].getClass().getName();
if (cn.length() == 2 && cn.charAt(1) != 'Z' || cn.charAt(1) != 'C') {
return true;
}
}
}
return false;
}
/**
* @return Is this a random groups header?
* @param hdr
* The header to be tested.
*/
public static boolean isHeader(Header hdr) {
if (hdr.getBooleanValue(SIMPLE)) {
return hdr.getBooleanValue(GROUPS);
}
String xtension = hdr.getStringValue(XTENSION);
xtension = xtension == null ? "" : xtension.trim();
if (XTENSION_IMAGE.equals(xtension)) {
return hdr.getBooleanValue(GROUPS);
}
return false;
}
/**
* @return Create FITS data object corresponding to a given header.
* @param header
* header for the data creation
* @throws FitsException
* if the operation failed
*/
public static RandomGroupsData manufactureData(Header header) throws FitsException {
int gcount = header.getIntValue(GCOUNT, -1);
int pcount = header.getIntValue(PCOUNT, -1);
if (!header.getBooleanValue(GROUPS) || header.getIntValue(NAXISn.n(1), -1) != 0 || gcount < 0 || pcount < 0 || header.getIntValue(NAXIS) < 2) {
throw new FitsException("Invalid Random Groups Parameters");
}
// Allocate the object.
Object[][] dataArray;
if (gcount > 0) {
dataArray = new Object[gcount][2];
} else {
dataArray = new Object[0][];
}
Object[] sampleRow = generateSampleRow(header);
for (int i = 0; i < gcount; i += 1) {
dataArray[i][0] = ((Object[]) ArrayFuncs.deepClone(sampleRow))[0];
dataArray[i][1] = ((Object[]) ArrayFuncs.deepClone(sampleRow))[1];
}
return new RandomGroupsData(dataArray);
}
/**
* @return Make a header point to the given object.
* @param d
* The random groups data the header should describe.
* @throws FitsException
* if the operation failed
*/
static Header manufactureHeader(Data d) throws FitsException {
if (d == null) {
throw new FitsException("Attempt to create null Random Groups data");
}
Header h = new Header();
d.fillHeader(h);
return h;
}
/**
* Create an HDU from the given header and data .
*
* @param header
* header to use
* @param data
* data to use
*/
public RandomGroupsHDU(Header header, RandomGroupsData data) {
super(header, data);
}
@Override
protected boolean canBePrimary() {
return true;
}
@Override
public void info(PrintStream stream) {
stream.println("Random Groups HDU");
if (this.myHeader != null) {
stream.println(" HeaderInformation:");
stream.println(" Ngroups:" + this.myHeader.getIntValue(GCOUNT));
stream.println(" Npar: " + this.myHeader.getIntValue(PCOUNT));
stream.println(" BITPIX: " + this.myHeader.getIntValue(BITPIX));
stream.println(" NAXIS: " + this.myHeader.getIntValue(NAXIS));
for (int i = 0; i < this.myHeader.getIntValue(NAXIS); i += 1) {
stream.println(" NAXIS" + (i + 1) + "= " + this.myHeader.getIntValue(NAXISn.n(i + 1)));
}
} else {
stream.println(" No Header Information");
}
Object[][] data = null;
if (this.myData != null) {
data = (Object[][]) this.myData.getData();
}
if (data == null || data.length < 1 || data[0].length != 2) {
stream.println(" Invalid/unreadable data");
} else {
stream.println(" Number of groups:" + data.length);
stream.println(" Parameters: " + ArrayFuncs.arrayDescription(data[0][0]));
stream.println(" Data:" + ArrayFuncs.arrayDescription(data[0][1]));
}
}
/**
* Check that this HDU has a valid header.
*
* @return true if this HDU has a valid header.
*/
public boolean isHeader() {
return isHeader(this.myHeader);
}
/**
* Move a RandomGroupsHDU to or from the beginning of a FITS file. Note that
* the FITS standard only supports Random Groups data at the beginning of
* the file, but we allow it within Image extensions.
*
* @param status
* true if the header should be primary
*/
@Override
protected void setPrimaryHDU(boolean status) throws FitsException {
super.setPrimaryHDU(status);
if (status) {
this.myHeader.setSimple(true);
} else {
this.myHeader.setXtension(XTENSION_IMAGE);
}
}
}
nom/tam/fits/AsciiTable.java 0000664 0000000 0000000 00000105343 12755570700 014756 0 ustar root root package nom.tam.fits;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import static nom.tam.fits.header.Standard.GCOUNT;
import static nom.tam.fits.header.Standard.NAXIS1;
import static nom.tam.fits.header.Standard.NAXIS2;
import static nom.tam.fits.header.Standard.PCOUNT;
import static nom.tam.fits.header.Standard.TBCOLn;
import static nom.tam.fits.header.Standard.TFIELDS;
import static nom.tam.fits.header.Standard.TFORMn;
import static nom.tam.fits.header.Standard.TNULLn;
import java.io.EOFException;
import java.io.IOException;
import java.lang.reflect.Array;
import java.util.logging.Level;
import java.util.logging.Logger;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import nom.tam.fits.header.IFitsHeader;
import nom.tam.fits.header.Standard;
import nom.tam.util.ArrayDataInput;
import nom.tam.util.ArrayDataOutput;
import nom.tam.util.ArrayFuncs;
import nom.tam.util.ByteFormatter;
import nom.tam.util.ByteParser;
import nom.tam.util.Cursor;
import nom.tam.util.FormatException;
import nom.tam.util.RandomAccess;
/**
* This class represents the data in an ASCII table
*/
public class AsciiTable extends AbstractTableData {
private static final int MAX_INTEGER_LENGTH = 10;
private static final int FLOAT_MAX_LENGTH = 16;
private static final int LONG_MAX_LENGTH = 20;
private static final int INT_MAX_LENGTH = 10;
private static final int DOUBLE_MAX_LENGTH = 24;
private static final Logger LOG = Logger.getLogger(AsciiTable.class.getName());
/** The number of rows in the table */
private int nRows;
/** The number of fields in the table */
private int nFields;
/** The number of bytes in a row */
private int rowLen;
/** The null string for the field */
private String[] nulls;
/** The type of data in the field */
private Class[] types;
/** The offset from the beginning of the row at which the field starts */
private int[] offsets;
/** The number of bytes in the field */
private int[] lengths;
/** The byte buffer used to read/write the ASCII table */
private byte[] buffer;
/** Markers indicating fields that are null */
private boolean[] isNull;
/**
* An array of arrays giving the data in the table in binary numbers
*/
private Object[] data;
/**
* The parser used to convert from buffer to data.
*/
private ByteParser bp;
/** The actual stream used to input data */
private ArrayDataInput currInput;
/** Create an empty ASCII table */
public AsciiTable() {
this.data = new Object[0];
this.buffer = null;
this.nFields = 0;
this.nRows = 0;
this.rowLen = 0;
this.types = new Class[0];
this.lengths = new int[0];
this.offsets = new int[0];
this.nulls = new String[0];
}
/**
* Create an ASCII table given a header
*
* @param hdr
* The header describing the table
* @throws FitsException
* if the operation failed
*/
public AsciiTable(Header hdr) throws FitsException {
this.nRows = hdr.getIntValue(NAXIS2);
this.nFields = hdr.getIntValue(TFIELDS);
this.rowLen = hdr.getIntValue(NAXIS1);
this.types = new Class[this.nFields];
this.offsets = new int[this.nFields];
this.lengths = new int[this.nFields];
this.nulls = new String[this.nFields];
for (int i = 0; i < this.nFields; i += 1) {
this.offsets[i] = hdr.getIntValue(TBCOLn.n(i + 1)) - 1;
String s = hdr.getStringValue(TFORMn.n(i + 1));
if (this.offsets[i] < 0 || s == null) {
throw new FitsException("Invalid Specification for column:" + (i + 1));
}
s = s.trim();
char c = s.charAt(0);
s = s.substring(1);
if (s.indexOf('.') > 0) {
s = s.substring(0, s.indexOf('.'));
}
this.lengths[i] = Integer.parseInt(s);
switch (c) {
case 'A':
this.types[i] = String.class;
break;
case 'I':
if (this.lengths[i] > MAX_INTEGER_LENGTH) {
this.types[i] = long.class;
} else {
this.types[i] = int.class;
}
break;
case 'F':
case 'E':
this.types[i] = float.class;
break;
case 'D':
this.types[i] = double.class;
break;
default:
throw new FitsException("could not parse column type of ascii table");
}
this.nulls[i] = hdr.getStringValue(TNULLn.n(i + 1));
if (this.nulls[i] != null) {
this.nulls[i] = this.nulls[i].trim();
}
}
}
int addColInfo(int col, Cursor iter) throws HeaderCardException {
String tform = null;
if (this.types[col] == String.class) {
tform = "A" + this.lengths[col];
} else if (this.types[col] == int.class || this.types[col] == long.class) {
tform = "I" + this.lengths[col];
} else if (this.types[col] == float.class) {
tform = "E" + this.lengths[col] + ".0";
} else if (this.types[col] == double.class) {
tform = "D" + this.lengths[col] + ".0";
}
Standard.context(AsciiTable.class);
IFitsHeader key = TFORMn.n(col + 1);
iter.add(new HeaderCard(key.key(), tform, key.comment()));
key = TBCOLn.n(col + 1);
iter.add(new HeaderCard(key.key(), this.offsets[col] + 1, key.comment()));
Standard.context(null);
return this.lengths[col];
}
@Override
public int addColumn(Object newCol) throws FitsException {
int maxLen = 1;
if (newCol instanceof String[]) {
String[] sa = (String[]) newCol;
for (String element : sa) {
if (element != null && element.length() > maxLen) {
maxLen = element.length();
}
}
} else if (newCol instanceof double[]) {
maxLen = DOUBLE_MAX_LENGTH;
} else if (newCol instanceof int[]) {
maxLen = INT_MAX_LENGTH;
} else if (newCol instanceof long[]) {
maxLen = LONG_MAX_LENGTH;
} else if (newCol instanceof float[]) {
maxLen = FLOAT_MAX_LENGTH;
} else {
throw new FitsException("Adding invalid type to ASCII table");
}
addColumn(newCol, maxLen);
// Invalidate the buffer
this.buffer = null;
return this.nFields;
}
/**
* This version of addColumn allows the user to override the default length
* associated with each column type.
*
* @param newCol
* The new column data
* @param length
* the requested length for the column
* @return the number of columns after this one is added.
* @throws FitsException
* if the operation failed
*/
public int addColumn(Object newCol, int length) throws FitsException {
if (this.nFields > 0 && Array.getLength(newCol) != this.nRows) {
throw new FitsException("New column has different number of rows");
}
if (this.nFields == 0) {
this.nRows = Array.getLength(newCol);
}
Object[] newData = new Object[this.nFields + 1];
int[] newOffsets = new int[this.nFields + 1];
int[] newLengths = new int[this.nFields + 1];
Class[] newTypes = new Class[this.nFields + 1];
String[] newNulls = new String[this.nFields + 1];
System.arraycopy(this.data, 0, newData, 0, this.nFields);
System.arraycopy(this.offsets, 0, newOffsets, 0, this.nFields);
System.arraycopy(this.lengths, 0, newLengths, 0, this.nFields);
System.arraycopy(this.types, 0, newTypes, 0, this.nFields);
System.arraycopy(this.nulls, 0, newNulls, 0, this.nFields);
this.data = newData;
this.offsets = newOffsets;
this.lengths = newLengths;
this.types = newTypes;
this.nulls = newNulls;
newData[this.nFields] = newCol;
this.offsets[this.nFields] = this.rowLen + 1;
this.lengths[this.nFields] = length;
this.types[this.nFields] = ArrayFuncs.getBaseClass(newCol);
this.rowLen += length + 1;
if (this.isNull != null) {
boolean[] newIsNull = new boolean[this.nRows * (this.nFields + 1)];
// Fix the null pointers.
int add = 0;
for (int i = 0; i < this.isNull.length; i += 1) {
if (i % this.nFields == 0) {
add += 1;
}
if (this.isNull[i]) {
newIsNull[i + add] = true;
}
}
this.isNull = newIsNull;
}
this.nFields += 1;
// Invalidate the buffer
this.buffer = null;
return this.nFields;
}
@Override
public int addRow(Object[] newRow) throws FitsException {
try {
// If there are no fields, then this is the
// first row. We need to add in each of the columns
// to get the descriptors set up.
if (this.nFields == 0) {
for (Object element : newRow) {
addColumn(element);
}
} else {
for (int i = 0; i < this.nFields; i += 1) {
Object o = ArrayFuncs.newInstance(this.types[i], this.nRows + 1);
System.arraycopy(this.data[i], 0, o, 0, this.nRows);
System.arraycopy(newRow[i], 0, o, this.nRows, 1);
this.data[i] = o;
}
this.nRows += 1;
}
// Invalidate the buffer
this.buffer = null;
return this.nRows;
} catch (Exception e) {
throw new FitsException("Error addnig row:" + e.getMessage(), e);
}
}
/**
* Delete columns from the table.
*
* @param start
* The first, 0-indexed, column to be deleted.
* @param len
* The number of columns to be deleted.
* @throws FitsException
* if the operation failed
*/
@Override
public void deleteColumns(int start, int len) throws FitsException {
ensureData();
Object[] newData = new Object[this.nFields - len];
int[] newOffsets = new int[this.nFields - len];
int[] newLengths = new int[this.nFields - len];
Class[] newTypes = new Class[this.nFields - len];
String[] newNulls = new String[this.nFields - len];
// Copy in the initial stuff...
System.arraycopy(this.data, 0, newData, 0, start);
// Don't do the offsets here.
System.arraycopy(this.lengths, 0, newLengths, 0, start);
System.arraycopy(this.types, 0, newTypes, 0, start);
System.arraycopy(this.nulls, 0, newNulls, 0, start);
// Copy in the final
System.arraycopy(this.data, start + len, newData, start, this.nFields - start - len);
// Don't do the offsets here.
System.arraycopy(this.lengths, start + len, newLengths, start, this.nFields - start - len);
System.arraycopy(this.types, start + len, newTypes, start, this.nFields - start - len);
System.arraycopy(this.nulls, start + len, newNulls, start, this.nFields - start - len);
for (int i = start; i < start + len; i += 1) {
this.rowLen -= this.lengths[i] + 1;
}
this.data = newData;
this.offsets = newOffsets;
this.lengths = newLengths;
this.types = newTypes;
this.nulls = newNulls;
if (this.isNull != null) {
boolean found = false;
boolean[] newIsNull = new boolean[this.nRows * (this.nFields - len)];
for (int i = 0; i < this.nRows; i += 1) {
int oldOff = this.nFields * i;
int newOff = (this.nFields - len) * i;
for (int col = 0; col < start; col += 1) {
newIsNull[newOff + col] = this.isNull[oldOff + col];
found = found || this.isNull[oldOff + col];
}
for (int col = start + len; col < this.nFields; col += 1) {
newIsNull[newOff + col - len] = this.isNull[oldOff + col];
found = found || this.isNull[oldOff + col];
}
}
if (found) {
this.isNull = newIsNull;
} else {
this.isNull = null;
}
}
// Invalidate the buffer
this.buffer = null;
this.nFields -= len;
}
/**
* Delete rows from a FITS table
*
* @param start
* The first (0-indexed) row to be deleted.
* @param len
* The number of rows to be deleted.
* @throws FitsException
* if the operation failed
*/
@Override
public void deleteRows(int start, int len) throws FitsException {
try {
if (this.nRows == 0 || start < 0 || start >= this.nRows || len <= 0) {
return;
}
if (start + len > this.nRows) {
len = this.nRows - start;
}
ensureData();
for (int i = 0; i < this.nFields; i += 1) {
Object o = ArrayFuncs.newInstance(this.types[i], this.nRows - len);
System.arraycopy(this.data[i], 0, o, 0, start);
System.arraycopy(this.data[i], start + len, o, start, this.nRows - len - start);
this.data[i] = o;
}
this.nRows -= len;
} catch (FitsException e) {
throw e;
} catch (Exception e) {
throw new FitsException("Error deleting row:" + e.getMessage(), e);
}
}
/**
* be sure that the data is filled. because the getData already tests null
* the getData is called without check.
*
* @throws FitsException
* if the operation failed
*/
private void ensureData() throws FitsException {
getData();
}
/**
* Move an element from the buffer into a data array.
*
* @param offset
* The offset within buffer at which the element starts.
* @param length
* The number of bytes in the buffer for the element.
* @param array
* An array of objects, each of which is a simple array.
* @param col
* Which element of array is to be modified?
* @param row
* Which index into that element is to be modified?
* @param nullFld
* What string signifies a null element?
* @throws FitsException
* if the operation failed
*/
private boolean extractElement(int offset, int length, Object[] array, int col, int row, String nullFld) throws FitsException {
this.bp.setOffset(offset);
if (nullFld != null) {
String s = this.bp.getString(length);
if (s.trim().equals(nullFld)) {
return false;
}
this.bp.skip(-length);
}
try {
if (array[col] instanceof String[]) {
((String[]) array[col])[row] = this.bp.getString(length);
} else if (array[col] instanceof int[]) {
((int[]) array[col])[row] = this.bp.getInt(length);
} else if (array[col] instanceof float[]) {
((float[]) array[col])[row] = this.bp.getFloat(length);
} else if (array[col] instanceof double[]) {
((double[]) array[col])[row] = this.bp.getDouble(length);
} else if (array[col] instanceof long[]) {
((long[]) array[col])[row] = this.bp.getLong(length);
} else {
throw new FitsException("Invalid type for ASCII table conversion:" + array[col]);
}
} catch (FormatException e) {
throw new FitsException("Error parsing data at row,col:" + row + "," + col + " " + e);
}
return true;
}
/**
* Fill in a header with information that points to this data.
*
* @param hdr
* The header to be updated with information appropriate to the
* current table data.
*/
@Override
public void fillHeader(Header hdr) {
try {
Standard.context(AsciiTable.class);
hdr.setXtension("TABLE");
hdr.setBitpix(BasicHDU.BITPIX_BYTE);
hdr.setNaxes(2);
hdr.setNaxis(1, this.rowLen);
hdr.setNaxis(2, this.nRows);
Cursor iter = hdr.iterator();
iter.setKey(NAXIS2.key());
iter.next();
iter.add(new HeaderCard(PCOUNT.key(), 0, PCOUNT.comment()));
iter.add(new HeaderCard(GCOUNT.key(), 1, GCOUNT.comment()));
iter.add(new HeaderCard(TFIELDS.key(), this.nFields, TFIELDS.comment()));
for (int i = 0; i < this.nFields; i += 1) {
addColInfo(i, iter);
}
} catch (HeaderCardException e) {
LOG.log(Level.SEVERE, "ImpossibleException in fillHeader:" + e.getMessage(), e);
} finally {
Standard.context(null);
}
}
/**
* Read some data into the buffer.
*/
private void getBuffer(int size, long offset) throws IOException, FitsException {
if (this.currInput == null) {
throw new IOException("No stream open to read");
}
this.buffer = new byte[size];
if (offset != 0) {
FitsUtil.reposition(this.currInput, offset);
}
this.currInput.readFully(this.buffer);
this.bp = new ByteParser(this.buffer);
}
/**
* Get a column of data
*
* @param col
* The 0-indexed column to be returned.
* @return The column object -- typically as a 1-d array.
* @throws FitsException
* if the operation failed
*/
@Override
public Object getColumn(int col) throws FitsException {
ensureData();
return this.data[col];
}
/**
* Get the ASCII table information. This will actually do the read if it had
* previously been deferred
*
* @return The table data as an Object[] array.
* @throws FitsException
* if the operation failed
*/
@Override
@SuppressFBWarnings(value = "EI_EXPOSE_REP", justification = "intended exposure of mutable data")
public Object getData() throws FitsException {
if (this.data == null) {
this.data = new Object[this.nFields];
for (int i = 0; i < this.nFields; i += 1) {
this.data[i] = ArrayFuncs.newInstance(this.types[i], this.nRows);
}
if (this.buffer == null) {
long newOffset = FitsUtil.findOffset(this.currInput);
try {
getBuffer(this.nRows * this.rowLen, this.fileOffset);
} catch (IOException e) {
throw new FitsException("Error in deferred read -- file closed prematurely?:" + e.getMessage(), e);
}
FitsUtil.reposition(this.currInput, newOffset);
}
this.bp.setOffset(0);
int rowOffset;
for (int i = 0; i < this.nRows; i += 1) {
rowOffset = this.rowLen * i;
for (int j = 0; j < this.nFields; j += 1) {
if (!extractElement(rowOffset + this.offsets[j], this.lengths[j], this.data, j, i, this.nulls[j])) {
if (this.isNull == null) {
this.isNull = new boolean[this.nRows * this.nFields];
}
this.isNull[j + i * this.nFields] = true;
}
}
}
}
return this.data;
}
/**
* Get a single element as a one-d array. We return String's as arrays for
* consistency though they could be returned as a scalar.
*
* @param row
* The 0-based row
* @param col
* The 0-based column
* @return The requested cell data.
* @throws FitsException
* when unable to get the data.
*/
@Override
public Object getElement(int row, int col) throws FitsException {
if (this.data != null) {
return singleElement(row, col);
} else {
return parseSingleElement(row, col);
}
}
/**
* Get the number of columns in the table
*
* @return The number of columns
*/
@Override
public int getNCols() {
return this.nFields;
}
/**
* Get the number of rows in the table
*
* @return The number of rows.
*/
@Override
public int getNRows() {
return this.nRows;
}
/**
* Get a row. If the data has not yet been read just read this row.
*
* @param row
* The 0-indexed row to be returned.
* @return A row of data.
* @throws FitsException
* if the operation failed
*/
@Override
public Object[] getRow(int row) throws FitsException {
if (this.data != null) {
return singleRow(row);
} else {
return parseSingleRow(row);
}
}
/**
* Get the number of bytes in a row
*
* @return The number of bytes for a single row in the table.
*/
public int getRowLen() {
return this.rowLen;
}
/**
* Return the size of the data section
*
* @return The size in bytes of the data section, not includeing the
* padding.
*/
@Override
protected long getTrueSize() {
return (long) this.nRows * this.rowLen;
}
/**
* See if an element is null.
*
* @param row
* The 0-based row
* @param col
* The 0-based column
* @return if the given element has been nulled.
*/
public boolean isNull(int row, int col) {
if (this.isNull != null) {
return this.isNull[row * this.nFields + col];
} else {
return false;
}
}
/**
* Read a single element from the table. This returns an array of dimension
* 1.
*
* @throws FitsException
* if the operation failed
*/
private Object parseSingleElement(int row, int col) throws FitsException {
Object[] res = new Object[1];
try {
getBuffer(this.lengths[col], this.fileOffset + (long) row * (long) this.rowLen + this.offsets[col]);
} catch (IOException e) {
this.buffer = null;
throw new FitsException("Unable to read element", e);
}
res[0] = ArrayFuncs.newInstance(this.types[col], 1);
if (extractElement(0, this.lengths[col], res, 0, 0, this.nulls[col])) {
this.buffer = null;
return res[0];
} else {
this.buffer = null;
return null;
}
}
/**
* Read a single row from the table. This returns a set of arrays of
* dimension 1.
*
* @throws FitsException
* if the operation failed
*/
private Object[] parseSingleRow(int row) throws FitsException {
Object[] res = new Object[this.nFields];
try {
getBuffer(this.rowLen, this.fileOffset + (long) row * (long) this.rowLen);
} catch (IOException e) {
throw new FitsException("Unable to read row", e);
}
for (int i = 0; i < this.nFields; i += 1) {
res[i] = ArrayFuncs.newInstance(this.types[i], 1);
if (!extractElement(this.offsets[i], this.lengths[i], res, i, 0, this.nulls[i])) {
res[i] = null;
}
}
// Invalidate buffer for future use.
this.buffer = null;
return res;
}
/**
* Read in an ASCII table. Reading is deferred if we are reading from a
* random access device
*
* @param str
* the stream to read from
* @throws FitsException
* if the operation failed
*/
@Override
public void read(ArrayDataInput str) throws FitsException {
try {
setFileOffset(str);
this.currInput = str;
if (str instanceof RandomAccess) {
str.skipAllBytes((long) this.nRows * this.rowLen);
} else {
if ((long) this.rowLen * this.nRows > Integer.MAX_VALUE) {
throw new FitsException("Cannot read ASCII table > 2 GB");
}
getBuffer(this.rowLen * this.nRows, 0);
}
str.skipAllBytes(FitsUtil.padding(this.nRows * this.rowLen));
} catch (EOFException e) {
throw new PaddingException("EOF skipping padding after ASCII Table", this, e);
} catch (IOException e) {
throw new FitsException("Error skipping padding after ASCII Table", e);
}
}
/**
* Replace a column with new data.
*
* @param col
* The 0-based index to the column
* @param newData
* The column data. This is typically a 1-d array.
* @throws FitsException
* if the operation failed
*/
@Override
public void setColumn(int col, Object newData) throws FitsException {
ensureData();
if (col < 0 || col >= this.nFields || newData.getClass() != this.data[col].getClass() || Array.getLength(newData) != Array.getLength(this.data[col])) {
throw new FitsException("Invalid column/column mismatch:" + col);
}
this.data[col] = newData;
// Invalidate the buffer.
this.buffer = null;
}
/**
* Modify an element in the table
*
* @param row
* the 0-based row
* @param col
* the 0-based column
* @param newData
* The new value for the column. Typically a primitive[1] array.
* @throws FitsException
* if the operation failed
*/
@Override
public void setElement(int row, int col, Object newData) throws FitsException {
ensureData();
try {
System.arraycopy(newData, 0, this.data[col], row, 1);
} catch (Exception e) {
throw new FitsException("Incompatible element:" + row + "," + col, e);
}
setNull(row, col, false);
// Invalidate the buffer
this.buffer = null;
}
/**
* Mark (or unmark) an element as null. Note that if this FITS file is
* latter written out, a TNULL keyword needs to be defined in the
* corresponding header. This routine does not add an element for String
* columns.
*
* @param row
* The 0-based row.
* @param col
* The 0-based column.
* @param flag
* True if the element is to be set to null.
*/
public void setNull(int row, int col, boolean flag) {
if (flag) {
if (this.isNull == null) {
this.isNull = new boolean[this.nRows * this.nFields];
}
this.isNull[col + row * this.nFields] = true;
} else if (this.isNull != null) {
this.isNull[col + row * this.nFields] = false;
}
// Invalidate the buffer
this.buffer = null;
}
/**
* Set the null string for a columns. This is not a public method since we
* want users to call the method in AsciiTableHDU and update the header
* also.
*/
void setNullString(int col, String newNull) {
if (col >= 0 && col < this.nulls.length) {
this.nulls[col] = newNull;
}
}
/**
* Modify a row in the table
*
* @param row
* The 0-based index of the row
* @param newData
* The new data. Each element of this array is typically a
* primitive[1] array.
* @throws FitsException
* if the operation failed
*/
@Override
public void setRow(int row, Object[] newData) throws FitsException {
if (row < 0 || row > this.nRows) {
throw new FitsException("Invalid row in setRow");
}
ensureData();
for (int i = 0; i < this.nFields; i += 1) {
try {
System.arraycopy(newData[i], 0, this.data[i], row, 1);
} catch (Exception e) {
throw new FitsException("Unable to modify row: incompatible data:" + row, e);
}
setNull(row, i, false);
}
// Invalidate the buffer
this.buffer = null;
}
/**
* Extract a single element from a table. This returns an array of length 1.
*/
private Object singleElement(int row, int col) {
Object res = null;
if (this.isNull == null || !this.isNull[row * this.nFields + col]) {
res = ArrayFuncs.newInstance(this.types[col], 1);
System.arraycopy(this.data[col], row, res, 0, 1);
}
return res;
}
/**
* Extract a single row from a table. This returns an array of Objects each
* of which is an array of length 1.
*/
private Object[] singleRow(int row) {
Object[] res = new Object[this.nFields];
for (int i = 0; i < this.nFields; i += 1) {
if (this.isNull == null || !this.isNull[row * this.nFields + i]) {
res[i] = ArrayFuncs.newInstance(this.types[i], 1);
System.arraycopy(this.data[i], row, res[i], 0, 1);
}
}
return res;
}
/**
* This is called after we delete columns. The HDU doesn't know how to
* update the TBCOL entries.
*
* @param oldNCol
* The number of columns we had before deletion.
* @param hdr
* The associated header. @throws FitsException if the operation
* failed
*/
@Override
public void updateAfterDelete(int oldNCol, Header hdr) throws FitsException {
int offset = 0;
for (int i = 0; i < this.nFields; i += 1) {
this.offsets[i] = offset;
hdr.addValue(TBCOLn.n(i + 1), offset + 1);
offset += this.lengths[i] + 1;
}
for (int i = this.nFields; i < oldNCol; i += 1) {
hdr.deleteKey(TBCOLn.n(i + 1));
}
hdr.addValue(NAXIS1, this.rowLen);
}
/**
* Write the data to an output stream.
*
* @param str
* The output stream to be written to
* @throws FitsException
* if any IO exception is found or some inconsistency the FITS
* file arises.
*/
@Override
public void write(ArrayDataOutput str) throws FitsException {
// Make sure we have the data in hand.
ensureData();
// If buffer is still around we can just reuse it,
// since nothing we've done has invalidated it.
if (this.buffer == null) {
if (this.data == null) {
throw new FitsException("Attempt to write undefined ASCII Table");
}
if ((long) this.nRows * this.rowLen > Integer.MAX_VALUE) {
throw new FitsException("Cannot write ASCII table > 2 GB");
}
this.buffer = new byte[this.nRows * this.rowLen];
this.bp = new ByteParser(this.buffer);
for (int i = 0; i < this.buffer.length; i += 1) {
this.buffer[i] = (byte) ' ';
}
ByteFormatter bf = new ByteFormatter();
for (int i = 0; i < this.nRows; i += 1) {
for (int j = 0; j < this.nFields; j += 1) {
int offset = i * this.rowLen + this.offsets[j];
int len = this.lengths[j];
if (this.isNull != null && this.isNull[i * this.nFields + j]) {
if (this.nulls[j] == null) {
throw new FitsException("No null value set when needed");
}
bf.format(this.nulls[j], this.buffer, offset, len);
} else {
if (this.types[j] == String.class) {
String[] s = (String[]) this.data[j];
bf.format(s[i], this.buffer, offset, len);
} else if (this.types[j] == int.class) {
int[] ia = (int[]) this.data[j];
bf.format(ia[i], this.buffer, offset, len);
} else if (this.types[j] == float.class) {
float[] fa = (float[]) this.data[j];
bf.format(fa[i], this.buffer, offset, len);
} else if (this.types[j] == double.class) {
double[] da = (double[]) this.data[j];
bf.format(da[i], this.buffer, offset, len);
} else if (this.types[j] == long.class) {
long[] la = (long[]) this.data[j];
bf.format(la[i], this.buffer, offset, len);
}
}
}
}
}
// Now write the buffer.
try {
str.write(this.buffer);
FitsUtil.pad(str, this.buffer.length, (byte) ' ');
} catch (IOException e) {
throw new FitsException("Error writing ASCII Table data", e);
}
}
}
nom/tam/fits/HeaderCardException.java 0000664 0000000 0000000 00000003114 12755570700 016610 0 ustar root root package nom.tam.fits;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
/* This class was contributed by David Glowacki */
public class HeaderCardException extends FitsException {
/**
* serial version UID.
*/
private static final long serialVersionUID = 1L;
public HeaderCardException(String s) {
super(s);
}
}
nom/tam/fits/compress/ 0000775 0000000 0000000 00000000000 12755570706 013746 5 ustar root root nom/tam/fits/compress/BasicCompressProvider.java 0000664 0000000 0000000 00000005700 12755570700 021055 0 ustar root root package nom.tam.fits.compress;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import static nom.tam.util.LoggerHelper.getLogger;
import java.io.IOException;
import java.io.InputStream;
import java.util.logging.Level;
import java.util.logging.Logger;
import nom.tam.fits.FitsException;
public class BasicCompressProvider implements ICompressProvider {
private static final int PRIORITY = 10;
private static final int COMPRESS_MAGIC_BYTE1 = 0x1f;
private static final int COMPRESS_MAGIC_BYTE2 = 0x9d;
private static final Logger LOG = getLogger(BasicCompressProvider.class);
private InputStream compressInputStream(final InputStream compressed) throws IOException, FitsException {
try {
Process proc = new ProcessBuilder("uncompress", "-c").start();
return new CloseIS(proc, compressed);
} catch (Exception e) {
ICompressProvider next = CompressionManager.nextCompressionProvider(COMPRESS_MAGIC_BYTE1, COMPRESS_MAGIC_BYTE2, this);
if (next != null) {
LOG.log(Level.WARNING, "Error initiating .Z decompression: " + e.getMessage() + " trying alternative decompressor", e);
return next.decompress(compressed);
}
throw new FitsException("Unable to read .Z compressed stream.\nIs 'uncompress' in the path?", e);
}
}
@Override
public InputStream decompress(InputStream in) throws IOException, FitsException {
return compressInputStream(in);
}
@Override
public int priority() {
return PRIORITY;
}
@Override
public boolean provides(int mag1, int mag2) {
return mag1 == COMPRESS_MAGIC_BYTE1 && mag2 == COMPRESS_MAGIC_BYTE2;
}
}
nom/tam/fits/compress/BZip2CompressionProvider.java 0000664 0000000 0000000 00000003744 12755570700 021476 0 ustar root root package nom.tam.fits.compress;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.io.IOException;
import java.io.InputStream;
public class BZip2CompressionProvider implements ICompressProvider {
private static final int PRIORITY = 5;
@Override
public InputStream decompress(InputStream in) throws IOException {
try {
return CompressionLibLoaderProtection.createBZip2Stream(in);
} catch (IOException e) {
throw e;
} catch (Exception e) {
throw new IOException(e);
}
}
@Override
public int priority() {
return PRIORITY;
}
@Override
public boolean provides(int mag1, int mag2) {
return mag1 == 'B' && mag2 == 'Z';
}
}
nom/tam/fits/compress/ICompressProvider.java 0000664 0000000 0000000 00000003127 12755570700 020225 0 ustar root root package nom.tam.fits.compress;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.io.IOException;
import java.io.InputStream;
import nom.tam.fits.FitsException;
public interface ICompressProvider {
InputStream decompress(InputStream in) throws IOException, FitsException;
int priority();
boolean provides(int byte1, int byte2);
}
nom/tam/fits/compress/CompressionLibLoaderProtection.java 0000664 0000000 0000000 00000003734 12755570700 022740 0 ustar root root package nom.tam.fits.compress;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.io.IOException;
import java.io.InputStream;
/**
* Indirect Apache compression access. This indirection keeps the classes
* loadable.
*
* @author Richard van Nieuwenhoven
*/
public final class CompressionLibLoaderProtection {
private CompressionLibLoaderProtection() {
}
public static InputStream createBZip2Stream(InputStream in) throws IOException {
return new org.apache.commons.compress.compressors.bzip2.BZip2CompressorInputStream(in);
}
public static InputStream createZStream(InputStream in) throws IOException {
return new org.apache.commons.compress.compressors.z.ZCompressorInputStream(in);
}
}
nom/tam/fits/compress/ExternalBZip2CompressionProvider.java 0000664 0000000 0000000 00000006023 12755570700 023172 0 ustar root root package nom.tam.fits.compress;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.io.IOException;
import java.io.InputStream;
import java.util.logging.Logger;
import nom.tam.fits.FitsException;
public class ExternalBZip2CompressionProvider implements ICompressProvider {
private static final int PRIORITY = 10;
private static final Logger LOG = Logger.getLogger(ExternalBZip2CompressionProvider.class.getName());
private InputStream bunzipper(final InputStream compressed) throws IOException, FitsException {
String cmd = getBzip2Cmd();
// Allow the user to have already specified the - option.
if (cmd.indexOf(" -") < 0) {
cmd += " -";
}
String[] flds = cmd.split(" +");
Process proc;
try {
proc = new ProcessBuilder(flds).start();
return new CloseIS(proc, compressed);
} catch (Exception e) {
ICompressProvider next = CompressionManager.nextCompressionProvider('B', 'Z', this);
if (next != null) {
LOG.warning("Error initiating BZIP decompression: " + e.getMessage() + " trieing alternative decompressor");
return next.decompress(compressed);
}
throw new FitsException("Error initiating BZIP decompression: " + e);
}
}
public String getBzip2Cmd() {
return System.getProperty("BZIP_DECOMPRESSOR", System.getenv("BZIP_DECOMPRESSOR"));
}
@Override
public InputStream decompress(InputStream in) throws IOException, FitsException {
return bunzipper(in);
}
@Override
public int priority() {
return PRIORITY;
}
@Override
public boolean provides(int mag1, int mag2) {
return mag1 == 'B' && mag2 == 'Z' && getBzip2Cmd() != null;
}
}
nom/tam/fits/compress/CloseIS.java 0000664 0000000 0000000 00000013257 12755570700 016114 0 ustar root root package nom.tam.fits.compress;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import static nom.tam.util.LoggerHelper.getLogger;
import java.io.BufferedInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.charset.Charset;
import java.util.logging.Level;
import java.util.logging.Logger;
public class CloseIS extends FilterInputStream {
private static final Logger LOG = getLogger(CloseIS.class);
private static final int COPY_BUFFER_SIZE = 64 * 1024;
private InputStream output;
private OutputStream input;
private String errorText;
private IOException exception;
private final Thread stdError;
private final Thread copier;
private final Process proc;
public CloseIS(Process proc, final InputStream compressed) {
super(new BufferedInputStream(proc.getInputStream(), CompressionManager.ONE_MEGABYTE));
if (compressed == null) {
throw new NullPointerException();
}
this.proc = proc;
final InputStream error = proc.getErrorStream();
this.output = proc.getInputStream();
this.input = proc.getOutputStream();
stdError = new Thread(new Runnable() {
@Override
public void run() {
try {
ByteArrayOutputStream bytes = new ByteArrayOutputStream();
byte[] buffer = new byte[COPY_BUFFER_SIZE];
int len;
while ((len = error.read(buffer, 0, buffer.length)) >= 0) {
bytes.write(buffer, 0, len);
}
error.close();
errorText = new String(bytes.toByteArray(), Charset.defaultCharset());
} catch (IOException e) {
exception = e;
}
}
});
// Now copy everything in a separate thread.
copier = new Thread(new Runnable() {
@Override
public void run() {
try {
byte[] buffer = new byte[COPY_BUFFER_SIZE];
int len;
while ((len = compressed.read(buffer, 0, buffer.length)) >= 0) {
input.write(buffer, 0, len);
}
input.close();
} catch (IOException e) {
exception = e;
}
try {
compressed.close();
} catch (IOException e) {
if (exception == null) {
exception = e;
}
}
}
});
start();
}
/**
* start all threads.
*/
private void start() {
stdError.start();
copier.start();
}
@Override
public int read() throws IOException {
int result = 0;
try {
result = super.read();
return result;
} catch (IOException e) {
result = -1;
throw e;
} finally {
handledOccuredException(result);
}
}
private void handledOccuredException(int result) throws IOException {
int exitValue = 0;
if (result < 0) {
try {
stdError.join();
copier.join();
exitValue = proc.exitValue();
} catch (Exception e) {
LOG.log(Level.WARNING, "could not join the stream processes", e);
}
}
if (exception != null || exitValue != 0) {
if (errorText != null && !errorText.trim().isEmpty()) {
throw new IOException(errorText, exception);
} else {
if (exception == null) {
throw new IOException("exit value was " + exitValue);
} else {
throw exception;
}
}
}
}
@Override
public int read(byte[] b, int off, int len) throws IOException {
int result = 0;
try {
result = super.read(b, off, len);
return result;
} catch (IOException e) {
throw e;
} finally {
handledOccuredException(result);
}
}
@Override
public void close() throws IOException {
super.close();
this.input.close();
this.output.close();
}
}
nom/tam/fits/compress/ZCompressionProvider.java 0000664 0000000 0000000 00000004174 12755570700 020757 0 ustar root root package nom.tam.fits.compress;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.io.IOException;
import java.io.InputStream;
public class ZCompressionProvider implements ICompressProvider {
private static final int Z_COMPRESS_MAGIC_BYTE1 = 0x1f;
private static final int Z_COMPRESS_MAGIC_BYTE2 = 0x9d;
private static final int PRIORITY = 5;
@Override
public InputStream decompress(InputStream in) throws IOException {
try {
return CompressionLibLoaderProtection.createZStream(in);
} catch (IOException e) {
throw e;
} catch (Exception e) {
throw new IOException(e);
}
}
@Override
public int priority() {
return PRIORITY;
}
@Override
public boolean provides(int mag1, int mag2) {
return mag1 == Z_COMPRESS_MAGIC_BYTE1 && mag2 == Z_COMPRESS_MAGIC_BYTE2;
}
}
nom/tam/fits/compress/GZipCompressionProvider.java 0000664 0000000 0000000 00000003734 12755570700 021420 0 ustar root root package nom.tam.fits.compress;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.io.IOException;
import java.io.InputStream;
import java.util.zip.GZIPInputStream;
public class GZipCompressionProvider implements ICompressProvider {
private static final int GZIP_MAGIC_BYTE1 = 0x1f;
private static final int GZIP_MAGIC_BYTE2 = 0x8b;
private static final int PRIORITY = 5;
@Override
public InputStream decompress(InputStream in) throws IOException {
return new GZIPInputStream(in);
}
@Override
public int priority() {
return PRIORITY;
}
@Override
public boolean provides(int mag1, int mag2) {
return mag1 == GZIP_MAGIC_BYTE1 && mag2 == GZIP_MAGIC_BYTE2;
}
}
nom/tam/fits/compress/CompressionManager.java 0000664 0000000 0000000 00000014275 12755570700 020410 0 ustar root root package nom.tam.fits.compress;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import static nom.tam.util.LoggerHelper.getLogger;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ServiceLoader;
import java.util.logging.Level;
import java.util.logging.Logger;
import nom.tam.fits.FitsException;
import nom.tam.util.SafeClose;
public final class CompressionManager {
private static final String BZIP2_EXTENTION = ".bz2";
private static final String COMPRESS_EXTENTION = ".Z";
private static final String GZIP_EXTENTION = ".gz";
public static final int ONE_MEGABYTE = 1024 * 1024;
/**
* logger to log to.
*/
private static final Logger LOG = getLogger(CompressionManager.class);
private CompressionManager() {
}
/**
* This method decompresses a compressed input stream. The decompression
* method is selected automatically based upon the first two bytes read.
*
* @param compressed
* The compressed input stream
* @return A stream which wraps the input stream and decompresses it. If the
* input stream is not compressed, a pushback input stream wrapping
* the original stream is returned.
* @throws FitsException
* when the stream could not be read or decompressed
*/
public static InputStream decompress(InputStream compressed) throws FitsException {
BufferedInputStream pb = new BufferedInputStream(compressed, ONE_MEGABYTE);
pb.mark(2);
int mag1 = -1;
int mag2 = -1;
try {
mag1 = pb.read();
mag2 = pb.read();
// Push the data back into the stream
pb.reset();
ICompressProvider selectedProvider = selectCompressionProvider(mag1, mag2);
if (selectedProvider != null) {
return selectedProvider.decompress(pb);
} else {
return pb;
}
} catch (IOException e) {
// This is probably a prelude to failure...
throw new FitsException("Unable to analyze input stream", e);
}
}
/**
* Is a file compressed? (the magic number in the first 2 bytes is used to
* detect the compression.
*
* @param file
* file to test for compression algorithms
* @return true if the file is compressed
*/
public static boolean isCompressed(File file) {
InputStream fis = null;
try {
if (file.exists()) {
fis = new FileInputStream(file);
int mag1 = fis.read();
int mag2 = fis.read();
fis.close();
return selectCompressionProvider(mag1, mag2) != null;
}
} catch (IOException e) {
LOG.log(Level.FINEST, "Error while checking if file " + file + " is compressed", e);
// This is probably a prelude to failure...
return false;
} finally {
SafeClose.close(fis);
}
return false;
}
/**
* Is a file compressed? (the magic number in the first 2 bytes is used to
* detect the compression.
*
* @param filename
* of the file to test for compression algorithms
* @return true if the file is compressed
*/
public static boolean isCompressed(String filename) {
if (filename == null) {
return false;
}
File test = new File(filename);
if (test.exists()) {
return isCompressed(test);
}
int len = filename.length();
return len > 2 && (filename.substring(len - GZIP_EXTENTION.length()).equalsIgnoreCase(GZIP_EXTENTION) || //
filename.substring(len - COMPRESS_EXTENTION.length()).equals(COMPRESS_EXTENTION) || //
filename.substring(len - BZIP2_EXTENTION.length()).equals(BZIP2_EXTENTION));
}
private static ICompressProvider selectCompressionProvider(int mag1, int mag2) {
return nextCompressionProvider(mag1, mag2, null);
}
protected static ICompressProvider nextCompressionProvider(int mag1, int mag2, ICompressProvider old) {
ICompressProvider selectedProvider = null;
int priority = 0;
int maxPriority = Integer.MAX_VALUE;
if (old != null) {
maxPriority = old.priority();
}
ServiceLoader compressionProviders = ServiceLoader.load(ICompressProvider.class, Thread.currentThread().getContextClassLoader());
for (ICompressProvider provider : compressionProviders) {
if (provider.priority() > Math.max(0, priority) && provider.priority() < maxPriority && provider != old && //
provider.provides(mag1, mag2)) {
priority = provider.priority();
selectedProvider = provider;
}
}
return selectedProvider;
}
}
nom/tam/fits/RandomGroupsData.java 0000664 0000000 0000000 00000014447 12755570700 016174 0 ustar root root package nom.tam.fits;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import static nom.tam.fits.header.Standard.GCOUNT;
import static nom.tam.fits.header.Standard.GROUPS;
import static nom.tam.fits.header.Standard.NAXISn;
import static nom.tam.fits.header.Standard.PCOUNT;
import java.io.EOFException;
import java.io.IOException;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import nom.tam.fits.header.Standard;
import nom.tam.util.ArrayDataInput;
import nom.tam.util.ArrayDataOutput;
import nom.tam.util.ArrayFuncs;
/**
* This class instantiates FITS Random Groups data. Random groups are
* instantiated as a two-dimensional array of objects. The first dimension of
* the array is the number of groups. The second dimension is 2. The first
* object in every row is a one dimensional parameter array. The second element
* is the n-dimensional data array.
*/
public class RandomGroupsData extends Data {
private final Object[][] dataArray;
/**
* Create the equivalent of a null data element.
*/
public RandomGroupsData() {
this.dataArray = new Object[0][];
}
/**
* Create a RandomGroupsData object using the specified object to initialize
* the data array.
*
* @param x
* The initial data array. This should a two-d array of objects
* as described above.
*/
@SuppressFBWarnings(value = "EI_EXPOSE_REP", justification = "intended exposure of mutable data")
public RandomGroupsData(Object[][] x) {
this.dataArray = x;
}
@Override
protected void fillHeader(Header h) throws FitsException {
if (this.dataArray.length <= 0 || this.dataArray[0].length != 2) {
throw new FitsException("Data not conformable to Random Groups");
}
Standard.context(RandomGroupsData.class);
Object paraSamp = this.dataArray[0][0];
Object dataSamp = this.dataArray[0][1];
Class pbase = ArrayFuncs.getBaseClass(paraSamp);
Class dbase = ArrayFuncs.getBaseClass(dataSamp);
if (pbase != dbase) {
throw new FitsException("Data and parameters do not agree in type for random group");
}
int[] pdims = ArrayFuncs.getDimensions(paraSamp);
int[] ddims = ArrayFuncs.getDimensions(dataSamp);
if (pdims.length != 1) {
throw new FitsException("Parameters are not 1 d array for random groups");
}
// Got the information we need to build the header.
h.setSimple(true);
if (dbase == byte.class) {
h.setBitpix(BasicHDU.BITPIX_BYTE);
} else if (dbase == short.class) {
h.setBitpix(BasicHDU.BITPIX_SHORT);
} else if (dbase == int.class) {
h.setBitpix(BasicHDU.BITPIX_INT);
} else if (dbase == long.class) { // Non-standard
h.setBitpix(BasicHDU.BITPIX_LONG);
} else if (dbase == float.class) {
h.setBitpix(BasicHDU.BITPIX_FLOAT);
} else if (dbase == double.class) {
h.setBitpix(BasicHDU.BITPIX_DOUBLE);
} else {
throw new FitsException("Data type:" + dbase + " not supported for random groups");
}
h.setNaxes(ddims.length + 1);
h.addValue(NAXISn.n(1), 0);
for (int i = 2; i <= ddims.length + 1; i += 1) {
h.addValue(NAXISn.n(i), ddims[i - 2]);
}
h.addValue(GROUPS, true);
h.addValue(GCOUNT, this.dataArray.length);
h.addValue(PCOUNT, pdims[0]);
Standard.context(null);
}
@Override
@SuppressFBWarnings(value = "EI_EXPOSE_REP", justification = "intended exposure of mutable data")
public Object getData() {
return this.dataArray;
}
/** Get the size of the actual data element. */
@Override
protected long getTrueSize() {
if (this.dataArray != null && this.dataArray.length > 0) {
return (ArrayFuncs.computeLSize(this.dataArray[0][0]) + ArrayFuncs.computeLSize(this.dataArray[0][1])) * this.dataArray.length;
} else {
return 0;
}
}
/** Read the RandomGroupsData */
@Override
public void read(ArrayDataInput str) throws FitsException {
setFileOffset(str);
try {
str.readLArray(this.dataArray);
} catch (IOException e) {
throw new FitsException("IO error reading Random Groups data " + e);
}
int pad = FitsUtil.padding(getTrueSize());
try {
str.skipAllBytes(pad);
} catch (EOFException e) {
throw new PaddingException("EOF reading padding after random groups", this, e);
} catch (IOException e) {
throw new FitsException("IO error reading padding after random groups", e);
}
}
/** Write the RandomGroupsData */
@Override
public void write(ArrayDataOutput str) throws FitsException {
try {
str.writeArray(this.dataArray);
FitsUtil.pad(str, getTrueSize());
} catch (IOException e) {
throw new FitsException("IO error writing random groups data " + e);
}
}
}
nom/tam/fits/Data.java 0000664 0000000 0000000 00000013126 12755570700 013624 0 ustar root root package nom.tam.fits;
import static nom.tam.util.LoggerHelper.getLogger;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
import nom.tam.util.ArrayDataInput;
import nom.tam.util.ArrayDataOutput;
import nom.tam.util.RandomAccess;
/**
* This class provides methods to access the data segment of an HDU.
*
* This is the object which contains the actual data for the HDU.
*
*
* For images and primary data this is a simple (but possibly
* multi-dimensional) primitive array. When group data is supported it will be a
* possibly multidimensional array of group objects.
* For ASCII data it is a two dimensional Object array where each of the
* constituent objects is a primitive array of length 1.
* For Binary data it is a two dimensional Object array where each of the
* constituent objects is a primitive array of arbitrary (more or less)
* dimensionality.
*
*/
public abstract class Data implements FitsElement {
private static final Logger LOG = getLogger(Data.class);
private static final int FITS_BLOCK_SIZE_MINUS_ONE = FitsFactory.FITS_BLOCK_SIZE - 1;
/**
* The starting location of the data when last read
*/
protected long fileOffset = -1;
/**
* The size of the data when last read
*/
protected long dataSize;
/**
* The input stream used.
*/
protected RandomAccess input;
/**
* Modify a header to point to this data, this differs per subclass, they
* all need oder provided different informations to the header. Basically
* they describe the structure of this data object.
*
* @param head
* header to fill with the data from the current data object
* @throws FitsException
* if the operation fails
*/
abstract void fillHeader(Header head) throws FitsException;
/**
* @return the data array object.
* @throws FitsException
* if the data could not be gathered .
*/
public abstract Object getData() throws FitsException;
/**
* @return the file offset
*/
@Override
public long getFileOffset() {
return this.fileOffset;
}
/**
* @return the non-FITS data object.
* @throws FitsException
* if the data could not be gathered .
*/
public Object getKernel() throws FitsException {
return getData();
}
/**
* @return the size of the data element in bytes.
*/
@Override
public long getSize() {
return FitsUtil.addPadding(getTrueSize());
}
abstract long getTrueSize();
@Override
public abstract void read(ArrayDataInput in) throws FitsException;
@Override
public boolean reset() {
try {
FitsUtil.reposition(this.input, this.fileOffset);
return true;
} catch (Exception e) {
LOG.log(Level.SEVERE, "Unable to reset", e);
return false;
}
}
@Override
public void rewrite() throws FitsException {
if (!rewriteable()) {
throw new FitsException("Illegal attempt to rewrite data");
}
FitsUtil.reposition(this.input, this.fileOffset);
write((ArrayDataOutput) this.input);
try {
((ArrayDataOutput) this.input).flush();
} catch (IOException e) {
throw new FitsException("Error in rewrite flush: " + e);
}
}
@Override
public boolean rewriteable() {
return this.input != null && this.fileOffset >= 0
&& (getTrueSize() + FITS_BLOCK_SIZE_MINUS_ONE) / FitsFactory.FITS_BLOCK_SIZE == (this.dataSize + FITS_BLOCK_SIZE_MINUS_ONE) / FitsFactory.FITS_BLOCK_SIZE;
}
/**
* Set the fields needed for a re-read.
*
* @param o
* reread information.
*/
protected void setFileOffset(ArrayDataInput o) {
if (o instanceof RandomAccess) {
this.fileOffset = FitsUtil.findOffset(o);
this.dataSize = getTrueSize();
this.input = (RandomAccess) o;
}
}
/**
* Write the data -- including any buffering needed
*
* @param o
* The output stream on which to write the data.
*/
@Override
public abstract void write(ArrayDataOutput o) throws FitsException;
}
nom/tam/fits/HeaderCardBuilder.java 0000664 0000000 0000000 00000022642 12755570700 016247 0 ustar root root package nom.tam.fits;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Date;
import nom.tam.fits.header.IFitsHeader;
/**
* builder pattern implementation for easy readable header card creation.
*
* @author nir
*/
public class HeaderCardBuilder {
/**
* the header to fill.
*/
private final Header header;
/**
* the current card to fill.
*/
private HeaderCard card;
/**
* the current selected key.
*/
private IFitsHeader key;
/**
* scale to use for decimal values.
*/
private int scale = -1;
/**
* constructor to the header card builder.
*
* @param header
* the header to fill.
* @param key
* the first header card to set.
*/
protected HeaderCardBuilder(Header header, IFitsHeader key) {
this.header = header;
card(key);
}
/**
* get the current build card of the builder.
*
* @return the current card
*/
public HeaderCard card() {
return this.card;
}
/**
* switch focus to the card with the specified key. If the card does not
* exist the card will be created when the value or the comment is set.
*
* @param newKey
* the new card to set
* @return this
*/
public HeaderCardBuilder card(IFitsHeader newKey) {
this.key = newKey;
this.card = this.header.findCard(this.key);
return this;
}
/**
* set the comment of the current card. If the card does not exist yet the
* card is created with a null value, if the card needs a value use the
* value setter first!
*
* @param newComment
* the new comment to set.
* @return this
* @throws HeaderCardException
* if the card creation failed.
*/
public HeaderCardBuilder comment(String newComment) throws HeaderCardException {
if (this.card == null) {
this.card = new HeaderCard(this.key.key(), (String) null, null);
this.header.addLine(this.card);
}
this.card.setComment(newComment);
return this;
}
/**
* set the value of the current card.If the card did not exist yet the card
* will be created.
*
* @param newValue
* the new value to set.
* @return this
* @throws HeaderCardException
* if the card creation failed.
*/
public HeaderCardBuilder value(boolean newValue) throws HeaderCardException {
if (this.card == null) {
this.card = new HeaderCard(this.key.key(), newValue, null);
this.header.addLine(this.card);
} else {
this.card.setValue(newValue);
}
return this;
}
/**
* set the value of the current card. If the card did not exist yet the card
* will be created.
*
* @param newValue
* the new value to set.
* @return this
* @throws HeaderCardException
* if the card creation failed.
*/
public HeaderCardBuilder value(Date newValue) throws HeaderCardException {
return value(FitsDate.getFitsDateString(newValue));
}
/**
* set the value of the current card.If the card did not exist yet the card
* will be created.
*
* @param newValue
* the new value to set.
* @return this
* @throws HeaderCardException
* if the card creation failed.
*/
public HeaderCardBuilder value(double newValue) throws HeaderCardException {
if (this.card == null) {
if (scale >= 0) {
this.card = new HeaderCard(this.key.key(), newValue, scale, null);
} else {
this.card = new HeaderCard(this.key.key(), newValue, null);
}
this.header.addLine(this.card);
} else {
if (scale >= 0) {
this.card.setValue(newValue, scale);
} else {
this.card.setValue(newValue);
}
}
return this;
}
/**
* set the value of the current card.If the card did not exist yet the card
* will be created.
*
* @param newValue
* the new value to set.
* @return this
* @throws HeaderCardException
* if the card creation failed.
*/
public HeaderCardBuilder value(BigDecimal newValue) throws HeaderCardException {
final BigDecimal scaledValue;
if (scale >= 0) {
scaledValue = newValue.setScale(scale, RoundingMode.HALF_UP);
} else {
scaledValue = newValue;
}
if (this.card == null) {
this.card = new HeaderCard(this.key.key(), scaledValue, null);
this.header.addLine(this.card);
} else {
this.card.setValue(scaledValue);
}
return this;
}
/**
* set the value of the current card.If the card did not exist yet the card
* will be created.
*
* @param newValue
* the new value to set.
* @return this
* @throws HeaderCardException
* if the card creation failed.
*/
public HeaderCardBuilder value(float newValue) throws HeaderCardException {
if (this.card == null) {
if (scale >= 0) {
this.card = new HeaderCard(this.key.key(), newValue, scale, null);
} else {
this.card = new HeaderCard(this.key.key(), newValue, null);
}
this.header.addLine(this.card);
} else {
if (scale >= 0) {
this.card.setValue(newValue, scale);
} else {
this.card.setValue(newValue);
}
}
return this;
}
/**
* set the value of the current card.If the card did not exist yet the card
* will be created.
*
* @param newValue
* the new value to set.
* @return this
* @throws HeaderCardException
* if the card creation failed.
*/
public HeaderCardBuilder value(int newValue) throws HeaderCardException {
if (this.card == null) {
this.card = new HeaderCard(this.key.key(), newValue, null);
this.header.addLine(this.card);
} else {
this.card.setValue(newValue);
}
return this;
}
/**
* set the value of the current card.If the card did not exist yet the card
* will be created.
*
* @param newValue
* the new value to set.
* @return this
* @throws HeaderCardException
* if the card creation failed.
*/
public HeaderCardBuilder value(long newValue) throws HeaderCardException {
if (this.card == null) {
this.card = new HeaderCard(this.key.key(), newValue, null);
this.header.addLine(this.card);
} else {
this.card.setValue(newValue);
}
return this;
}
/**
* set the value of the current card.If the card did not exist yet the card
* will be created.
*
* @param newValue
* the new value to set.
* @return this
* @throws HeaderCardException
* if the card creation failed.
*/
public HeaderCardBuilder value(String newValue) throws HeaderCardException {
if (this.card == null) {
this.card = new HeaderCard(this.key.key(), newValue, null);
this.header.addLine(this.card);
} else {
this.card.setValue(newValue);
}
return this;
}
/**
* set the scale for the following decimal values.
*
* @param newScale
* the new scale to use
* @return this
*/
public HeaderCardBuilder scale(int newScale) {
this.scale = newScale;
return this;
}
/**
* use no scale for the following decimal values.
*
* @return this
*/
public HeaderCardBuilder noScale() {
this.scale = -1;
return this;
}
/**
* @return the filled header.
*/
public Header header() {
return header;
}
}
nom/tam/fits/AsciiTableHDU.java 0000664 0000000 0000000 00000017724 12755570700 015324 0 ustar root root package nom.tam.fits;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 2004 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import static nom.tam.fits.header.Standard.NAXIS1;
import static nom.tam.fits.header.Standard.NAXIS2;
import static nom.tam.fits.header.Standard.TBCOLn;
import static nom.tam.fits.header.Standard.TFIELDS;
import static nom.tam.fits.header.Standard.TFORMn;
import static nom.tam.fits.header.Standard.TNULLn;
import static nom.tam.fits.header.Standard.TTYPEn;
import static nom.tam.fits.header.Standard.TUNITn;
import static nom.tam.fits.header.Standard.TZEROn;
import static nom.tam.fits.header.Standard.XTENSION;
import java.io.PrintStream;
import java.util.logging.Logger;
import nom.tam.fits.header.IFitsHeader;
import nom.tam.fits.header.Standard;
import nom.tam.util.ArrayFuncs;
import nom.tam.util.Cursor;
/**
* FITS ASCII table header/data unit
*/
public class AsciiTableHDU extends TableHDU {
private static final Logger LOG = Logger.getLogger(AsciiTableHDU.class.getName());
/**
* The standard column stems for an ASCII table. Note that TBCOL is not
* included here -- it needs to be handled specially since it does not
* simply shift.
*/
private static final IFitsHeader[] KEY_STEMS = {
TFORMn,
TZEROn,
TNULLn,
TTYPEn,
TUNITn
};
/**
* Create an ASCII table header/data unit.
*
* @param h
* the template specifying the ASCII table.
* @param d
* the FITS data structure containing the table data.
*/
public AsciiTableHDU(Header h, AsciiTable d) {
super(h, d);
}
/**
* @return a ASCII table data structure from an array of objects
* representing the columns.
* @param o
* the array of object to create the ASCII table
* @throws FitsException
* if the table could not be created.
*/
public static AsciiTable encapsulate(Object o) throws FitsException {
Object[] oo = (Object[]) o;
AsciiTable d = new AsciiTable();
for (Object element : oo) {
d.addColumn(element);
}
return d;
}
/**
* @return true if this data is usable as an ASCII table.
* @param o
* object representing the data
*/
public static boolean isData(Object o) {
if (o instanceof Object[]) {
Object[] oo = (Object[]) o;
for (Object element : oo) {
if (!(element instanceof String[]) && //
!(element instanceof int[]) && //
!(element instanceof long[]) && //
!(element instanceof float[]) && //
!(element instanceof double[])) {
return false;
}
}
return true;
} else {
return false;
}
}
/**
* Check that this is a valid ascii table header.
*
* @param header
* to validate.
* @return true if this is an ascii table header.
*/
public static boolean isHeader(Header header) {
String xtension = header.getStringValue(XTENSION);
xtension = xtension == null ? "" : xtension.trim();
return "TABLE".equals(xtension);
}
/**
* Create a Data object to correspond to the header description.
*
* @param hdr
* the header to create the data for
* @return An unfilled Data object which can be used to read in the data for
* this HDU.
* @throws FitsException
* if the Data object could not be created from this HDU's
* Header
*/
public static Data manufactureData(Header hdr) throws FitsException {
return new AsciiTable(hdr);
}
/**
* @return a created header to match the input data.
* @param d
* data to create a header for
* @throws FitsException
* if the header could not b e created
*/
public static Header manufactureHeader(Data d) throws FitsException {
Header hdr = new Header();
d.fillHeader(hdr);
hdr.iterator();
return hdr;
}
@Override
public int addColumn(Object newCol) throws FitsException {
Standard.context(AsciiTable.class);
this.myData.addColumn(newCol);
// Move the iterator to point after all the data describing
// the previous column.
Cursor iter = this.myHeader.positionAfterIndex(TBCOLn, this.myData.getNCols());
int rowlen = this.myData.addColInfo(getNCols() - 1, iter);
int oldRowlen = this.myHeader.getIntValue(NAXIS1);
this.myHeader.setNaxis(1, rowlen + oldRowlen);
super.addColumn(newCol);
Standard.context(null);
return getNCols();
}
@Override
protected IFitsHeader[] columnKeyStems() {
return KEY_STEMS;
}
@Override
public void info(PrintStream stream) {
stream.println("ASCII Table:");
stream.println(" Header:");
stream.println(" Number of fields:" + this.myHeader.getIntValue(TFIELDS));
stream.println(" Number of rows: " + this.myHeader.getIntValue(NAXIS2));
stream.println(" Length of row: " + this.myHeader.getIntValue(NAXIS1));
stream.println(" Data:");
Object[] data = (Object[]) getKernel();
for (int i = 0; i < getNCols(); i += 1) {
stream.println(" " + i + ":" + ArrayFuncs.arrayDescription(data[i]));
}
}
/**
* @param row
* row index of the element
* @param col
* column index of the element
* @return true if an element is null
*/
public boolean isNull(int row, int col) {
return this.myData.isNull(row, col);
}
/**
* Mark an entry as null.
*
* @param row
* row index of the element
* @param col
* column index of the element
* @param flag
* set to null or not
*/
public void setNull(int row, int col, boolean flag) {
if (flag) {
String nullStr = this.myHeader.getStringValue(TNULLn.n(col + 1));
if (nullStr == null) {
setNullString(col, "NULL");
}
}
this.myData.setNull(row, col, flag);
}
/**
* Set the null string for a column.
*
* @param col
* the column index
* @param newNull
* the String representing null
*/
public void setNullString(int col, String newNull) {
this.myHeader.positionAfterIndex(TBCOLn, col + 1);
saveReplaceCard(TNULLn.n(col + 1).key(), true, newNull);
this.myData.setNullString(col, newNull);
}
}
nom/tam/fits/AbstractTableData.java 0000664 0000000 0000000 00000003006 12755570700 016254 0 ustar root root package nom.tam.fits;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
/**
* Just an abstract class to reuse the myData in all subclasses of the HDU's.
*
* @author Richard van Nieuwenhoven
*/
public abstract class AbstractTableData extends Data implements TableData {
}
nom/tam/fits/compression/ 0000775 0000000 0000000 00000000000 12755570700 014446 5 ustar root root nom/tam/fits/compression/algorithm/ 0000775 0000000 0000000 00000000000 12755570700 016434 5 ustar root root nom/tam/fits/compression/algorithm/api/ 0000775 0000000 0000000 00000000000 12755570706 017213 5 ustar root root nom/tam/fits/compression/algorithm/api/ICompressOption.java 0000664 0000000 0000000 00000006033 12755570700 023147 0 ustar root root package nom.tam.fits.compression.algorithm.api;
import nom.tam.fits.compression.provider.param.api.ICompressParameters;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
/**
* Option for the compression algorithm, implementors are used to control the
* compression algorithm.
*/
public interface ICompressOption extends Cloneable {
/**
* @return copy the option (normally the option from with the copy happened
* is saved as original).
*/
ICompressOption copy();
/**
* @return the parameters that must be synchronized with the hdu meta data.
*/
ICompressParameters getCompressionParameters();
/**
* @return true if the compression done with this specified options uses
* approximations. That means if the reconstruction of the data is
* excact the return should be false.
*/
boolean isLossyCompression();
/**
* set the parameters that must be synchronized with the hdu meta data.
*
* @param parameters
* the parameters to synchronized
*/
void setParameters(ICompressParameters parameters);
/**
* set the tile height in pixel.
*
* @param value
* the number of pixel.
* @return this (builder pattern)
*/
ICompressOption setTileHeight(int value);
/**
* set the tile width.
*
* @param value
* the number of pixel.
* @return this (builder pattern)
*/
ICompressOption setTileWidth(int value);
/**
* un wrap a specific implementation detail.
*
* @param clazz
* the type to unwrap
* @param
* the class to unrwap
* @return the implementation detail or null if no such detail is avalable.
*/
T unwrap(Class clazz);
}
nom/tam/fits/compression/algorithm/api/ICompressorControl.java 0000664 0000000 0000000 00000005103 12755570700 023655 0 ustar root root package nom.tam.fits.compression.algorithm.api;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2016 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.nio.Buffer;
import java.nio.ByteBuffer;
/**
* The interface to a provided compression algorithm.
*/
public interface ICompressorControl {
/**
* Compress the buffer into the byte buffer using the specified options.
*
* @param in
* the buffer to compress.
* @param out
* the compressed data to fill (must already be allocated with
* enough space)
* @param option
* the options to use for the compression
* @return true if the compression succeded.
*/
boolean compress(Buffer in, ByteBuffer out, ICompressOption option);
/**
* decompress the byte buffer back into the buffer using the specified
* options.
*
* @param in
* the bytes to decompress.
* @param out
* the buffer to fill with the decompressed data (must already be
* allocated with enough space)
* @param option
* the options to use for decompressing.
*/
void decompress(ByteBuffer in, Buffer out, ICompressOption option);
/**
* @return a option instance that can be used to control the compression
* meganism.
*/
ICompressOption option();
}
nom/tam/fits/compression/algorithm/api/ICompressor.java 0000664 0000000 0000000 00000004454 12755570700 022324 0 ustar root root package nom.tam.fits.compression.algorithm.api;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.nio.Buffer;
import java.nio.ByteBuffer;
/**
* Compressor that can compress a Buffer into a ByteBuffer and vize versa. the
* Byte buffer must have enough space allocated else an exception will be
* thrown.
*/
public interface ICompressor {
/**
* compress the buffer into the byte buffer. Attention enough space must
* already be allocated.
*
* @param buffer
* the buffer to compress.
* @param compressed
* the compressed data
* @return true if the compression succeeded.
*/
boolean compress(T buffer, ByteBuffer compressed);
/**
* Decompress the byte buffer and restore the buffer from it, again enough
* space must already be allocated.
*
* @param compressed
* the compressed data
* @param buffer
* the buffer to fill with the uncompressed data.
*/
void decompress(ByteBuffer compressed, T buffer);
}
nom/tam/fits/compression/algorithm/uncompressed/ 0000775 0000000 0000000 00000000000 12755570706 021151 5 ustar root root nom/tam/fits/compression/algorithm/uncompressed/NoCompressCompressor.java 0000664 0000000 0000000 00000012255 12755570700 026160 0 ustar root root package nom.tam.fits.compression.algorithm.uncompressed;
import java.nio.Buffer;
import java.nio.ByteBuffer;
import java.nio.DoubleBuffer;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.nio.LongBuffer;
import java.nio.ShortBuffer;
import nom.tam.fits.compression.algorithm.api.ICompressor;
import nom.tam.util.type.PrimitiveTypes;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
/**
* This compression algorithm will just copy the input to the output and do
* nothing at all.
*
* @param
* the buffer type of the pixel data
*/
public abstract class NoCompressCompressor implements ICompressor {
public static class ByteNoCompressCompressor extends NoCompressCompressor {
@Override
public boolean compress(ByteBuffer pixelData, ByteBuffer compressed) {
compressed.put(pixelData);
return true;
}
@Override
public void decompress(ByteBuffer compressed, ByteBuffer pixelData) {
pixelData.put(compressed);
}
}
public static class DoubleNoCompressCompressor extends NoCompressCompressor {
@Override
public boolean compress(DoubleBuffer pixelData, ByteBuffer compressed) {
int size = pixelData.remaining();
compressed.asDoubleBuffer().put(pixelData);
compressed.position(compressed.position() + size * PrimitiveTypes.DOUBLE.size());
return true;
}
@Override
public void decompress(ByteBuffer compressed, DoubleBuffer pixelData) {
pixelData.put(compressed.asDoubleBuffer());
}
}
public static class FloatNoCompressCompressor extends NoCompressCompressor {
@Override
public boolean compress(FloatBuffer pixelData, ByteBuffer compressed) {
int size = pixelData.remaining();
compressed.asFloatBuffer().put(pixelData);
compressed.position(compressed.position() + size * PrimitiveTypes.FLOAT.size());
return true;
}
@Override
public void decompress(ByteBuffer compressed, FloatBuffer pixelData) {
pixelData.put(compressed.asFloatBuffer());
}
}
public static class IntNoCompressCompressor extends NoCompressCompressor {
@Override
public boolean compress(IntBuffer pixelData, ByteBuffer compressed) {
int size = pixelData.remaining();
compressed.asIntBuffer().put(pixelData);
compressed.position(compressed.position() + size * PrimitiveTypes.INT.size());
return true;
}
@Override
public void decompress(ByteBuffer compressed, IntBuffer pixelData) {
pixelData.put(compressed.asIntBuffer());
}
}
public static class LongNoCompressCompressor extends NoCompressCompressor {
@Override
public boolean compress(LongBuffer pixelData, ByteBuffer compressed) {
int size = pixelData.remaining();
compressed.asLongBuffer().put(pixelData);
compressed.position(compressed.position() + size * PrimitiveTypes.LONG.size());
return true;
}
@Override
public void decompress(ByteBuffer compressed, LongBuffer pixelData) {
pixelData.put(compressed.asLongBuffer());
}
}
public static class ShortNoCompressCompressor extends NoCompressCompressor {
@Override
public boolean compress(ShortBuffer pixelData, ByteBuffer compressed) {
int size = pixelData.remaining();
compressed.asShortBuffer().put(pixelData);
compressed.position(compressed.position() + size * PrimitiveTypes.SHORT.size());
return true;
}
@Override
public void decompress(ByteBuffer compressed, ShortBuffer pixelData) {
pixelData.put(compressed.asShortBuffer());
}
}
}
nom/tam/fits/compression/algorithm/rice/ 0000775 0000000 0000000 00000000000 12755570706 017364 5 ustar root root nom/tam/fits/compression/algorithm/rice/RiceCompressOption.java 0000664 0000000 0000000 00000007501 12755570700 024013 0 ustar root root package nom.tam.fits.compression.algorithm.rice;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import nom.tam.fits.compression.algorithm.api.ICompressOption;
import nom.tam.fits.compression.provider.param.api.ICompressParameters;
import nom.tam.util.type.PrimitiveTypes;
public class RiceCompressOption implements ICompressOption {
public static final int DEFAULT_RICE_BLOCKSIZE = 32;
public static final int DEFAULT_RICE_BYTEPIX = PrimitiveTypes.INT.size();
/**
* this is a circular dependency that still has to be cut.
*/
private ICompressParameters parameters;
private int blockSize = DEFAULT_RICE_BLOCKSIZE;
private Integer bytePix = null;
private RiceCompressOption original;
@Override
public RiceCompressOption copy() {
try {
return ((RiceCompressOption) clone()).setOriginal(this);
} catch (CloneNotSupportedException e) {
throw new IllegalStateException("option could not be cloned", e);
}
}
public int getBlockSize() {
return this.blockSize;
}
public int getBytePix() {
return this.bytePix;
}
@Override
public ICompressParameters getCompressionParameters() {
return this.parameters;
}
@Override
public boolean isLossyCompression() {
return false;
}
public RiceCompressOption setBlockSize(int value) {
this.blockSize = value;
return this;
}
public RiceCompressOption setBytePix(int value) {
this.bytePix = value;
return this;
}
@Override
public void setParameters(ICompressParameters parameters) {
this.parameters = parameters;
}
@Override
public RiceCompressOption setTileHeight(int value) {
return this;
}
@Override
public RiceCompressOption setTileWidth(int value) {
return this;
}
@Override
public T unwrap(Class clazz) {
if (clazz.isAssignableFrom(this.getClass())) {
return clazz.cast(this);
}
return null;
}
private RiceCompressOption setOriginal(RiceCompressOption riceCompressOption) {
this.original = riceCompressOption;
this.parameters = this.parameters.copy(this);
return this;
}
protected RiceCompressOption setDefaultBytePix(int defaultBytePix) {
if (this.original != null) {
this.original.setDefaultBytePix(defaultBytePix);
this.bytePix = this.original.getBytePix();
} else if (this.bytePix == null) {
this.bytePix = defaultBytePix;
}
return this;
}
}
nom/tam/fits/compression/algorithm/rice/BitBuffer.java 0000664 0000000 0000000 00000012627 12755570700 022101 0 ustar root root package nom.tam.fits.compression.algorithm.rice;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.nio.ByteBuffer;
/**
* A bit wise reader writer around a bytebuffer.
*
* @author Ritchie
*/
public class BitBuffer {
private static final int BITS_OF_4_BYTES = 32;
private static final int BYTE_MASK = 0xFF;
private static final long INTEGER_MASK = 0xFFFFFFFFL;
private static final int BITS_OF_1_BYTE = 8;
private static final int BITS_OF_2_BYTES = 16;
private static final int BITS_OF_3_BYTES = 24;
private static final int BYTE_1_OF_INT = 0x000000FF;
private static final int BYTE_2_OF_INT = 0x0000FF00;
private static final int BYTE_3_OF_INT = 0x00FF0000;
private static final int BYTE_4_OF_INT = 0xFF000000;
private final ByteBuffer buffer;
private long position;
public BitBuffer(ByteBuffer writeBuffer) {
this.buffer = writeBuffer;
}
public int bitbuffer() {
return this.buffer.get((int) (this.position / BITS_OF_1_BYTE));
}
void close() {
if (this.position % BITS_OF_1_BYTE != 0) {
putByte((byte) 0, (int) (BITS_OF_1_BYTE - this.position % BITS_OF_1_BYTE));
}
this.buffer.position((int) (this.position / BITS_OF_1_BYTE));
}
public int missingBitsInCurrentByte() {
return (int) (BITS_OF_1_BYTE - this.position % BITS_OF_1_BYTE);
}
public void movePosition(int i) {
this.position += i;
}
public void putByte(byte byteToAdd) {
final int bytePosition = (int) (this.position / BITS_OF_1_BYTE);
final int positionInByte = (int) (this.position % BITS_OF_1_BYTE);
final byte old = (byte) (this.buffer.get(bytePosition) & (byte) ~(BYTE_MASK >>> positionInByte));
final int byteAsInt = byteToAdd & BYTE_MASK;
this.buffer.put(bytePosition, (byte) (old | (byte) (byteAsInt >>> positionInByte)));
if (positionInByte > 0) {
this.buffer.put(bytePosition + 1, (byte) (byteAsInt << BITS_OF_1_BYTE - positionInByte));
}
this.position += BITS_OF_1_BYTE;
}
public void putByte(byte byteToAdd, int bits) {
final int bytePosition = (int) (this.position / BITS_OF_1_BYTE);
final int positionInByte = (int) (this.position % BITS_OF_1_BYTE);
final byte old = this.buffer.get(bytePosition);
final int byteAsInt = BYTE_MASK & (byteToAdd & BYTE_MASK >>> BITS_OF_1_BYTE - bits) << BITS_OF_1_BYTE - bits;
this.buffer.put(bytePosition, (byte) (BYTE_MASK & //
(old & BYTE_MASK << BITS_OF_1_BYTE - positionInByte | byteAsInt >>> positionInByte)));
if (BITS_OF_1_BYTE - positionInByte < bits) {
this.buffer.put(bytePosition + 1, (byte) (BYTE_MASK & byteAsInt << BITS_OF_1_BYTE - positionInByte));
}
this.position += bits;
}
/**
* write out int value to the next 4 bytes of the buffer
*
* @param i
* integer to write
*/
public void putInt(int i) {
putByte((byte) ((i & BYTE_4_OF_INT) >>> BITS_OF_3_BYTES));
putByte((byte) ((i & BYTE_3_OF_INT) >>> BITS_OF_2_BYTES));
putByte((byte) ((i & BYTE_2_OF_INT) >>> BITS_OF_1_BYTE));
putByte((byte) (i & BYTE_1_OF_INT));
}
public void putInt(int i, int bits) {
if (bits == 0) {
return;
}
do {
if (bits >= BITS_OF_1_BYTE) {
putByte((byte) ((i & BYTE_MASK << bits - BITS_OF_1_BYTE) >>> bits - BITS_OF_1_BYTE & BYTE_MASK));
bits -= BITS_OF_1_BYTE;
} else {
putByte((byte) (i & BYTE_MASK >> -(bits - BITS_OF_1_BYTE)), bits);
bits = 0;
}
} while (bits > 0);
}
public void putLong(long l, int bits) {
if (bits == 0) {
return;
}
do {
if (bits >= BITS_OF_4_BYTES) {
putInt((int) ((l & INTEGER_MASK << bits - BITS_OF_4_BYTES) >>> bits - BITS_OF_4_BYTES));
bits -= BITS_OF_4_BYTES;
} else {
putInt((int) (l & INTEGER_MASK >> -(bits - BITS_OF_4_BYTES)), bits);
bits = 0;
}
} while (bits > 0);
}
}
nom/tam/fits/compression/algorithm/rice/RiceCompressor.java 0000664 0000000 0000000 00000044761 12755570700 023174 0 ustar root root package nom.tam.fits.compression.algorithm.rice;
import java.nio.Buffer;
import java.nio.ByteBuffer;
import java.nio.IntBuffer;
import java.nio.ShortBuffer;
import java.util.logging.Logger;
import nom.tam.fits.compression.algorithm.api.ICompressor;
import nom.tam.fits.compression.algorithm.quant.QuantizeProcessor.DoubleQuantCompressor;
import nom.tam.fits.compression.algorithm.quant.QuantizeProcessor.FloatQuantCompressor;
import nom.tam.util.FitsIO;
import nom.tam.util.type.PrimitiveTypes;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
/**
* The original compression was designed by Rice, Yeh, and Miller the code was
* written by Richard White at STSc at the STScI and included (ported to c and
* adapted) in cfitsio by William Pence, NASA/GSFC. That code was then ported to
* java by R. van Nieuwenhoven. Later it was massively refactored to harmonize
* the different compression algorithms and reduce the duplicate code pieces
* without obscuring the algorithm itself as far as possible.
*
* @author Richard White
* @author William Pence
* @author Richard van Nieuwenhoven
*/
public abstract class RiceCompressor implements ICompressor {
public static class ByteRiceCompressor extends RiceCompressor {
private ByteBuffer pixelBuffer;
public ByteRiceCompressor(RiceCompressOption option) {
super(option.setDefaultBytePix(PrimitiveTypes.BYTE.size()));
}
@Override
public boolean compress(ByteBuffer buffer, ByteBuffer writeBuffer) {
this.pixelBuffer = buffer;
super.compress(buffer.limit(), this.pixelBuffer.get(this.pixelBuffer.position()), new BitBuffer(writeBuffer));
return true;
}
@Override
public void decompress(ByteBuffer readBuffer, ByteBuffer buffer) {
this.pixelBuffer = buffer;
super.decompressBuffer(readBuffer, buffer.limit());
}
@Override
protected int nextPixel() {
return this.pixelBuffer.get();
}
@Override
protected void nextPixel(int pixel) {
this.pixelBuffer.put((byte) pixel);
}
}
public static class DoubleRiceCompressor extends DoubleQuantCompressor {
public DoubleRiceCompressor(RiceQuantizeCompressOption options) {
super(options, new IntRiceCompressor(options.getRiceCompressOption()));
}
}
public static class FloatRiceCompressor extends FloatQuantCompressor {
public FloatRiceCompressor(RiceQuantizeCompressOption options) {
super(options, new IntRiceCompressor(options.getRiceCompressOption()));
}
}
public static class IntRiceCompressor extends RiceCompressor {
private IntBuffer pixelBuffer;
public IntRiceCompressor(RiceCompressOption option) {
super(option.setDefaultBytePix(PrimitiveTypes.INT.size()));
}
@Override
public boolean compress(IntBuffer buffer, ByteBuffer writeBuffer) {
this.pixelBuffer = buffer;
super.compress(buffer.limit(), this.pixelBuffer.get(this.pixelBuffer.position()), new BitBuffer(writeBuffer));
return true;
}
@Override
public void decompress(ByteBuffer readBuffer, IntBuffer buffer) {
this.pixelBuffer = buffer;
super.decompressBuffer(readBuffer, buffer.limit());
}
@Override
protected int nextPixel() {
return this.pixelBuffer.get();
}
@Override
protected void nextPixel(int pixel) {
this.pixelBuffer.put(pixel);
}
}
public static class ShortRiceCompressor extends RiceCompressor {
private ShortBuffer pixelBuffer;
public ShortRiceCompressor(RiceCompressOption option) {
super(option.setDefaultBytePix(PrimitiveTypes.SHORT.size()));
}
@Override
public boolean compress(ShortBuffer buffer, ByteBuffer writeBuffer) {
this.pixelBuffer = buffer;
super.compress(buffer.limit(), this.pixelBuffer.get(this.pixelBuffer.position()), new BitBuffer(writeBuffer));
return true;
}
@Override
public void decompress(ByteBuffer readBuffer, ShortBuffer buffer) {
this.pixelBuffer = buffer;
super.decompressBuffer(readBuffer, buffer.limit());
}
@Override
protected int nextPixel() {
return this.pixelBuffer.get();
}
@Override
protected void nextPixel(int pixel) {
this.pixelBuffer.put((short) pixel);
}
}
/**
* logger to log to.
*/
private static final Logger LOG = Logger.getLogger(RiceCompressor.class.getName());
private static final int BITS_OF_1_BYTE = 8;
private static final int BITS_PER_BYTE = 8;
private static final int BYTE_MASK = 0xff;
private static final int FS_BITS_FOR_BYTE = 3;
private static final int FS_BITS_FOR_INT = 5;
private static final int FS_BITS_FOR_SHORT = 4;
private static final int FS_MAX_FOR_BYTE = 6;
private static final int FS_MAX_FOR_INT = 25;
private static final int FS_MAX_FOR_SHORT = 14;
/*
* nonzero_count is lookup table giving number of bits in 8-bit values not
* including leading zeros used in fits_rdecomp, fits_rdecomp_short and
* fits_rdecomp_byte.
* @formatter:off
*/
private static final int[] NONZERO_COUNT = {
0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8
};
// @formatter:on
private final int bBits;
private final int bitsPerPixel;
private final int blockSize;
private final int fsBits;
private final int fsMax;
private RiceCompressor(RiceCompressOption option) {
this.blockSize = option.getBlockSize();
if (option.getBytePix() == PrimitiveTypes.BYTE.size()) {
this.fsBits = FS_BITS_FOR_BYTE;
this.fsMax = FS_MAX_FOR_BYTE;
this.bitsPerPixel = FitsIO.BITS_OF_1_BYTE;
} else if (option.getBytePix() == PrimitiveTypes.SHORT.size()) {
this.fsBits = FS_BITS_FOR_SHORT;
this.fsMax = FS_MAX_FOR_SHORT;
this.bitsPerPixel = FitsIO.BITS_OF_2_BYTES;
} else if (option.getBytePix() == PrimitiveTypes.INT.size()) {
this.fsBits = FS_BITS_FOR_INT;
this.fsMax = FS_MAX_FOR_INT;
this.bitsPerPixel = FitsIO.BITS_OF_4_BYTES;
} else {
throw new UnsupportedOperationException("Rice only supports 1/2/4 type per pixel");
}
/*
* From bsize derive: FSBITS = # bits required to store FS FSMAX =
* maximum value for FS BBITS = bits/pixel for direct coding
*/
this.bBits = 1 << this.fsBits;
}
/**
* compress the integer tiledImageOperation on a rise compressed byte
* buffer.
*
* @param dataLength
* length of the data to compress
* @param firstPixel
* the value of the first pixel
* @param buffer
* the buffer to write to
*/
protected void compress(final int dataLength, int firstPixel, BitBuffer buffer) {
/* the first difference will always be zero */
int lastpix = firstPixel;
/* write out first int value to the first 4 bytes of the buffer */
buffer.putInt(lastpix, this.bitsPerPixel);
int thisblock = this.blockSize;
for (int i = 0; i < dataLength; i += this.blockSize) {
/* last block may be shorter */
if (dataLength - i < this.blockSize) {
thisblock = dataLength - i;
}
/*
* Compute differences of adjacent pixels and map them to unsigned
* values. Note that this may overflow the integer variables --
* that's OK, because we can recover when decompressing. If we were
* compressing shorts or bytes, would want to do this arithmetic
* with short/byte working variables (though diff will still be
* passed as an int.) compute sum of mapped pixel values at same
* time use double precision for sum to allow 32-bit integer inputs
*/
long[] diff = new long[this.blockSize];
double pixelsum = 0.0;
int nextpix;
/*
* tiledImageOperation for differences mapped to non-negative values
*/
for (int j = 0; j < thisblock; j++) {
nextpix = nextPixel();
long pdiff = nextpix - lastpix;
diff[j] = Math.abs(pdiff < 0 ? ~(pdiff << 1) : pdiff << 1);
pixelsum += diff[j];
lastpix = nextpix;
}
/*
* compute number of bits to split from sum
*/
double dpsum = (pixelsum - thisblock / 2d - 1d) / thisblock;
if (dpsum < 0) {
dpsum = 0.0;
}
long psum = (long) dpsum >> 1;
int fs;
for (fs = 0; psum > 0; fs++) { // NOSONAR
psum >>= 1;
}
/*
* write the codes fsbits ID bits used to indicate split level
*/
if (fs >= this.fsMax) {
/*
* Special high entropy case when FS >= fsmax Just write pixel
* difference values directly, no Rice coding at all.
*/
buffer.putInt(this.fsMax + 1, this.fsBits);
for (int j = 0; j < thisblock; j++) {
buffer.putLong(diff[j], this.bBits);
}
} else if (fs == 0 && pixelsum == 0) { // NOSONAR
/*
* special low entropy case when FS = 0 and pixelsum=0 (all
* pixels in block are zero.) Output a 0 and return
*/
buffer.putInt(0, this.fsBits);
} else {
/* normal case: not either very high or very low entropy */
buffer.putInt(fs + 1, this.fsBits);
int fsmask = (1 << fs) - 1;
/*
* local copies of bit buffer to improve optimization
*/
int bitsToGo = buffer.missingBitsInCurrentByte();
int bitBuffer = buffer.bitbuffer() >> bitsToGo;
buffer.movePosition(bitsToGo - BITS_OF_1_BYTE);
for (int j = 0; j < thisblock; j++) {
int v = (int) diff[j];
int top = v >> fs;
/*
* top is coded by top zeros + 1
*/
if (bitsToGo >= top + 1) {
bitBuffer <<= top + 1;
bitBuffer |= 1;
bitsToGo -= top + 1;
} else {
bitBuffer <<= bitsToGo;
buffer.putByte((byte) (bitBuffer & BYTE_MASK));
for (top -= bitsToGo; top >= BITS_OF_1_BYTE; top -= BITS_OF_1_BYTE) {
buffer.putByte((byte) 0);
}
bitBuffer = 1;
bitsToGo = BITS_OF_1_BYTE - 1 - top;
}
/*
* bottom FS bits are written without coding code is
* output_nbits, moved into this routine to reduce overheads
* This code potentially breaks if FS>24, so I am limiting
* FS to 24 by choice of FSMAX above.
*/
if (fs > 0) {
bitBuffer <<= fs;
bitBuffer |= v & fsmask;
bitsToGo -= fs;
while (bitsToGo <= 0) {
buffer.putByte((byte) (bitBuffer >> -bitsToGo & BYTE_MASK));
bitsToGo += BITS_OF_1_BYTE;
}
}
}
buffer.putByte((byte) (bitBuffer & BYTE_MASK), BITS_OF_1_BYTE - bitsToGo);
}
}
buffer.close();
}
/**
* decompress the readbuffer and fill the pixelarray.
*
* @param readBuffer
* input buffer
* @param nx
* the number of pixel to uncompress
*/
protected void decompressBuffer(final ByteBuffer readBuffer, final int nx) {
/* first x bytes of input buffer contain the value of the first */
/* x byte integer value, without any encoding */
int lastpix = 0;
if (this.bitsPerPixel == PrimitiveTypes.BYTE.bitPix()) {
lastpix = readBuffer.get();
} else if (this.bitsPerPixel == PrimitiveTypes.SHORT.bitPix()) {
lastpix = readBuffer.getShort();
} else if (this.bitsPerPixel == PrimitiveTypes.INT.bitPix()) {
lastpix = readBuffer.getInt();
}
int b = readBuffer.get() & BYTE_MASK; /* bit buffer */
int nbits = BITS_PER_BYTE; /* number of bits remaining in b */
for (int i = 0; i < nx;) {
/* get the FS value from first fsbits */
nbits -= this.fsBits;
while (nbits < 0) {
b = b << BITS_PER_BYTE | readBuffer.get() & BYTE_MASK;
nbits += BITS_PER_BYTE;
}
int fs = (b >> nbits) - 1;
b &= (1 << nbits) - 1;
/* loop over the next block */
int imax = i + this.blockSize;
if (imax > nx) {
imax = nx;
}
if (fs < 0) {
/* low-entropy case, all zero differences */
for (; i < imax; i++) {
nextPixel(lastpix);
}
} else if (fs == this.fsMax) {
/* high-entropy case, directly coded pixel values */
for (; i < imax; i++) {
int k = this.bBits - nbits;
int diff = b << k;
for (k -= BITS_PER_BYTE; k >= 0; k -= BITS_PER_BYTE) {
b = readBuffer.get() & BYTE_MASK;
diff |= b << k;
}
if (nbits > 0) {
b = readBuffer.get() & BYTE_MASK;
diff |= b >> -k;
b &= (1 << nbits) - 1;
} else {
b = 0;
}
/*
* undo mapping and differencing Note that some of these
* operations will overflow the unsigned int arithmetic --
* that's OK, it all works out to give the right answers in
* the output file.
*/
if ((diff & 1) == 0) {
diff = diff >> 1;
} else {
diff = ~(diff >> 1);
}
lastpix = diff + lastpix;
nextPixel(lastpix);
}
} else {
/* normal case, Rice coding */
for (; i < imax; i++) {
/* count number of leading zeros */
while (b == 0) {
nbits += BITS_PER_BYTE;
b = readBuffer.get() & BYTE_MASK;
}
int nzero = nbits - NONZERO_COUNT[b & BYTE_MASK];
nbits -= nzero + 1;
/* flip the leading one-bit */
b ^= 1 << nbits;
/* get the FS trailing bits */
nbits -= fs;
while (nbits < 0) {
b = b << BITS_PER_BYTE | readBuffer.get() & BYTE_MASK;
nbits += BITS_PER_BYTE;
}
int diff = nzero << fs | b >> nbits;
b &= (1 << nbits) - 1;
/* undo mapping and differencing */
if ((diff & 1) == 0) {
diff = diff >> 1;
} else {
diff = ~(diff >> 1);
}
lastpix = diff + lastpix;
nextPixel(lastpix);
}
}
}
if (readBuffer.limit() > readBuffer.position()) {
LOG.warning("decompressing left over some extra bytes got: " + readBuffer.limit() + " but needed only " + readBuffer.position());
}
}
protected abstract int nextPixel();
protected abstract void nextPixel(int pixel);
}
nom/tam/fits/compression/algorithm/rice/RiceQuantizeCompressOption.java 0000664 0000000 0000000 00000005356 12755570700 025542 0 ustar root root package nom.tam.fits.compression.algorithm.rice;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2016 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import nom.tam.fits.compression.algorithm.quant.QuantizeOption;
import nom.tam.fits.compression.provider.param.rice.RiceQuantizeCompressParameters;
public class RiceQuantizeCompressOption extends QuantizeOption {
private RiceCompressOption riceCompressOption = new RiceCompressOption();
public RiceQuantizeCompressOption() {
super();
// circulat dependency, musst be cut.
this.parameters = new RiceQuantizeCompressParameters(this);
}
@Override
public RiceQuantizeCompressOption copy() {
RiceQuantizeCompressOption copy = (RiceQuantizeCompressOption) super.copy();
copy.riceCompressOption = this.riceCompressOption.copy();
return copy;
}
public RiceCompressOption getRiceCompressOption() {
return this.riceCompressOption;
}
@Override
public RiceQuantizeCompressOption setTileHeight(int value) {
super.setTileHeight(value);
this.riceCompressOption.setTileHeight(value);
return this;
}
@Override
public RiceQuantizeCompressOption setTileWidth(int value) {
super.setTileWidth(value);
this.riceCompressOption.setTileWidth(value);
return this;
}
@Override
public T unwrap(Class clazz) {
T result = super.unwrap(clazz);
if (result == null) {
return this.riceCompressOption.unwrap(clazz);
}
return result;
}
}
nom/tam/fits/compression/algorithm/gzip/ 0000775 0000000 0000000 00000000000 12755570706 017413 5 ustar root root nom/tam/fits/compression/algorithm/gzip/GZipCompressor.java 0000664 0000000 0000000 00000026103 12755570700 023200 0 ustar root root package nom.tam.fits.compression.algorithm.gzip;
import java.io.IOException;
import java.nio.Buffer;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.DoubleBuffer;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.nio.LongBuffer;
import java.nio.ShortBuffer;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;
import nom.tam.fits.compression.algorithm.api.ICompressor;
import nom.tam.util.ArrayFuncs;
import nom.tam.util.ByteBufferInputStream;
import nom.tam.util.ByteBufferOutputStream;
import nom.tam.util.FitsIO;
import nom.tam.util.SafeClose;
import nom.tam.util.type.PrimitiveType;
import nom.tam.util.type.PrimitiveTypeHandler;
import nom.tam.util.type.PrimitiveTypes;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
public abstract class GZipCompressor implements ICompressor {
/**
* Byte compress is a special case, the only one that does not extends
* GZipCompress because it can write the buffer directly.
*/
public static class ByteGZipCompressor extends GZipCompressor {
public ByteGZipCompressor() {
super(1);
this.nioBuffer = ByteBuffer.wrap(this.buffer);
}
@Override
protected void getPixel(ByteBuffer pixelData, byte[] pixelBytes) {
this.nioBuffer.put(pixelData);
}
@Override
protected void setPixel(ByteBuffer pixelData, byte[] pixelBytes) {
pixelData.put(this.nioBuffer);
}
}
public static class DoubleGZipCompressor extends GZipCompressor {
protected static final int BYTE_SIZE_OF_DOUBLE = 8;
public DoubleGZipCompressor() {
super(BYTE_SIZE_OF_DOUBLE);
this.nioBuffer = ByteBuffer.wrap(this.buffer).asDoubleBuffer();
}
@Override
protected void getPixel(DoubleBuffer pixelData, byte[] pixelBytes) {
this.nioBuffer.put(pixelData);
}
@Override
protected void setPixel(DoubleBuffer pixelData, byte[] pixelBytes) {
pixelData.put(this.nioBuffer);
}
}
public static class FloatGZipCompressor extends GZipCompressor {
protected static final int BYTE_SIZE_OF_FLOAT = 4;
public FloatGZipCompressor() {
super(BYTE_SIZE_OF_FLOAT);
this.nioBuffer = ByteBuffer.wrap(this.buffer).asFloatBuffer();
}
@Override
protected void getPixel(FloatBuffer pixelData, byte[] pixelBytes) {
this.nioBuffer.put(pixelData);
}
@Override
protected void setPixel(FloatBuffer pixelData, byte[] pixelBytes) {
pixelData.put(this.nioBuffer);
}
}
public static class IntGZipCompressor extends GZipCompressor {
protected static final int BYTE_SIZE_OF_INT = 4;
public IntGZipCompressor() {
super(BYTE_SIZE_OF_INT);
this.nioBuffer = ByteBuffer.wrap(this.buffer).asIntBuffer();
}
@Override
protected void getPixel(IntBuffer pixelData, byte[] pixelBytes) {
this.nioBuffer.put(pixelData);
}
@Override
protected void setPixel(IntBuffer pixelData, byte[] pixelBytes) {
pixelData.put(this.nioBuffer);
}
}
public static class LongGZipCompressor extends GZipCompressor {
protected static final int BYTE_SIZE_OF_LONG = 8;
public LongGZipCompressor() {
super(BYTE_SIZE_OF_LONG);
this.nioBuffer = ByteBuffer.wrap(this.buffer).asLongBuffer();
}
@Override
protected void getPixel(LongBuffer pixelData, byte[] pixelBytes) {
this.nioBuffer.put(pixelData);
}
@Override
protected void setPixel(LongBuffer pixelData, byte[] pixelBytes) {
pixelData.put(this.nioBuffer);
}
}
public static class ShortGZipCompressor extends GZipCompressor {
protected static final int BYTE_SIZE_OF_SHORT = 2;
public ShortGZipCompressor() {
super(BYTE_SIZE_OF_SHORT);
this.nioBuffer = ByteBuffer.wrap(this.buffer).asShortBuffer();
}
@Override
protected void getPixel(ShortBuffer pixelData, byte[] pixelBytes) {
this.nioBuffer.put(pixelData);
}
@Override
protected void setPixel(ShortBuffer pixelData, byte[] pixelBytes) {
pixelData.put(this.nioBuffer);
}
}
private final class TypeConversion {
private final PrimitiveType from;
private final PrimitiveType to;
private final B fromBuffer;
private final T toBuffer;
private final Object fromArray;
private final Object toArray;
private TypeConversion(PrimitiveType from) {
this.from = from;
this.to = getPrimitiveType(GZipCompressor.this.primitiveSize);
this.toBuffer = GZipCompressor.this.nioBuffer;
this.fromBuffer = from.asTypedBuffer(ByteBuffer.wrap(GZipCompressor.this.buffer));
this.fromArray = from.newArray(DEFAULT_GZIP_BUFFER_SIZE / from.size());
this.toArray = this.to.newArray(DEFAULT_GZIP_BUFFER_SIZE / this.to.size());
}
int copy(int byteCount) {
this.fromBuffer.rewind();
this.toBuffer.rewind();
this.from.getArray(this.fromBuffer, this.fromArray);
ArrayFuncs.copyInto(this.fromArray, this.toArray);
this.to.putArray(this.toBuffer, this.toArray);
return byteCount * this.to.size() / this.from.size();
}
}
private static final int DEFAULT_GZIP_BUFFER_SIZE = 65536;
private static final int MINIMAL_GZIP_BUFFER_SIZE = 65536;
protected final int primitiveSize;
protected byte[] buffer = new byte[DEFAULT_GZIP_BUFFER_SIZE];
protected T nioBuffer;
private final byte[] sizeArray = new byte[PrimitiveTypes.INT.size()];
private final IntBuffer sizeBuffer = ByteBuffer.wrap(this.sizeArray).order(ByteOrder.LITTLE_ENDIAN).asIntBuffer();
public GZipCompressor(int primitiveSize) {
this.primitiveSize = primitiveSize;
}
@Override
public boolean compress(T pixelData, ByteBuffer compressed) {
this.nioBuffer.rewind();
int pixelDataLimit = pixelData.limit();
GZIPOutputStream zip = null;
try {
zip = createGZipOutputStream(pixelDataLimit, compressed);
while (pixelData.hasRemaining()) {
int count = Math.min(pixelData.remaining(), this.nioBuffer.capacity());
pixelData.limit(pixelData.position() + count);
getPixel(pixelData, null);
zip.write(this.buffer, 0, this.nioBuffer.position() * this.primitiveSize);
this.nioBuffer.rewind();
pixelData.limit(pixelDataLimit);
}
} catch (IOException e) {
throw new IllegalStateException("could not gzip data", e);
} finally {
SafeClose.close(zip);
}
compressed.limit(compressed.position());
return true;
}
@Override
public void decompress(ByteBuffer compressed, T pixelData) {
this.nioBuffer.rewind();
TypeConversion typeConverter = getTypeConverter(compressed, pixelData.limit());
GZIPInputStream zip = null;
try {
zip = createGZipInputStream(compressed);
int count;
while ((count = zip.read(this.buffer)) >= 0) {
if (typeConverter != null) {
count = typeConverter.copy(count);
}
this.nioBuffer.position(0);
this.nioBuffer.limit(count / this.primitiveSize);
setPixel(pixelData, null);
}
} catch (IOException e) {
throw new IllegalStateException("could not gunzip data", e);
} finally {
SafeClose.close(zip);
}
}
@SuppressWarnings("unchecked")
private PrimitiveType getPrimitiveType(int size) {
return (PrimitiveType) PrimitiveTypeHandler.valueOf(size * FitsIO.BITS_OF_1_BYTE);
}
private TypeConversion getTypeConverter(ByteBuffer compressed, int nrOfPrimitiveElements) {
if (compressed.limit() > FitsIO.BYTES_IN_INTEGER) {
int oldPosition = compressed.position();
try {
compressed.position(compressed.limit() - this.sizeArray.length);
compressed.get(this.sizeArray);
int uncompressedSize = this.sizeBuffer.get(0);
if (uncompressedSize > 0) {
compressed.position(oldPosition);
if (uncompressedSize % nrOfPrimitiveElements == 0) {
int compressedPrimitiveSize = uncompressedSize / nrOfPrimitiveElements;
if (compressedPrimitiveSize != this.primitiveSize) {
return new TypeConversion(getPrimitiveType(compressedPrimitiveSize));
}
}
}
} finally {
compressed.position(oldPosition);
}
}
return null;
}
protected GZIPInputStream createGZipInputStream(ByteBuffer compressed) throws IOException {
return new GZIPInputStream(new ByteBufferInputStream(compressed), Math.min(compressed.limit() * 2, DEFAULT_GZIP_BUFFER_SIZE));
}
protected GZIPOutputStream createGZipOutputStream(int length, ByteBuffer compressed) throws IOException {
return new GZIPOutputStream(new ByteBufferOutputStream(compressed), Math.min(Math.max(length * 2, MINIMAL_GZIP_BUFFER_SIZE), DEFAULT_GZIP_BUFFER_SIZE));
}
protected abstract void getPixel(T pixelData, byte[] pixelBytes);
protected abstract void setPixel(T pixelData, byte[] pixelBytes);
}
nom/tam/fits/compression/algorithm/gzip2/ 0000775 0000000 0000000 00000000000 12755570706 017475 5 ustar root root nom/tam/fits/compression/algorithm/gzip2/GZip2Compressor.java 0000664 0000000 0000000 00000017476 12755570700 023361 0 ustar root root package nom.tam.fits.compression.algorithm.gzip2;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.io.IOException;
import java.nio.Buffer;
import java.nio.ByteBuffer;
import java.nio.DoubleBuffer;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.nio.LongBuffer;
import java.nio.ShortBuffer;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;
import nom.tam.fits.compression.algorithm.gzip.GZipCompressor;
import nom.tam.util.SafeClose;
import nom.tam.util.type.PrimitiveTypes;
public abstract class GZip2Compressor extends GZipCompressor {
public static class ByteGZip2Compressor extends ByteGZipCompressor {
}
public static class IntGZip2Compressor extends GZip2Compressor {
public IntGZip2Compressor() {
super(PrimitiveTypes.INT.size());
}
@Override
protected void getPixel(IntBuffer pixelData, byte[] pixelBytes) {
IntBuffer pixelBuffer = ByteBuffer.wrap(pixelBytes).asIntBuffer();
pixelBuffer.put(pixelData);
}
@Override
protected void setPixel(IntBuffer pixelData, byte[] pixelBytes) {
pixelData.put(ByteBuffer.wrap(pixelBytes).asIntBuffer());
}
}
public static class FloatGZip2Compressor extends GZip2Compressor {
public FloatGZip2Compressor() {
super(PrimitiveTypes.FLOAT.size());
}
@Override
protected void getPixel(FloatBuffer pixelData, byte[] pixelBytes) {
FloatBuffer pixelBuffer = ByteBuffer.wrap(pixelBytes).asFloatBuffer();
pixelBuffer.put(pixelData);
}
@Override
protected void setPixel(FloatBuffer pixelData, byte[] pixelBytes) {
pixelData.put(ByteBuffer.wrap(pixelBytes).asFloatBuffer());
}
}
public static class LongGZip2Compressor extends GZip2Compressor {
public LongGZip2Compressor() {
super(PrimitiveTypes.LONG.size());
}
@Override
protected void getPixel(LongBuffer pixelData, byte[] pixelBytes) {
LongBuffer pixelBuffer = ByteBuffer.wrap(pixelBytes).asLongBuffer();
pixelBuffer.put(pixelData);
}
@Override
protected void setPixel(LongBuffer pixelData, byte[] pixelBytes) {
pixelData.put(ByteBuffer.wrap(pixelBytes).asLongBuffer());
}
}
public static class DoubleGZip2Compressor extends GZip2Compressor {
public DoubleGZip2Compressor() {
super(PrimitiveTypes.DOUBLE.size());
}
@Override
protected void getPixel(DoubleBuffer pixelData, byte[] pixelBytes) {
DoubleBuffer pixelBuffer = ByteBuffer.wrap(pixelBytes).asDoubleBuffer();
pixelBuffer.put(pixelData);
}
@Override
protected void setPixel(DoubleBuffer pixelData, byte[] pixelBytes) {
pixelData.put(ByteBuffer.wrap(pixelBytes).asDoubleBuffer());
}
}
public static class ShortGZip2Compressor extends GZip2Compressor {
public ShortGZip2Compressor() {
super(PrimitiveTypes.SHORT.size());
}
@Override
protected void getPixel(ShortBuffer pixelData, byte[] pixelBytes) {
ShortBuffer shortBuffer = ByteBuffer.wrap(pixelBytes).asShortBuffer();
shortBuffer.put(pixelData);
}
@Override
protected void setPixel(ShortBuffer pixelData, byte[] pixelBytes) {
pixelData.put(ByteBuffer.wrap(pixelBytes).asShortBuffer());
}
}
public GZip2Compressor(int primitiveSize) {
super(primitiveSize);
}
private int[] calculateOffsets(byte[] byteArray) {
int[] offset = new int[this.primitiveSize];
offset[0] = 0;
for (int primitivIndex = 1; primitivIndex < this.primitiveSize; primitivIndex++) {
offset[primitivIndex] = offset[primitivIndex - 1] + byteArray.length / this.primitiveSize;
}
return offset;
}
@Override
public boolean compress(T pixelData, ByteBuffer compressed) {
int pixelDataLimit = pixelData.limit();
byte[] pixelBytes = new byte[pixelDataLimit * this.primitiveSize];
getPixel(pixelData, pixelBytes);
pixelBytes = shuffle(pixelBytes);
GZIPOutputStream zip = null;
try {
zip = createGZipOutputStream(pixelDataLimit, compressed);
zip.write(pixelBytes, 0, pixelBytes.length);
} catch (IOException e) {
throw new IllegalStateException("could not gzip data", e);
} finally {
SafeClose.close(zip);
}
return true;
}
@Override
public void decompress(ByteBuffer compressed, T pixelData) {
int pixelDataLimit = pixelData.limit();
byte[] pixelBytes = new byte[pixelDataLimit * this.primitiveSize];
GZIPInputStream zip = null;
try {
zip = createGZipInputStream(compressed);
int count = 0;
int offset = 0;
while (offset < pixelBytes.length && count >= 0) {
count = zip.read(pixelBytes, offset, pixelBytes.length - offset);
if (count >= 0) {
offset = offset + count;
}
}
} catch (IOException e) {
throw new IllegalStateException("could not gunzip data", e);
} finally {
SafeClose.close(zip);
}
pixelBytes = unshuffle(pixelBytes);
setPixel(pixelData, pixelBytes);
}
public byte[] shuffle(byte[] byteArray) {
byte[] result = new byte[byteArray.length];
int resultIndex = 0;
int[] offset = calculateOffsets(byteArray);
for (int index = 0; index < byteArray.length; index += this.primitiveSize) {
for (int primitiveIndex = 0; primitiveIndex < this.primitiveSize; primitiveIndex++) {
result[resultIndex + offset[primitiveIndex]] = byteArray[index + primitiveIndex];
}
resultIndex++;
}
return result;
}
public byte[] unshuffle(byte[] byteArray) {
byte[] result = new byte[byteArray.length];
int resultIndex = 0;
int[] offset = calculateOffsets(byteArray);
for (int index = 0; index < byteArray.length; index += this.primitiveSize) {
for (int primitiveIndex = 0; primitiveIndex < this.primitiveSize; primitiveIndex++) {
result[index + primitiveIndex] = byteArray[resultIndex + offset[primitiveIndex]];
}
resultIndex++;
}
return result;
}
}
nom/tam/fits/compression/algorithm/hcompress/ 0000775 0000000 0000000 00000000000 12755570706 020445 5 ustar root root nom/tam/fits/compression/algorithm/hcompress/HCompressor.java 0000664 0000000 0000000 00000013561 12755570700 023554 0 ustar root root package nom.tam.fits.compression.algorithm.hcompress;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.nio.Buffer;
import java.nio.ByteBuffer;
import java.nio.IntBuffer;
import java.nio.ShortBuffer;
import nom.tam.fits.compression.algorithm.api.ICompressor;
import nom.tam.fits.compression.algorithm.quant.QuantizeProcessor.DoubleQuantCompressor;
import nom.tam.fits.compression.algorithm.quant.QuantizeProcessor.FloatQuantCompressor;
import nom.tam.util.ArrayFuncs;
public abstract class HCompressor implements ICompressor {
public static class ByteHCompressor extends HCompressor {
private static final long BYTE_MASK_FOR_LONG = 0xFFL;
public ByteHCompressor(HCompressorOption options) {
super(options);
}
@Override
public boolean compress(ByteBuffer buffer, ByteBuffer compressed) {
byte[] byteArray = new byte[buffer.limit()];
buffer.get(byteArray);
long[] longArray = new long[byteArray.length];
for (int index = 0; index < longArray.length; index++) {
longArray[index] = byteArray[index] & BYTE_MASK_FOR_LONG;
}
compress(longArray, compressed);
return true;
}
@Override
public void decompress(ByteBuffer compressed, ByteBuffer buffer) {
long[] longArray = new long[buffer.limit()];
decompress(compressed, longArray);
for (long element : longArray) {
buffer.put((byte) element);
}
}
}
public static class DoubleHCompressor extends DoubleQuantCompressor {
public DoubleHCompressor(HCompressorQuantizeOption options) {
super(options, new IntHCompressor(options.getHCompressorOption()));
}
}
public static class FloatHCompressor extends FloatQuantCompressor {
public FloatHCompressor(HCompressorQuantizeOption options) {
super(options, new IntHCompressor(options.getHCompressorOption()));
}
}
public static class IntHCompressor extends HCompressor {
public IntHCompressor(HCompressorOption options) {
super(options);
}
@Override
public boolean compress(IntBuffer buffer, ByteBuffer compressed) {
int[] intArray = new int[buffer.limit()];
buffer.get(intArray);
long[] longArray = new long[intArray.length];
ArrayFuncs.copyInto(intArray, longArray);
compress(longArray, compressed);
return true;
}
@Override
public void decompress(ByteBuffer compressed, IntBuffer buffer) {
long[] longArray = new long[buffer.limit()];
decompress(compressed, longArray);
for (long element : longArray) {
buffer.put((int) element);
}
}
}
public static class ShortHCompressor extends HCompressor {
public ShortHCompressor(HCompressorOption options) {
super(options);
}
@Override
public boolean compress(ShortBuffer buffer, ByteBuffer compressed) {
short[] shortArray = new short[buffer.limit()];
buffer.get(shortArray);
long[] longArray = new long[shortArray.length];
ArrayFuncs.copyInto(shortArray, longArray);
compress(longArray, compressed);
return true;
}
@Override
public void decompress(ByteBuffer compressed, ShortBuffer buffer) {
long[] longArray = new long[buffer.limit()];
decompress(compressed, longArray);
for (long element : longArray) {
buffer.put((short) element);
}
}
}
private HCompress compress;
private HDecompress decompress;
private final HCompressorOption options;
public HCompressor(HCompressorOption options) {
this.options = options;
}
private HCompress compress() {
if (this.compress == null) {
this.compress = new HCompress();
}
return this.compress;
}
protected void compress(long[] longArray, ByteBuffer compressed) {
compress().compress(longArray, this.options.getTileHeight(), this.options.getTileWidth(), this.options.getScale(), compressed);
}
private HDecompress decompress() {
if (this.decompress == null) {
this.decompress = new HDecompress();
}
return this.decompress;
}
protected void decompress(ByteBuffer compressed, long[] aa) {
decompress().decompress(compressed, this.options.isSmooth(), aa);
}
}
nom/tam/fits/compression/algorithm/hcompress/HDecompress.java 0000664 0000000 0000000 00000115240 12755570700 023521 0 ustar root root package nom.tam.fits.compression.algorithm.hcompress;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import static nom.tam.fits.compression.algorithm.hcompress.HCompress.BITS_OF_1_BYTE;
import static nom.tam.fits.compression.algorithm.hcompress.HCompress.BITS_OF_1_NYBBLE;
import static nom.tam.fits.compression.algorithm.hcompress.HCompress.BYTE_MASK;
import static nom.tam.fits.compression.algorithm.hcompress.HCompress.NYBBLE_MASK;
import static nom.tam.fits.compression.algorithm.hcompress.HCompress.ROUNDING_HALF;
import java.nio.ByteBuffer;
/**
* The original decompression code was written by R. White at the STScI and
* included (ported to c and adapted) in cfitsio by William Pence, NASA/GSFC.
* That code was then ported to java by R. van Nieuwenhoven. Later it was
* massively refactored to harmonize the different compression algorithms and
* reduce the duplicate code pieces without obscuring the algorithm itself as
* far as possible. The original site for the algorithm is
*
*
* @see http://www.stsci.edu/software/hcompress.html
*
*
* @author Richard White
* @author William Pence
* @author Richard van Nieuwenhoven
*/
public class HDecompress {
private static class LongArrayPointer {
private final long[] a;
private int offset;
LongArrayPointer(long[] tmp) {
this.a = tmp;
this.offset = 0;
}
public void bitOr(int i, long planeVal) {
this.a[this.offset + i] |= planeVal;
}
public LongArrayPointer copy(int extraOffset) {
LongArrayPointer intAP = new LongArrayPointer(this.a);
intAP.offset = this.offset + extraOffset;
return intAP;
}
public long get() {
return this.a[this.offset];
}
public long get(int i) {
return this.a[this.offset + i];
}
public void set(int i, long value) {
this.a[this.offset + i] = value;
}
public void set(long value) {
this.a[this.offset] = value;
}
}
private static final byte[] CODE_MAGIC = {
(byte) 0xDD,
(byte) 0x99
};
private static final int[] MASKS = {
0,
1,
3,
7,
15,
31,
63,
127,
255
};
private static final byte ZERO = 0;
private static final byte BIT_ONE = 1;
private static final byte BIT_TWO = 2;
private static final byte BIT_THREE = 4;
private static final byte BIT_FOUR = 8;
/**
* these N constants are obscuring the algorithm and should get some
* explaining javadoc if somebody understands the algorithm.
*/
private static final int N03 = 3;
private static final int N04 = 4;
private static final int N05 = 5;
private static final int N06 = 6;
private static final int N07 = 7;
private static final int N08 = 8;
private static final int N09 = 9;
private static final int N10 = 10;
private static final int N11 = 11;
private static final int N12 = 12;
private static final int N13 = 13;
private static final int N14 = 14;
private static final int N15 = 15;
private static final int N26 = 26;
private static final int N27 = 27;
private static final int N28 = 28;
private static final int N29 = 29;
private static final int N30 = 30;
private static final int N31 = 31;
private static final int N62 = 62;
private static final int N63 = 63;
/**
* Number of bits still in buffer
*/
private int bitsToGo;
/** Bits waiting to be input */
private int buffer2;
private int nx;
private int ny;
private int scale;
/**
* log2n is log2 of max(nx,ny) rounded up to next power of 2
*/
private int calculateLog2N(int nmax) {
int log2n;
log2n = (int) (Math.log(nmax) / Math.log(2.0) + ROUNDING_HALF);
if (nmax > 1 << log2n) {
log2n += 1;
}
return log2n;
}
/**
* char *infile; input file long *a; address of output tiledImageOperation
* [nx][ny] int *nx,*ny; size of output tiledImageOperation int *scale;
* scale factor for digitization
*
* @param infile
* @param a
*/
private void decode64(ByteBuffer infile, LongArrayPointer a) {
byte[] nbitplanes = new byte[N03];
byte[] tmagic = new byte[2];
/*
* File starts either with special 2-byte magic code or with FITS
* keyword "SIMPLE ="
*/
infile.get(tmagic);
/*
* check for correct magic code value
*/
if (tmagic[0] != CODE_MAGIC[0] || tmagic[1] != CODE_MAGIC[1]) {
throw new RuntimeException("Compression error");
}
this.nx = infile.getInt(); /* x size of image */
this.ny = infile.getInt(); /* y size of image */
this.scale = infile.getInt(); /* scale factor for digitization */
/* sum of all pixels */
long sumall = infile.getLong();
/* # bits in quadrants */
infile.get(nbitplanes);
dodecode64(infile, a, nbitplanes);
/*
* put sum of all pixels back into pixel 0
*/
a.set(0, sumall);
}
/**
* decompress the input byte stream using the H-compress algorithm input -
* input tiledImageOperation of compressed bytes a - pre-allocated
* tiledImageOperation to hold the output uncompressed image nx - returned X
* axis size ny - returned Y axis size NOTE: the nx and ny dimensions as
* defined within this code are reversed from the usual FITS notation. ny is
* the fastest varying dimension, which is usually considered the X axis in
* the FITS image display
*
* @param input
* the input buffer to decompress
* @param smooth
* should the image be smoothed
* @param aa
* the resulting long tiledImageOperation
*/
public void decompress(ByteBuffer input, boolean smooth, long[] aa) {
LongArrayPointer a = new LongArrayPointer(aa);
/* decode the input tiledImageOperation */
decode64(input, a);
/*
* Un-Digitize
*/
undigitize64(a);
/*
* Inverse H-transform
*/
hinv64(a, smooth);
}
/**
* long a[]; int nx,ny; Array dimensions are [nx][ny] unsigned char
* nbitplanes[3]; Number of bit planes in quadrants
*/
private int dodecode64(ByteBuffer infile, LongArrayPointer a, byte[] nbitplanes) {
int nel = this.nx * this.ny;
int nx2 = (this.nx + 1) / 2;
int ny2 = (this.ny + 1) / 2;
/*
* initialize a to zero
*/
for (int i = 0; i < nel; i++) {
a.set(i, 0);
}
/*
* Initialize bit input
*/
startInputingBits();
/*
* read bit planes for each quadrant
*/
qtreeDecode64(infile, a.copy(0), this.ny, nx2, ny2, nbitplanes[0]);
qtreeDecode64(infile, a.copy(ny2), this.ny, nx2, this.ny / 2, nbitplanes[1]);
qtreeDecode64(infile, a.copy(this.ny * nx2), this.ny, this.nx / 2, ny2, nbitplanes[1]);
qtreeDecode64(infile, a.copy(this.ny * nx2 + ny2), this.ny, this.nx / 2, this.ny / 2, nbitplanes[2]);
/*
* make sure there is an EOF symbol (nybble=0) at end
*/
if (inputNybble(infile) != 0) {
throw new RuntimeException("Compression error");
}
/*
* now get the sign bits Re-initialize bit input
*/
startInputingBits();
for (int i = 0; i < nel; i++) {
if (a.get(i) != 0) {
if (inputBit(infile) != 0) {
a.set(i, -a.get(i));
}
}
}
return 0;
}
/**
* int smooth; 0 for no smoothing, else smooth during inversion int scale;
* used if smoothing is specified
*/
private int hinv64(LongArrayPointer a, boolean smooth) {
int nmax = this.nx > this.ny ? this.nx : this.ny;
int log2n = calculateLog2N(nmax);
// get temporary storage for shuffling elements
long[] tmp = new long[(nmax + 1) / 2];
// set up masks, rounding parameters
int shift = 1;
long bit0 = (long) 1 << log2n - 1;
long bit1 = bit0 << 1;
long bit2 = bit0 << 2;
long mask0 = -bit0;
long mask1 = mask0 << 1;
long mask2 = mask0 << 2;
long prnd0 = bit0 >> 1;
long prnd1 = bit1 >> 1;
long prnd2 = bit2 >> 1;
long nrnd0 = prnd0 - 1;
long nrnd1 = prnd1 - 1;
long nrnd2 = prnd2 - 1;
// round h0 to multiple of bit2
a.set(0, a.get(0) + (a.get(0) >= 0 ? prnd2 : nrnd2) & mask2);
// do log2n expansions We're indexing a as a 2-D tiledImageOperation
// with dimensions
// (nx,ny).
int nxtop = 1;
int nytop = 1;
int nxf = this.nx;
int nyf = this.ny;
int c = 1 << log2n;
int i;
for (int k = log2n - 1; k >= 0; k--) {
// this somewhat cryptic code generates the sequence ntop[k-1] =
// (ntop[k]+1)/2, where ntop[log2n] = n
c = c >> 1;
nxtop = nxtop << 1;
nytop = nytop << 1;
if (nxf <= c) {
nxtop -= 1;
} else {
nxf -= c;
}
if (nyf <= c) {
nytop -= 1;
} else {
nyf -= c;
}
// double shift and fix nrnd0 (because prnd0=0) on last pass
if (k == 0) {
nrnd0 = 0;
shift = 2;
}
// unshuffle in each dimension to interleave coefficients
for (i = 0; i < nxtop; i++) {
unshuffle64(a.copy(this.ny * i), nytop, 1, tmp);
}
for (int j = 0; j < nytop; j++) {
unshuffle64(a.copy(j), nxtop, this.ny, tmp);
}
// smooth by interpolating coefficients if SMOOTH != 0
if (smooth) {
hsmooth64(a, nxtop, nytop);
}
int oddx = nxtop % 2;
int oddy = nytop % 2;
for (i = 0; i < nxtop - oddx; i += 2) {
int s00 = this.ny * i; /* s00 is index of a[i,j] */
int s10 = s00 + this.ny; /* s10 is index of a[i+1,j] */
for (int j = 0; j < nytop - oddy; j += 2) {
long h0 = a.get(s00);
long hx = a.get(s10);
long hy = a.get(s00 + 1);
long hc = a.get(s10 + 1);
// round hx and hy to multiple of bit1, hc to multiple of
// bit0 h0 is already a multiple of bit2
hx = hx + (hx >= 0 ? prnd1 : nrnd1) & mask1;
hy = hy + (hy >= 0 ? prnd1 : nrnd1) & mask1;
hc = hc + (hc >= 0 ? prnd0 : nrnd0) & mask0;
// propagate bit0 of hc to hx,hy
long lowbit0 = hc & bit0;
hx = hx >= 0 ? hx - lowbit0 : hx + lowbit0;
hy = hy >= 0 ? hy - lowbit0 : hy + lowbit0;
// Propagate bits 0 and 1 of hc,hx,hy to h0. This could be
// simplified if we assume h0>0, but then the inversion
// would not be lossless for images with negative pixels.
long lowbit1 = (hc ^ hx ^ hy) & bit1;
h0 = h0 >= 0 ? h0 + lowbit0 - lowbit1 : h0 + (lowbit0 == 0 ? lowbit1 : lowbit0 - lowbit1);
// Divide sums by 2 (4 last time)
a.set(s10 + 1, h0 + hx + hy + hc >> shift);
a.set(s10, h0 + hx - hy - hc >> shift);
a.set(s00 + 1, h0 - hx + hy - hc >> shift);
a.set(s00, h0 - hx - hy + hc >> shift);
s00 += 2;
s10 += 2;
}
if (oddy != 0) {
// do last element in row if row length is odd s00+1, s10+1
// are off edge
long h0 = a.get(s00);
long hx = a.get(s10);
hx = (hx >= 0 ? hx + prnd1 : hx + nrnd1) & mask1;
long lowbit1 = hx & bit1;
h0 = h0 >= 0 ? h0 - lowbit1 : h0 + lowbit1;
a.set(s10, h0 + hx >> shift);
a.set(s00, h0 - hx >> shift);
}
}
if (oddx != 0) {
// do last row if column length is odd s10, s10+1 are off edge
int s00 = this.ny * i;
for (int j = 0; j < nytop - oddy; j += 2) {
long h0 = a.get(s00);
long hy = a.get(s00 + 1);
hy = (hy >= 0 ? hy + prnd1 : hy + nrnd1) & mask1;
long lowbit1 = hy & bit1;
h0 = h0 >= 0 ? h0 - lowbit1 : h0 + lowbit1;
a.set(s00 + 1, h0 + hy >> shift);
a.set(s00, h0 - hy >> shift);
s00 += 2;
}
if (oddy != 0) {
// do corner element if both row and column lengths are odd
// s00+1, s10, s10+1 are off edge
long h0 = a.get(s00);
a.set(s00, h0 >> shift);
}
}
// divide all the masks and rounding values by 2
bit1 = bit0;
bit0 = bit0 >> 1;
mask1 = mask0;
mask0 = mask0 >> 1;
prnd1 = prnd0;
prnd0 = prnd0 >> 1;
nrnd1 = nrnd0;
nrnd0 = prnd0 - 1;
}
return 0;
}
/**
* long a[]; tiledImageOperation of H-transform coefficients int
* nxtop,nytop; size of coefficient block to use int ny; actual 1st
* dimension of tiledImageOperation int scale; truncation scale factor that
* was used
*/
private void hsmooth64(LongArrayPointer a, int nxtop, int nytop) {
int i, j;
int ny2, s10, s00;
long hm, h0, hp, hmm, hpm, hmp, hpp, hx2, hy2, diff, dmax, dmin, s, smax, m1, m2;
/*
* Maximum change in coefficients is determined by scale factor. Since
* we rounded during division (see digitize.c), the biggest permitted
* change is scale/2.
*/
smax = this.scale >> 1;
if (smax <= 0) {
return;
}
ny2 = this.ny << 1;
/*
* We're indexing a as a 2-D tiledImageOperation with dimensions
* (nxtop,ny) of which only (nxtop,nytop) are used. The coefficients on
* the edge of the tiledImageOperation are not adjusted (which is why
* the loops below start at 2 instead of 0 and end at nxtop-2 instead of
* nxtop.)
*/
/*
* Adjust x difference hx
*/
for (i = 2; i < nxtop - 2; i += 2) {
s00 = this.ny * i; /* s00 is index of a[i,j] */
s10 = s00 + this.ny; /* s10 is index of a[i+1,j] */
for (j = 0; j < nytop; j += 2) {
/*
* hp is h0 (mean value) in next x zone, hm is h0 in previous x
* zone
*/
hm = a.get(s00 - ny2);
h0 = a.get(s00);
hp = a.get(s00 + ny2);
/*
* diff = 8 * hx slope that would match h0 in neighboring zones
*/
diff = hp - hm;
/*
* monotonicity constraints on diff
*/
dmax = Math.max(Math.min(hp - h0, h0 - hm), 0) << 2;
dmin = Math.min(Math.max(hp - h0, h0 - hm), 0) << 2;
/*
* if monotonicity would set slope = 0 then don't change hx.
* note dmax>=0, dmin<=0.
*/
if (dmin < dmax) {
diff = Math.max(Math.min(diff, dmax), dmin);
/*
* Compute change in slope limited to range +/- smax.
* Careful with rounding negative numbers when using shift
* for divide by 8.
*/
s = diff - (a.get(s10) << N03);
s = s >= 0 ? s >> N03 : s + N07 >> N03;
s = Math.max(Math.min(s, smax), -smax);
a.set(s10, a.get(s10) + s);
}
s00 += 2;
s10 += 2;
}
}
/*
* Adjust y difference hy
*/
for (i = 0; i < nxtop; i += 2) {
s00 = this.ny * i + 2;
s10 = s00 + this.ny;
for (j = 2; j < nytop - 2; j += 2) {
hm = a.get(s00 - 2);
h0 = a.get(s00);
hp = a.get(s00 + 2);
diff = hp - hm;
dmax = Math.max(Math.min(hp - h0, h0 - hm), 0) << 2;
dmin = Math.min(Math.max(hp - h0, h0 - hm), 0) << 2;
if (dmin < dmax) {
diff = Math.max(Math.min(diff, dmax), dmin);
s = diff - (a.get(s00 + 1) << N03);
s = s >= 0 ? s >> N03 : s + N07 >> N03;
s = Math.max(Math.min(s, smax), -smax);
a.set(s00 + 1, a.get(s00 + 1) + s);
}
s00 += 2;
s10 += 2;
}
}
/*
* Adjust curvature difference hc
*/
for (i = 2; i < nxtop - 2; i += 2) {
s00 = this.ny * i + 2;
s10 = s00 + this.ny;
for (j = 2; j < nytop - 2; j += 2) {
/*
* ------------------ y | hmp | | hpp | | ------------------ | |
* | h0 | | | ------------------ -------x | hmm | | hpm |
* ------------------
*/
hmm = a.get(s00 - ny2 - 2);
hpm = a.get(s00 + ny2 - 2);
hmp = a.get(s00 - ny2 + 2);
hpp = a.get(s00 + ny2 + 2);
h0 = a.get(s00);
/*
* diff = 64 * hc value that would match h0 in neighboring zones
*/
diff = hpp + hmm - hmp - hpm;
/*
* 2 times x,y slopes in this zone
*/
hx2 = a.get(s10) << 1;
hy2 = a.get(s00 + 1) << 1;
/*
* monotonicity constraints on diff
*/
m1 = Math.min(Math.max(hpp - h0, 0) - hx2 - hy2, Math.max(h0 - hpm, 0) + hx2 - hy2);
m2 = Math.min(Math.max(h0 - hmp, 0) - hx2 + hy2, Math.max(hmm - h0, 0) + hx2 + hy2);
dmax = Math.min(m1, m2) << BITS_OF_1_NYBBLE;
m1 = Math.max(Math.min(hpp - h0, 0) - hx2 - hy2, Math.min(h0 - hpm, 0) + hx2 - hy2);
m2 = Math.max(Math.min(h0 - hmp, 0) - hx2 + hy2, Math.min(hmm - h0, 0) + hx2 + hy2);
dmin = Math.max(m1, m2) << BITS_OF_1_NYBBLE;
/*
* if monotonicity would set slope = 0 then don't change hc.
* note dmax>=0, dmin<=0.
*/
if (dmin < dmax) {
diff = Math.max(Math.min(diff, dmax), dmin);
/*
* Compute change in slope limited to range +/- smax.
* Careful with rounding negative numbers when using shift
* for divide by 64.
*/
s = diff - (a.get(s10 + 1) << N06);
s = s >= 0 ? s >> N06 : s + N63 >> N06;
s = Math.max(Math.min(s, smax), -smax);
a.set(s10 + 1, a.get(s10 + 1) + s);
}
s00 += 2;
s10 += 2;
}
}
}
private int inputBit(ByteBuffer infile) {
if (this.bitsToGo == 0) { /* Read the next byte if no */
this.buffer2 = infile.get() & BYTE_MASK;
this.bitsToGo = BITS_OF_1_BYTE;
}
/*
* Return the next bit
*/
this.bitsToGo -= 1;
return this.buffer2 >> this.bitsToGo & 1;
}
/*
* Huffman decoding for fixed codes Coded values range from 0-15 Huffman
* code values (hex): 3e, 00, 01, 08, 02, 09, 1a, 1b, 03, 1c, 0a, 1d, 0b,
* 1e, 3f, 0c and number of bits in each code: 6, 3, 3, 4, 3, 4, 5, 5, 3, 5,
* 4, 5, 4, 5, 6, 4
*/
private int inputHuffman(ByteBuffer infile) {
int c;
/*
* get first 3 bits to start
*/
c = inputNbits(infile, N03);
if (c < N04) {
/*
* this is all we need return 1,2,4,8 for c=0,1,2,3
*/
return 1 << c;
}
/*
* get the next bit
*/
c = inputBit(infile) | c << 1;
if (c < N13) {
/*
* OK, 4 bits is enough
*/
switch (c) {
case N08:
return N03;
case N09:
return N05;
case N10:
return N10;
case N11:
return N12;
case N12:
return N15;
default:
}
}
/*
* get yet another bit
*/
c = inputBit(infile) | c << 1;
if (c < N31) {
/*
* OK, 5 bits is enough
*/
switch (c) {
case N26:
return N06;
case N27:
return N07;
case N28:
return N09;
case N29:
return N11;
case N30:
return N13;
default:
}
}
/*
* need the 6th bit
*/
c = inputBit(infile) | c << 1;
if (c == N62) {
return 0;
} else {
return N14;
}
}
private int inputNbits(ByteBuffer infile, int n) {
if (this.bitsToGo < n) {
/*
* need another byte's worth of bits
*/
this.buffer2 = this.buffer2 << BITS_OF_1_BYTE | infile.get() & BYTE_MASK;
this.bitsToGo += BITS_OF_1_BYTE;
}
/*
* now pick off the first n bits
*/
this.bitsToGo -= n;
/* there was a slight gain in speed by replacing the following line */
/* return( (buffer2>>bits_to_go) & ((1<> this.bitsToGo & MASKS[n];
}
/* INITIALIZE BIT INPUT */
private int inputNnybble(ByteBuffer infile, int n, byte[] array) {
/*
* copy n 4-bit nybbles from infile to the lower 4 bits of
* tiledImageOperation
*/
int ii, kk, shift1, shift2;
/*
* forcing byte alignment doesn;t help, and even makes it go slightly
* slower if (bits_to_go != 8) input_nbits(infile, bits_to_go);
*/
if (n == 1) {
array[0] = (byte) inputNybble(infile);
return 0;
}
if (this.bitsToGo == BITS_OF_1_BYTE) {
/*
* already have 2 full nybbles in buffer2, so backspace the infile
* tiledImageOperation to reuse last char
*/
infile.position(infile.position() - 1);
this.bitsToGo = 0;
}
/* bits_to_go now has a value in the range 0 - 7. After adding */
/* another byte, bits_to_go effectively will be in range 8 - 15 */
shift1 = this.bitsToGo + BITS_OF_1_NYBBLE; /*
* shift1 will be in range 4
* - 11
*/
shift2 = this.bitsToGo; /* shift2 will be in range 0 - 7 */
kk = 0;
/* special case */
if (this.bitsToGo == 0) {
for (ii = 0; ii < n / 2; ii++) {
/*
* refill the buffer with next byte
*/
this.buffer2 = this.buffer2 << BITS_OF_1_BYTE | infile.get() & BYTE_MASK;
array[kk] = (byte) (this.buffer2 >> BITS_OF_1_NYBBLE & NYBBLE_MASK);
array[kk + 1] = (byte) (this.buffer2 & NYBBLE_MASK); /*
* no shift
* required
*/
kk += 2;
}
} else {
for (ii = 0; ii < n / 2; ii++) {
/*
* refill the buffer with next byte
*/
this.buffer2 = this.buffer2 << BITS_OF_1_BYTE | infile.get() & BYTE_MASK;
array[kk] = (byte) (this.buffer2 >> shift1 & NYBBLE_MASK);
array[kk + 1] = (byte) (this.buffer2 >> shift2 & NYBBLE_MASK);
kk += 2;
}
}
if (ii * 2 != n) { /* have to read last odd byte */
array[n - 1] = (byte) inputNybble(infile);
}
return this.buffer2 >> this.bitsToGo & NYBBLE_MASK;
}
private int inputNybble(ByteBuffer infile) {
if (this.bitsToGo < BITS_OF_1_NYBBLE) {
/*
* need another byte's worth of bits
*/
this.buffer2 = this.buffer2 << BITS_OF_1_BYTE | infile.get() & BYTE_MASK;
this.bitsToGo += BITS_OF_1_BYTE;
}
/*
* now pick off the first 4 bits
*/
this.bitsToGo -= BITS_OF_1_NYBBLE;
return this.buffer2 >> this.bitsToGo & NYBBLE_MASK;
}
/**
* Copy 4-bit values from a[(nx+1)/2,(ny+1)/2] to b[nx,ny], expanding each
* value to 2x2 pixels and inserting into bitplane BIT of B. A,B may NOT be
* same tiledImageOperation (it wouldn't make sense to be inserting bits
* into the same tiledImageOperation anyway.)
*/
private void qtreeBitins64(byte[] a, int lnx, int lny, LongArrayPointer b, int n, int bit) {
int i, j, s00;
long planeVal = 1L << bit;
// expand each 2x2 block
ByteBuffer k = ByteBuffer.wrap(a); /* k is index of a[i/2,j/2] */
for (i = 0; i < lnx - 1; i += 2) {
s00 = n * i; /* s00 is index of b[i,j] */
// Note: this code appears to run very slightly faster on a 32-bit
// linux machine using s00+n rather than the s10 intermediate
// variable
// s10 = s00+n; *//* s10 is index of b[i+1,j]
for (j = 0; j < lny - 1; j += 2) {
byte value = k.get();
if ((value & BIT_ONE) != ZERO) {
b.bitOr(s00 + n + 1, planeVal);
}
if ((value & BIT_TWO) != ZERO) {
b.bitOr(s00 + n, planeVal);
}
if ((value & BIT_THREE) != ZERO) {
b.bitOr(s00 + 1, planeVal);
}
if ((value & BIT_FOUR) != ZERO) {
b.bitOr(s00, planeVal);
}
// b.bitOr(s10+1, ((LONGLONG) ( a[k] & 1)) << bit; b.bitOr(s10 ,
// ((((LONGLONG)a[k])>>1) & 1) << bit; b.bitOr(s00+1,
// ((((LONGLONG)a[k])>>2) & 1) << bit; b.bitOr(s00
// ,((((LONGLONG)a[k])>>3) & 1) << bit;
s00 += 2;
/* s10 += 2; */
}
if (j < lny) {
// row size is odd, do last element in row s00+1, s10+1 are off
// edge
byte value = k.get();
if ((value & BIT_TWO) != ZERO) {
b.bitOr(s00 + n, planeVal);
}
if ((value & BIT_FOUR) != ZERO) {
b.bitOr(s00, planeVal);
}
// b.bitOr(s10 , ((((LONGLONG)a[k])>>1) & 1) << bit; b.bitOr(s00
// , ((((LONGLONG)a[k])>>3) & 1) << bit;
}
}
if (i < lnx) {
// column size is odd, do last row s10, s10+1 are off edge
s00 = n * i;
for (j = 0; j < lny - 1; j += 2) {
byte value = k.get();
if ((value & BIT_THREE) != ZERO) {
b.bitOr(s00 + 1, planeVal);
}
if ((value & BIT_FOUR) != ZERO) {
b.bitOr(s00, planeVal);
} // b.bitOr(s00+1, ((((LONGLONG)a[k])>>2) & 1) << bit;
// b.bitOr(s00 , ((((LONGLONG)a[k])>>3) & 1) << bit;
s00 += 2;
}
if (j < lny) {
// both row and column size are odd, do corner element s00+1,
// s10, s10+1 are off edge
if ((k.get() & BIT_FOUR) != ZERO) {
b.bitOr(s00, planeVal);
}
// b.bitOr(s00 , ((((LONGLONG)a[k])>>3) & 1) << bit;
}
}
}
/**
* copy 4-bit values from a[(nx+1)/2,(ny+1)/2] to b[nx,ny], expanding each
* value to 2x2 pixels a,b may be same tiledImageOperation
*/
private void qtreeCopy(byte[] a, int lnx, int lny, byte[] b, int n) {
int i, j, k, nx2, ny2;
int s00, s10;
// first copy 4-bit values to b start at end in case a,b are same
// tiledImageOperation
nx2 = (lnx + 1) / 2;
ny2 = (lny + 1) / 2;
k = ny2 * (nx2 - 1) + ny2 - 1; /* k is index of a[i,j] */
for (i = nx2 - 1; i >= 0; i--) {
s00 = 2 * (n * i + ny2 - 1); /* s00 is index of b[2*i,2*j] */
for (j = ny2 - 1; j >= 0; j--) {
b[s00] = a[k];
k -= 1;
s00 -= 2;
}
}
for (i = 0; i < lnx - 1; i += 2) { // now expand each 2x2 block
// Note: Unlike the case in qtree_bitins, this code runs faster on a
// 32-bit linux machine using the s10 intermediate variable, rather
// that using s00+n. Go figure!
s00 = n * i; // s00 is index of b[i,j]
s10 = s00 + n; // s10 is index of b[i+1,j]
for (j = 0; j < lny - 1; j += 2) {
b[s10 + 1] = (b[s00] & BIT_ONE) == ZERO ? ZERO : BIT_ONE;
b[s10] = (b[s00] & BIT_TWO) == ZERO ? ZERO : BIT_ONE;
b[s00 + 1] = (b[s00] & BIT_THREE) == ZERO ? ZERO : BIT_ONE;
b[s00] = (b[s00] & BIT_FOUR) == ZERO ? ZERO : BIT_ONE;
s00 += 2;
s10 += 2;
}
if (j < lny) {
// row size is odd, do last element in row s00+1, s10+1 are off
// edge not worth converting this to use 16 case statements
b[s10] = (byte) (b[s00] >> 1 & 1);
b[s00] = (byte) (b[s00] >> N03 & 1);
}
}
if (i < lnx) {
// column size is odd, do last row s10, s10+1 are off edge
s00 = n * i;
for (j = 0; j < lny - 1; j += 2) {
// not worth converting this to use 16 case statements
b[s00 + 1] = (byte) (b[s00] >> 2 & 1);
b[s00] = (byte) (b[s00] >> N03 & 1);
s00 += 2;
}
if (j < lny) {
// both row and column size are odd, do corner element s00+1,
// s10, s10+1 are off edge not worth converting this to use 16
// case statements
b[s00] = (byte) (b[s00] >> N03 & 1);
}
}
}
/**
* char *infile; long a[]; a is 2-D tiledImageOperation with dimensions
* (n,n) int n; length of full row in a int nqx; partial length of row to
* decode int nqy; partial length of column (<=n) int nbitplanes; number of
* bitplanes to decode
*/
private int qtreeDecode64(ByteBuffer infile, LongArrayPointer a, int n, int nqx, int nqy, int nbitplanes) {
int k, bit, b;
int nx2, ny2, nfx, nfy, c;
byte[] scratch;
/*
* log2n is log2 of max(nqx,nqy) rounded up to next power of 2
*/
int nqmax = nqx > nqy ? nqx : nqy;
int log2n = calculateLog2N(nqmax);
/*
* allocate scratch tiledImageOperation for working space
*/
int nqx2 = (nqx + 1) / 2;
int nqy2 = (nqy + 1) / 2;
scratch = new byte[nqx2 * nqy2];
/*
* now decode each bit plane, starting at the top A is assumed to be
* initialized to zero
*/
for (bit = nbitplanes - 1; bit >= 0; bit--) {
/*
* Was bitplane was quadtree-coded or written directly?
*/
b = inputNybble(infile);
if (b == 0) {
/*
* bit map was written directly
*/
readBdirect64(infile, a, n, nqx, nqy, scratch, bit);
} else if (b != NYBBLE_MASK) {
throw new RuntimeException("Compression error");
} else {
/*
* bitmap was quadtree-coded, do log2n expansions read first
* code
*/
scratch[0] = (byte) inputHuffman(infile);
/*
* now do log2n expansions, reading codes from file as necessary
*/
nx2 = 1;
ny2 = 1;
nfx = nqx;
nfy = nqy;
c = 1 << log2n;
for (k = 1; k < log2n; k++) {
/*
* this somewhat cryptic code generates the sequence n[k-1]
* = (n[k]+1)/2 where n[log2n]=nqx or nqy
*/
c = c >> 1;
nx2 = nx2 << 1;
ny2 = ny2 << 1;
if (nfx <= c) {
nx2 -= 1;
} else {
nfx -= c;
}
if (nfy <= c) {
ny2 -= 1;
} else {
nfy -= c;
}
qtreeExpand(infile, scratch, nx2, ny2, scratch);
}
/*
* now copy last set of 4-bit codes to bitplane bit of
* tiledImageOperation a
*/
qtreeBitins64(scratch, nqx, nqy, a, n, bit);
}
}
return 0;
}
/*
* do one quadtree expansion step on tiledImageOperation
* a[(nqx+1)/2,(nqy+1)/2] results put into b[nqx,nqy] (which may be the same
* as a)
*/
private void qtreeExpand(ByteBuffer infile, byte[] a, int nx2, int ny2, byte[] b) {
int i;
/*
* first copy a to b, expanding each 4-bit value
*/
qtreeCopy(a, nx2, ny2, b, ny2);
/*
* now read new 4-bit values into b for each non-zero element
*/
for (i = nx2 * ny2 - 1; i >= 0; i--) {
if (b[i] != 0) {
b[i] = (byte) inputHuffman(infile);
}
}
}
private void readBdirect64(ByteBuffer infile, LongArrayPointer a, int n, int nqx, int nqy, byte[] scratch, int bit) {
/*
* read bit image packed 4 pixels/nybble
*/
/*
* int i; for (i = 0; i < ((nqx+1)/2) * ((nqy+1)/2); i++) { scratch[i] =
* input_nybble(infile); }
*/
inputNnybble(infile, (nqx + 1) / 2 * ((nqy + 1) / 2), scratch);
/*
* insert in bitplane BIT of image A
*/
qtreeBitins64(scratch, nqx, nqy, a, n, bit);
}
/*
* ##########################################################################
* ##
*/
private void startInputingBits() {
/*
* Buffer starts out with no bits in it
*/
this.bitsToGo = 0;
}
private void undigitize64(LongArrayPointer a) {
long scale64;
/*
* multiply by scale
*/
if (this.scale <= 1) {
return;
}
scale64 = this.scale; /*
* use a 64-bit int for efficiency in the big loop
*/
for (int index = 0; index < a.a.length; index++) {
a.a[index] = a.a[index] * scale64;
}
}
/**
* long a[]; tiledImageOperation to shuffle int n; number of elements to
* shuffle int n2; second dimension long tmp[]; scratch storage
*/
private void unshuffle64(LongArrayPointer a, int n, int n2, long[] tmp) {
int i;
int nhalf;
LongArrayPointer p1, p2, pt;
/*
* copy 2nd half of tiledImageOperation to tmp
*/
nhalf = n + 1 >> 1;
pt = new LongArrayPointer(tmp);
p1 = a.copy(n2 * nhalf); /* pointer to a[i] */
for (i = nhalf; i < n; i++) {
pt.set(p1.get());
p1.offset += n2;
pt.offset += 1;
}
/*
* distribute 1st half of tiledImageOperation to even elements
*/
p2 = a.copy(n2 * (nhalf - 1)); /* pointer to a[i] */
p1 = a.copy(n2 * (nhalf - 1) << 1); /* pointer to a[2*i] */
for (i = nhalf - 1; i >= 0; i--) {
p1.set(p2.get());
p2.offset -= n2;
p1.offset -= n2 + n2;
}
/*
* now distribute 2nd half of tiledImageOperation (in tmp) to odd
* elements
*/
pt = new LongArrayPointer(tmp);
p1 = a.copy(n2); /* pointer to a[i] */
for (i = 1; i < n; i += 2) {
p1.set(pt.get());
p1.offset += n2 + n2;
pt.offset += 1;
}
}
}
nom/tam/fits/compression/algorithm/hcompress/HCompress.java 0000664 0000000 0000000 00000070441 12755570700 023213 0 ustar root root package nom.tam.fits.compression.algorithm.hcompress;
import java.nio.ByteBuffer;
import java.nio.LongBuffer;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
/**
* The original compression code was written by Richard White at the STScI and
* included (ported to c and adapted) in cfitsio by William Pence, NASA/GSFC.
* That code was then ported to java by R. van Nieuwenhoven. Later it was
* massively refactored to harmonize the different compression algorithms and
* reduce the duplicate code pieces without obscuring the algorithm itself as
* far as possible. The original site for the algorithm is
*
*
* @see http://www.stsci.edu/software/hcompress.html
*
*
* @author Richard White
* @author William Pence
* @author Richard van Nieuwenhoven
*/
public class HCompress {
private static final int HTRANS_START_MASK = -2;
protected static final double ROUNDING_HALF = 0.5;
protected static final int BITS_OF_1_BYTE = 8;
protected static final int BITS_OF_1_NYBBLE = 4;
protected static final int BYTE_MASK = 0xff;
protected static final int NYBBLE_MASK = 0xF;
/**
* to be refactored to a good name.
*/
private static final int N3 = 3;
private static final int[] BITS_MASK = {
0,
1,
3,
7,
15,
31,
63,
127,
255
};
/*
* Huffman code values and number of bits in each code
*/
private static final int[] CODE = {
0x3e,
0x00,
0x01,
0x08,
0x02,
0x09,
0x1a,
0x1b,
0x03,
0x1c,
0x0a,
0x1d,
0x0b,
0x1e,
0x3f,
0x0c
};
private static final byte[] CODE_MAGIC = {
(byte) 0xDD,
(byte) 0x99
};
private static final int[] NCODE = {
6,
3,
3,
4,
3,
4,
5,
5,
3,
5,
4,
5,
4,
5,
6,
4
};
/**
* variables for bit output to buffer when Huffman coding
*/
private int bitbuffer;
/** Number of bits free in buffer */
private int bitsToGo2;
private int bitsToGo3;
/** Bits buffered for output */
private int buffer2;
private int b2i(boolean b) {
return b ? 1 : 0;
}
private int bufcopy(byte[] a, int n, byte[] buffer, int b, long bmax) {
int i;
for (i = 0; i < n; i++) {
if (a[i] != 0) {
/*
* add Huffman code for a[i] to buffer
*/
this.bitbuffer |= CODE[a[i]] << this.bitsToGo3;
this.bitsToGo3 += NCODE[a[i]];
if (this.bitsToGo3 >= BITS_OF_1_BYTE) {
buffer[b] = (byte) (this.bitbuffer & BYTE_MASK);
b += 1;
/*
* return warning code if we fill buffer
*/
if (b >= bmax) {
return b;
}
this.bitbuffer >>= BITS_OF_1_BYTE;
this.bitsToGo3 -= BITS_OF_1_BYTE;
}
}
}
return b;
}
protected void compress(long[] aa, int ny, int nx, int scale, ByteBuffer output) {
/*
* compress the input image using the H-compress algorithm a - input
* image tiledImageOperation nx - size of X axis of image ny - size of Y
* axis of image scale - quantization scale factor. Larger values
* results in more (lossy) compression scale = 0 does lossless
* compression output - pre-allocated tiledImageOperation to hold the
* output compressed stream of bytes nbyts - input value = size of the
* output buffer; returned value = size of the compressed byte stream,
* in bytes NOTE: the nx and ny dimensions as defined within this code
* are reversed from the usual FITS notation. ny is the fastest varying
* dimension, which is usually considered the X axis in the FITS image
* display
*/
/* H-transform */
htrans(aa, nx, ny);
LongBuffer a = LongBuffer.wrap(aa);
/* digitize */
digitize(a, 0, nx, ny, scale);
/* encode and write to output tiledImageOperation */
encode(output, a, nx, ny, scale);
}
private LongBuffer copy(LongBuffer a, int i) {
a.position(i);
return a.slice();
}
private void digitize(LongBuffer a, int aOffset, int nx, int ny, long scale) {
/*
* round to multiple of scale
*/
if (scale <= 1) {
return;
}
long d = (scale + 1L) / 2L - 1L;
for (int index = 0; index < a.limit(); index++) {
long current = a.get(index);
a.put(index, (current > 0 ? current + d : current - d) / scale);
}
}
/**
* encode pixels.
*
* @param compressedBytes
* compressed data
* @param pixels
* pixels to compress
* @param nx
* image width dimension
* @param ny
* image height dimension
* @param nbitplanes
* Number of bit planes in quadrants
*/
private void doEncode(ByteBuffer compressedBytes, LongBuffer pixels, int nx, int ny, byte[] nbitplanes) {
int nx2 = (nx + 1) / 2;
int ny2 = (ny + 1) / 2;
/*
* Initialize bit output
*/
startOutputtingBits();
/*
* write out the bit planes for each quadrant
*/
qtreeEncode(compressedBytes, copy(pixels, 0), ny, nx2, ny2, nbitplanes[0]);
qtreeEncode(compressedBytes, copy(pixels, ny2), ny, nx2, ny / 2, nbitplanes[1]);
qtreeEncode(compressedBytes, copy(pixels, ny * nx2), ny, nx / 2, ny2, nbitplanes[1]);
qtreeEncode(compressedBytes, copy(pixels, ny * nx2 + ny2), ny, nx / 2, ny / 2, nbitplanes[2]);
/*
* Add zero as an EOF symbol
*/
outputNybble(compressedBytes, 0);
doneOutputtingBits(compressedBytes);
}
private void doneOutputtingBits(ByteBuffer outfile) {
if (this.bitsToGo2 < BITS_OF_1_BYTE) {
/* putc(buffer2< 0) {
/*
* positive element, put zero at end of buffer
*/
signbits[nsign] <<= 1;
bitsToGo -= 1;
} else if (a.get(i) < 0) {
/*
* negative element, shift in a one
*/
signbits[nsign] <<= 1;
signbits[nsign] |= 1;
bitsToGo -= 1;
/*
* replace a by absolute value
*/
a.put(i, -a.get(i));
}
if (bitsToGo == 0) {
/*
* filled up this byte, go to the next one
*/
bitsToGo = BITS_OF_1_BYTE;
nsign += 1;
signbits[nsign] = 0;
}
}
if (bitsToGo != BITS_OF_1_BYTE) {
/*
* some bits in last element move bits in last byte to bottom and
* increment nsign
*/
signbits[nsign] <<= bitsToGo;
nsign += 1;
}
/*
* calculate number of bit planes for 3 quadrants quadrant 0=bottom
* left, 1=bottom right or top left, 2=top right,
*/
for (int q = 0; q < N3; q++) {
vmax[q] = 0;
}
/*
* get maximum absolute value in each quadrant
*/
int nx2 = (nx + 1) / 2;
int ny2 = (ny + 1) / 2;
int j = 0; /* column counter */
int k = 0; /* row counter */
for (int i = 0; i < nel; i++) {
int q = (j >= ny2 ? 1 : 0) + (k >= nx2 ? 1 : 0);
if (vmax[q] < a.get(i)) {
vmax[q] = a.get(i);
}
if (++j >= ny) {
j = 0;
k += 1;
}
}
/*
* now calculate number of bits for each quadrant
*/
/* this is a more efficient way to do this, */
for (int q = 0; q < N3; q++) {
nbitplanes[q] = 0;
while (vmax[q] > 0) {
vmax[q] = vmax[q] >> 1;
nbitplanes[q]++;
}
}
/*
* write nbitplanes
*/
compressedBytes.put(nbitplanes, 0, nbitplanes.length);
/*
* write coded tiledImageOperation
*/
doEncode(compressedBytes, a, nx, ny, nbitplanes);
/*
* write sign bits
*/
if (nsign > 0) {
compressedBytes.put(signbits, 0, nsign);
}
return (int) noutchar;
}
private int htrans(long[] a, int nx, int ny) {
/*
* log2n is log2 of max(nx,ny) rounded up to next power of 2
*/
int nmax = nx > ny ? nx : ny;
int log2n = log2n(nmax);
if (nmax > 1 << log2n) {
log2n += 1;
}
/*
* get temporary storage for shuffling elements
*/
long[] tmp = new long[(nmax + 1) / 2];
/*
* set up rounding and shifting masks
*/
long shift = 0;
long mask = HTRANS_START_MASK;
long mask2 = mask << 1;
long prnd = 1;
long prnd2 = prnd << 1;
long nrnd2 = prnd2 - 1;
/*
* do log2n reductions We're indexing a as a 2-D tiledImageOperation
* with dimensions (nx,ny).
*/
int nxtop = nx;
int nytop = ny;
for (int k = 0; k < log2n; k++) {
int oddx = nxtop % 2;
int oddy = nytop % 2;
int i = 0;
for (; i < nxtop - oddx; i += 2) {
int s00 = i * ny; /* s00 is index of a[i,j] */
int s10 = s00 + ny; /* s10 is index of a[i+1,j] */
for (int j = 0; j < nytop - oddy; j += 2) {
/*
* Divide h0,hx,hy,hc by 2 (1 the first time through).
*/
long h0 = a[s10 + 1] + a[s10] + a[s00 + 1] + a[s00] >> shift;
long hx = a[s10 + 1] + a[s10] - a[s00 + 1] - a[s00] >> shift;
long hy = a[s10 + 1] - a[s10] + a[s00 + 1] - a[s00] >> shift;
long hc = a[s10 + 1] - a[s10] - a[s00 + 1] + a[s00] >> shift;
/*
* Throw away the 2 bottom bits of h0, bottom bit of hx,hy.
* To get rounding to be same for positive and negative
* numbers, nrnd2 = prnd2 - 1.
*/
a[s10 + 1] = hc;
a[s10] = (hx >= 0 ? hx + prnd : hx) & mask;
a[s00 + 1] = (hy >= 0 ? hy + prnd : hy) & mask;
a[s00] = (h0 >= 0 ? h0 + prnd2 : h0 + nrnd2) & mask2;
s00 += 2;
s10 += 2;
}
if (oddy != 0) {
/*
* do last element in row if row length is odd s00+1, s10+1
* are off edge
*/
long h0 = a[s10] + a[s00] << 1 - shift;
long hx = a[s10] - a[s00] << 1 - shift;
a[s10] = (hx >= 0 ? hx + prnd : hx) & mask;
a[s00] = (h0 >= 0 ? h0 + prnd2 : h0 + nrnd2) & mask2;
s00 += 1;
s10 += 1;
}
}
if (oddx != 0) {
/*
* do last row if column length is odd s10, s10+1 are off edge
*/
int s00 = i * ny;
for (int j = 0; j < nytop - oddy; j += 2) {
long h0 = a[s00 + 1] + a[s00] << 1 - shift;
long hy = a[s00 + 1] - a[s00] << 1 - shift;
a[s00 + 1] = (hy >= 0 ? hy + prnd : hy) & mask;
a[s00] = (h0 >= 0 ? h0 + prnd2 : h0 + nrnd2) & mask2;
s00 += 2;
}
if (oddy != 0) {
/*
* do corner element if both row and column lengths are odd
* s00+1, s10, s10+1 are off edge
*/
long h0 = a[s00] << 2 - shift;
a[s00] = (h0 >= 0 ? h0 + prnd2 : h0 + nrnd2) & mask2;
}
}
/*
* now shuffle in each dimension to group coefficients by order
*/
// achtung eigenlich pointer nach a
for (i = 0; i < nxtop; i++) {
shuffle(a, ny * i, nytop, 1, tmp);
}
for (int j = 0; j < nytop; j++) {
shuffle(a, j, nxtop, ny, tmp);
}
/*
* image size reduced by 2 (round up if odd)
*/
nxtop = nxtop + 1 >> 1;
nytop = nytop + 1 >> 1;
/*
* divisor doubles after first reduction
*/
shift = 1;
/*
* masks, rounding values double after each iteration
*/
mask = mask2;
prnd = prnd2;
mask2 = mask2 << 1;
prnd2 = prnd2 << 1;
nrnd2 = prnd2 - 1;
}
return 0;
}
private int log2n(int nqmax) {
return (int) (Math.log(nqmax) / Math.log(2.0) + ROUNDING_HALF);
}
private void outputNbits(ByteBuffer outfile, int bits, int n) {
/* AND mask for the right-most n bits */
/*
* insert bits at end of buffer
*/
this.buffer2 <<= n;
/* buffer2 |= ( bits & ((1<> -this.bitsToGo2 & BYTE_MASK));
this.bitsToGo2 += BITS_OF_1_BYTE;
}
}
private void outputNnybble(ByteBuffer outfile, int n, byte[] array) {
/*
* pack the 4 lower bits in each element of the tiledImageOperation into
* the outfile tiledImageOperation
*/
int ii, jj, kk = 0, shift;
if (n == 1) {
outputNybble(outfile, array[0]);
return;
}
/*
* forcing byte alignment doesn;t help, and even makes it go slightly
* slower if (bits_to_go2 != 8) output_nbits(outfile, kk, bits_to_go2);
*/
if (this.bitsToGo2 <= BITS_OF_1_NYBBLE) {
/* just room for 1 nybble; write it out separately */
outputNybble(outfile, array[0]);
kk++; /* index to next tiledImageOperation element */
if (n == 2) {
// only 1 more nybble to write out
outputNybble(outfile, array[1]);
return;
}
}
/* bits_to_go2 is now in the range 5 - 8 */
shift = BITS_OF_1_BYTE - this.bitsToGo2;
/*
* now write out pairs of nybbles; this does not affect value of
* bits_to_go2
*/
jj = (n - kk) / 2;
if (this.bitsToGo2 == BITS_OF_1_BYTE) {
/* special case if nybbles are aligned on byte boundary */
/* this actually seems to make very little difference in speed */
this.buffer2 = 0;
for (ii = 0; ii < jj; ii++) {
outfile.put((byte) ((array[kk] & NYBBLE_MASK) << BITS_OF_1_NYBBLE | array[kk + 1] & NYBBLE_MASK));
kk += 2;
}
} else {
for (ii = 0; ii < jj; ii++) {
this.buffer2 = this.buffer2 << BITS_OF_1_BYTE | (array[kk] & NYBBLE_MASK) << BITS_OF_1_NYBBLE | array[kk + 1] & NYBBLE_MASK;
kk += 2;
/*
* buffer2 full, put out top 8 bits
*/
outfile.put((byte) (this.buffer2 >> shift & BYTE_MASK));
}
}
/* write out last odd nybble, if present */
if (kk != n) {
outputNybble(outfile, array[n - 1]);
}
}
private void outputNybble(ByteBuffer outfile, int bits) {
/*
* insert 4 bits at end of buffer
*/
this.buffer2 = this.buffer2 << BITS_OF_1_NYBBLE | bits & NYBBLE_MASK;
this.bitsToGo2 -= BITS_OF_1_NYBBLE;
if (this.bitsToGo2 <= 0) {
/*
* buffer2 full, put out top 8 bits
*/
outfile.put((byte) (this.buffer2 >> -this.bitsToGo2 & BYTE_MASK));
this.bitsToGo2 += BITS_OF_1_BYTE;
}
}
/**
* macros to write out 4-bit nybble, Huffman code for this value
*/
private int qtreeEncode(ByteBuffer outfile, LongBuffer a, int n, int nqx, int nqy, int nbitplanes) {
/*
* int a[]; int n; physical dimension of row in a int nqx; length of row
* int nqy; length of column (<=n) int nbitplanes; number of bit planes
* to output
*/
int log2n, i, k, bit, b, nqmax, nqx2, nqy2, nx, ny;
long bmax;
byte[] scratch, buffer;
/*
* log2n is log2 of max(nqx,nqy) rounded up to next power of 2
*/
nqmax = nqx > nqy ? nqx : nqy;
log2n = log2n(nqmax);
if (nqmax > 1 << log2n) {
log2n += 1;
}
/*
* initialize buffer point, max buffer size
*/
nqx2 = (nqx + 1) / 2;
nqy2 = (nqy + 1) / 2;
bmax = (nqx2 * nqy2 + 1) / 2;
/*
* We're indexing A as a 2-D tiledImageOperation with dimensions
* (nqx,nqy). Scratch is 2-D with dimensions (nqx/2,nqy/2) rounded up.
* Buffer is used to store string of codes for output.
*/
scratch = new byte[(int) (2 * bmax)];
buffer = new byte[(int) bmax];
/*
* now encode each bit plane, starting with the top
*/
bitplane_done: for (bit = nbitplanes - 1; bit >= 0; bit--) {
/*
* initial bit buffer
*/
b = 0;
this.bitbuffer = 0;
this.bitsToGo3 = 0;
/*
* on first pass copy A to scratch tiledImageOperation
*/
qtreeOnebit(a, n, nqx, nqy, scratch, bit);
nx = nqx + 1 >> 1;
ny = nqy + 1 >> 1;
/*
* copy non-zero values to output buffer, which will be written in
* reverse order
*/
b = bufcopy(scratch, nx * ny, buffer, b, bmax);
if (b >= bmax) {
/*
* quadtree is expanding data, change warning code and just fill
* buffer with bit-map
*/
writeBdirect(outfile, a, n, nqx, nqy, scratch, bit);
continue bitplane_done;
}
/*
* do log2n reductions
*/
for (k = 1; k < log2n; k++) {
qtreeReduce(scratch, ny, nx, ny, scratch);
nx = nx + 1 >> 1;
ny = ny + 1 >> 1;
b = bufcopy(scratch, nx * ny, buffer, b, bmax);
if (b >= bmax) {
writeBdirect(outfile, a, n, nqx, nqy, scratch, bit);
continue bitplane_done;
}
}
/*
* OK, we've got the code in buffer Write quadtree warning code,
* then write buffer in reverse order
*/
outputNybble(outfile, NYBBLE_MASK);
if (b == 0) {
if (this.bitsToGo3 > 0) {
/*
* put out the last few bits
*/
outputNbits(outfile, this.bitbuffer & (1 << this.bitsToGo3) - 1, this.bitsToGo3);
} else {
/*
* have to write a zero nybble if there are no 1's in
* tiledImageOperation
*/
outputNbits(outfile, CODE[0], NCODE[0]);
}
} else {
if (this.bitsToGo3 > 0) {
/*
* put out the last few bits
*/
outputNbits(outfile, this.bitbuffer & (1 << this.bitsToGo3) - 1, this.bitsToGo3);
}
for (i = b - 1; i >= 0; i--) {
outputNbits(outfile, buffer[i], BITS_OF_1_BYTE);
}
}
}
return 0;
}
private void qtreeOnebit(LongBuffer a, int n, int nx, int ny, byte[] b, int bit) {
int i, j, k;
long b0, b1, b2, b3;
int s10, s00;
/*
* use selected bit to get amount to shift
*/
b0 = 1L << bit;
b1 = b0 << 1;
b2 = b1 << 1;
b3 = b2 << 1;
k = 0; /* k is index of b[i/2,j/2] */
for (i = 0; i < nx - 1; i += 2) {
s00 = n * i; /* s00 is index of a[i,j] */
/*
* tried using s00+n directly in the statements, but this had no
* effect on performance
*/
s10 = s00 + n; /* s10 is index of a[i+1,j] */
for (j = 0; j < ny - 1; j += 2) {
b[k] = (byte) ((a.get(s10 + 1) & b0 //
| a.get(s10) << 1 & b1 //
| a.get(s00 + 1) << 2 & b2 //
| a.get(s00) << N3 & b3) >> bit);
k += 1;
s00 += 2;
s10 += 2;
}
if (j < ny) {
/*
* row size is odd, do last element in row s00+1,s10+1 are off
* edge
*/
b[k] = (byte) ((a.get(s10) << 1 & b1 | a.get(s00) << N3 & b3) >> bit);
k += 1;
}
}
if (i < nx) {
/*
* column size is odd, do last row s10,s10+1 are off edge
*/
s00 = n * i;
for (j = 0; j < ny - 1; j += 2) {
b[k] = (byte) ((a.get(s00 + 1) << 2 & b2 | a.get(s00) << N3 & b3) >> bit);
k += 1;
s00 += 2;
}
if (j < ny) {
/*
* both row and column size are odd, do corner element s00+1,
* s10, s10+1 are off edge
*/
b[k] = (byte) ((a.get(s00) << N3 & b3) >> bit);
k += 1;
}
}
}
private void qtreeReduce(byte[] a, int n, int nx, int ny, byte[] b) {
int i, j, k;
int s10, s00;
k = 0; /* k is index of b[i/2,j/2] */
for (i = 0; i < nx - 1; i += 2) {
s00 = n * i; /* s00 is index of a[i,j] */
s10 = s00 + n; /* s10 is index of a[i+1,j] */
for (j = 0; j < ny - 1; j += 2) {
b[k] = (byte) (b2i(a[s10 + 1] != 0) | b2i(a[s10] != 0) << 1 | b2i(a[s00 + 1] != 0) << 2 | b2i(a[s00] != 0) << N3);
k += 1;
s00 += 2;
s10 += 2;
}
if (j < ny) {
/*
* row size is odd, do last element in row s00+1,s10+1 are off
* edge
*/
b[k] = (byte) (b2i(a[s10] != 0) << 1 | b2i(a[s00] != 0) << N3);
k += 1;
}
}
if (i < nx) {
/*
* column size is odd, do last row s10,s10+1 are off edge
*/
s00 = n * i;
for (j = 0; j < ny - 1; j += 2) {
b[k] = (byte) (b2i(a[s00 + 1] != 0) << 2 | b2i(a[s00] != 0) << N3);
k += 1;
s00 += 2;
}
if (j < ny) {
/*
* both row and column size are odd, do corner element s00+1,
* s10, s10+1 are off edge
*/
b[k] = (byte) (b2i(a[s00] != 0) << N3);
k += 1;
}
}
}
private void shuffle(long[] a, int aOffset, int n, int n2, long[] tmp) {
/*
* int a[]; tiledImageOperation to shuffle int n; number of elements to
* shuffle int n2; second dimension int tmp[]; scratch storage
*/
int i;
long[] p1, p2, pt;
int p1Offset;
int ptOffset;
int p2Offset;
/*
* copy odd elements to tmp
*/
pt = tmp;
ptOffset = 0;
p1 = a;
p1Offset = aOffset + n2;
for (i = 1; i < n; i += 2) {
pt[ptOffset] = p1[p1Offset];
ptOffset += 1;
p1Offset += n2 + n2;
}
/*
* compress even elements into first half of A
*/
p1 = a;
p1Offset = aOffset + n2;
p2 = a;
p2Offset = aOffset + n2 + n2;
for (i = 2; i < n; i += 2) {
p1[p1Offset] = p2[p2Offset];
p1Offset += n2;
p2Offset += n2 + n2;
}
/*
* put odd elements into 2nd half
*/
pt = tmp;
ptOffset = 0;
for (i = 1; i < n; i += 2) {
p1[p1Offset] = pt[ptOffset];
p1Offset += n2;
ptOffset += 1;
}
}
private void startOutputtingBits() {
this.buffer2 = 0; /* Buffer is empty to start */
this.bitsToGo2 = BITS_OF_1_BYTE; /* with */
}
private void writeBdirect(ByteBuffer outfile, LongBuffer a, int n, int nqx, int nqy, byte[] scratch, int bit) {
/*
* Write the direct bitmap warning code
*/
outputNybble(outfile, 0x0);
/*
* Copy A to scratch tiledImageOperation (again!), packing 4 bits/nybble
*/
qtreeOnebit(a, n, nqx, nqy, scratch, bit);
/*
* write to outfile
*/
/*
* int i; for (i = 0; i < ((nqx+1)/2) * ((nqy+1)/2); i++) {
* output_nybble(outfile,scratch[i]); }
*/
outputNnybble(outfile, (nqx + 1) / 2 * ((nqy + 1) / 2), scratch);
}
}
nom/tam/fits/compression/algorithm/hcompress/HCompressorQuantizeOption.java 0000664 0000000 0000000 00000005262 12755570700 026465 0 ustar root root package nom.tam.fits.compression.algorithm.hcompress;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2016 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import nom.tam.fits.compression.algorithm.quant.QuantizeOption;
import nom.tam.fits.compression.provider.param.hcompress.HCompressQuantizeParameters;
public class HCompressorQuantizeOption extends QuantizeOption {
private HCompressorOption hCompressorOption = new HCompressorOption();
public HCompressorQuantizeOption() {
super();
this.parameters = new HCompressQuantizeParameters(this);
}
@Override
public HCompressorQuantizeOption copy() {
HCompressorQuantizeOption copy = (HCompressorQuantizeOption) super.copy();
copy.hCompressorOption = this.hCompressorOption.copy();
return copy;
}
public HCompressorOption getHCompressorOption() {
return this.hCompressorOption;
}
@Override
public HCompressorQuantizeOption setTileHeight(int value) {
super.setTileHeight(value);
this.hCompressorOption.setTileHeight(value);
return this;
}
@Override
public HCompressorQuantizeOption setTileWidth(int value) {
super.setTileWidth(value);
this.hCompressorOption.setTileWidth(value);
return this;
}
@Override
public T unwrap(Class clazz) {
T result = super.unwrap(clazz);
if (result == null) {
return this.hCompressorOption.unwrap(clazz);
}
return result;
}
}
nom/tam/fits/compression/algorithm/hcompress/HCompressorOption.java 0000664 0000000 0000000 00000006660 12755570700 024747 0 ustar root root package nom.tam.fits.compression.algorithm.hcompress;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import nom.tam.fits.compression.algorithm.api.ICompressOption;
import nom.tam.fits.compression.provider.param.api.ICompressParameters;
public class HCompressorOption implements ICompressOption {
/**
* circular dependency, has to be cut.
*/
private ICompressParameters parameters;
private int scale;
private boolean smooth;
private int tileHeight;
private int tileWidth;
@Override
public HCompressorOption copy() {
try {
return ((HCompressorOption) clone()).setOriginal(this);
} catch (CloneNotSupportedException e) {
throw new IllegalStateException("option could not be cloned", e);
}
}
@Override
public ICompressParameters getCompressionParameters() {
return this.parameters;
}
public int getScale() {
return this.scale;
}
public int getTileHeight() {
return this.tileHeight;
}
public int getTileWidth() {
return this.tileWidth;
}
@Override
public boolean isLossyCompression() {
return this.scale > 1 || this.smooth;
}
public boolean isSmooth() {
return this.smooth;
}
@Override
public void setParameters(ICompressParameters parameters) {
this.parameters = parameters;
}
public HCompressorOption setScale(int value) {
this.scale = value;
return this;
}
public HCompressorOption setSmooth(boolean value) {
this.smooth = value;
return this;
}
@Override
public HCompressorOption setTileHeight(int value) {
this.tileHeight = value;
return this;
}
@Override
public HCompressorOption setTileWidth(int value) {
this.tileWidth = value;
return this;
}
@Override
public T unwrap(Class clazz) {
if (clazz.isAssignableFrom(this.getClass())) {
return clazz.cast(this);
}
return null;
}
private HCompressorOption setOriginal(HCompressorOption hCompressorOption) {
this.parameters = this.parameters.copy(this);
return this;
}
}
nom/tam/fits/compression/algorithm/quant/ 0000775 0000000 0000000 00000000000 12755570706 017572 5 ustar root root nom/tam/fits/compression/algorithm/quant/QuantizeOption.java 0000664 0000000 0000000 00000016216 12755570700 023426 0 ustar root root package nom.tam.fits.compression.algorithm.quant;
import nom.tam.fits.compression.algorithm.api.ICompressOption;
import nom.tam.fits.compression.provider.param.api.ICompressParameters;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
public class QuantizeOption implements ICompressOption {
/**
* and including NULL_VALUE. These values may not be used to represent the
* quantized and scaled floating point pixel values If lossy Hcompression is
* used, and the tiledImageOperation contains null values, then it is also
* possible for the compressed values to slightly exceed the range of the
* actual (lossless) values so we must reserve a little more space value
* used to represent undefined pixels
*/
private static final int NULL_VALUE = Integer.MIN_VALUE + 1;
protected ICompressParameters parameters;
private double bScale = Double.NaN;
private double bZero = Double.NaN;
private boolean centerOnZero;
private boolean checkNull;
private boolean checkZero;
private boolean dither;
private boolean dither2;
private int intMaxValue;
private int intMinValue;
private double maxValue;
private double minValue;
private double nullValue = Double.NaN;
private Integer nullValueIndicator;
private double qlevel = Double.NaN;
private long seed = 1L;
private int tileHeight;
private int tileWidth;
private QuantizeOption original;
@Override
public QuantizeOption copy() {
try {
return ((QuantizeOption) clone()).setOriginal(this);
} catch (CloneNotSupportedException e) {
throw new IllegalStateException("option could not be cloned", e);
}
}
public Integer getBNull() {
return this.nullValueIndicator;
}
public double getBScale() {
return this.bScale;
}
public double getBZero() {
return this.bZero;
}
@Override
public ICompressParameters getCompressionParameters() {
return this.parameters;
}
public T getCompressOption(Class clazz) {
return unwrap(clazz);
}
public int getIntMaxValue() {
return this.intMaxValue;
}
public int getIntMinValue() {
return this.intMinValue;
}
public double getMaxValue() {
return this.maxValue;
}
public double getMinValue() {
return this.minValue;
}
public double getNullValue() {
return this.nullValue;
}
public Integer getNullValueIndicator() {
return this.nullValueIndicator;
}
public QuantizeOption getOriginal() {
return this.original;
}
public double getQLevel() {
return this.qlevel;
}
public long getSeed() {
return this.seed;
}
public int getTileHeight() {
return this.tileHeight;
}
public int getTileWidth() {
return this.tileWidth;
}
public boolean isCenterOnZero() {
return this.centerOnZero;
}
public boolean isCheckNull() {
return this.checkNull;
}
public boolean isCheckZero() {
return this.checkZero;
}
public boolean isDither() {
return this.dither;
}
public boolean isDither2() {
return this.dither2;
}
@Override
public boolean isLossyCompression() {
return true;
}
public ICompressOption setBNull(Integer blank) {
if (blank != null) {
this.checkNull = true;
this.nullValueIndicator = blank;
}
return this;
}
public QuantizeOption setBScale(double value) {
this.bScale = value;
return this;
}
public QuantizeOption setBZero(double value) {
this.bZero = value;
return this;
}
public QuantizeOption setCenterOnZero(boolean value) {
this.centerOnZero = value;
return this;
}
public QuantizeOption setCheckNull(boolean value) {
this.checkNull = value;
if (this.nullValueIndicator == null) {
this.nullValueIndicator = NULL_VALUE;
}
return this;
}
public QuantizeOption setCheckZero(boolean value) {
this.checkZero = value;
return this;
}
public QuantizeOption setDither(boolean value) {
this.dither = value;
return this;
}
public QuantizeOption setDither2(boolean value) {
this.dither2 = value;
return this;
}
public QuantizeOption setIntMaxValue(int value) {
this.intMaxValue = value;
return this;
}
public QuantizeOption setIntMinValue(int value) {
this.intMinValue = value;
return this;
}
public QuantizeOption setMaxValue(double value) {
this.maxValue = value;
return this;
}
public QuantizeOption setMinValue(double value) {
this.minValue = value;
return this;
}
public QuantizeOption setNullValue(double value) {
this.nullValue = value;
return this;
}
@Override
public void setParameters(ICompressParameters parameters) {
this.parameters = parameters;
}
public QuantizeOption setQlevel(double value) {
this.qlevel = value;
return this;
}
public QuantizeOption setSeed(long value) {
this.seed = value;
return this;
}
@Override
public QuantizeOption setTileHeight(int value) {
this.tileHeight = value;
return this;
}
@Override
public QuantizeOption setTileWidth(int value) {
this.tileWidth = value;
return this;
}
@Override
public T unwrap(Class clazz) {
if (clazz.isAssignableFrom(this.getClass())) {
return clazz.cast(this);
}
return null;
}
private QuantizeOption setOriginal(QuantizeOption quantizeOption) {
this.original = quantizeOption;
this.parameters = this.parameters.copy(this);
return this;
}
}
nom/tam/fits/compression/algorithm/quant/Quantize.java 0000664 0000000 0000000 00000046131 12755570700 022234 0 ustar root root package nom.tam.fits.compression.algorithm.quant;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.util.Arrays;
public class Quantize {
class DoubleArrayPointer {
private final double[] array;
private int startIndex;
DoubleArrayPointer(double[] arrayIn) {
this.array = arrayIn;
}
public DoubleArrayPointer copy(long l) {
DoubleArrayPointer result = new DoubleArrayPointer(this.array);
result.startIndex = (int) l;
return result;
}
public double get(int ii) {
return this.array[ii + this.startIndex];
}
}
private static final double DEFAULT_QUANT_LEVEL = 4.;
private static final double MAX_INT_AS_DOUBLE = Integer.MAX_VALUE;
private static final int MINIMUM_PIXEL_WIDTH = 9;
/**
* number of reserved values, starting with
*/
private static final long N_RESERVED_VALUES = 10;
private static final int N4 = 4;
private static final int N6 = 6;
private static final double NOISE_2_MULTIPLICATOR = 1.0483579;
private static final double NOISE_3_MULTIPLICATOR = 0.6052697;
private static final double NOISE_5_MULTIPLICATOR = 0.1772048;
private final QuantizeOption parameter;
/**
* maximum non-null value
*/
private double maxValue;
/**
* minimum non-null value
*/
private double minValue;
/**
* number of good, non-null pixels?
*/
private long ngood;
/**
* returned 2nd order MAD of all non-null pixels
*/
private double noise2;
/**
* returned 3rd order MAD of all non-null pixels
*/
private double noise3;
/* returned 5th order MAD of all non-null pixels */
private double noise5;
private double xmaxval;
private double xminval;
private double xnoise2;
private double xnoise3;
private double xnoise5;
public Quantize(QuantizeOption quantizeOption) {
this.parameter = quantizeOption;
}
/**
* Estimate the median and background noise in the input image using 2nd,
* 3rd and 5th order Median Absolute Differences. The noise in the
* background of the image is calculated using the MAD algorithms developed
* for deriving the signal to noise ratio in spectra (see issue #42 of the
* ST-ECF newsletter, http://www.stecf.org/documents/newsletter/) 3rd order:
* noise = 1.482602 / sqrt(6) * median (abs(2*flux(i) - flux(i-2) -
* flux(i+2))) The returned estimates are the median of the values that are
* computed for each row of the image.
*
* @param arrayIn
* 2 dimensional tiledImageOperation of image pixels
* @param nx
* number of pixels in each row of the image
* @param ny
* number of rows in the image
* @param nullcheck
* check for null values, if true
* @param nullvalue
* value of null pixels, if nullcheck is true
* @return error status
*/
private void calculateNoise(double[] arrayIn, int nx, int ny) {
DoubleArrayPointer array = new DoubleArrayPointer(arrayIn);
initializeNoise();
if (nx < MINIMUM_PIXEL_WIDTH) {
// treat entire tiledImageOperation as an image with a single row
nx = nx * ny;
ny = 1;
}
if (calculateNoiseShortRow(array, nx, ny)) {
return;
}
DoubleArrayPointer rowpix;
int nrows = 0, nrows2 = 0;
long ngoodpix = 0;
/* allocate arrays used to compute the median and noise estimates */
double[] differences2 = new double[nx];
double[] differences3 = new double[nx];
double[] differences5 = new double[nx];
double[] diffs2 = new double[ny];
double[] diffs3 = new double[ny];
double[] diffs5 = new double[ny];
/* loop over each row of the image */
for (int jj = 0; jj < ny; jj++) {
rowpix = array.copy(jj * nx); /* point to first pixel in the row */
int ii = 0;
ii = findNextValidPixelWithNullCheck(nx, rowpix, ii);
if (ii == nx) {
continue; /* hit end of row */
}
double v1 = getNextPixelAndCheckMinMax(rowpix, ii);
ngoodpix++;
ii = findNextValidPixelWithNullCheck(nx, rowpix, ++ii);
if (ii == nx) {
continue; /* hit end of row */
}
double v2 = getNextPixelAndCheckMinMax(rowpix, ii);
ngoodpix++;
ii = findNextValidPixelWithNullCheck(nx, rowpix, ++ii);
if (ii == nx) {
continue; /* hit end of row */
}
double v3 = getNextPixelAndCheckMinMax(rowpix, ii);
ngoodpix++;
ii = findNextValidPixelWithNullCheck(nx, rowpix, ++ii);
if (ii == nx) {
continue; /* hit end of row */
}
double v4 = getNextPixelAndCheckMinMax(rowpix, ii);
ngoodpix++;
ii = findNextValidPixelWithNullCheck(nx, rowpix, ++ii);
if (ii == nx) {
continue; /* hit end of row */
}
double v5 = getNextPixelAndCheckMinMax(rowpix, ii);
ngoodpix++;
ii = findNextValidPixelWithNullCheck(nx, rowpix, ++ii);
if (ii == nx) {
continue; /* hit end of row */
}
double v6 = getNextPixelAndCheckMinMax(rowpix, ii);
ngoodpix++;
ii = findNextValidPixelWithNullCheck(nx, rowpix, ++ii);
if (ii == nx) {
continue; /* hit end of row */
}
double v7 = getNextPixelAndCheckMinMax(rowpix, ii);
ngoodpix++;
ii = findNextValidPixelWithNullCheck(nx, rowpix, ++ii);
if (ii == nx) {
continue; /* hit end of row */
}
double v8 = getNextPixelAndCheckMinMax(rowpix, ii);
ngoodpix++;
// now populate the differences arrays for the remaining pixels in
// the row */
int nvals = 0;
int nvals2 = 0;
for (ii++; ii < nx; ii++) {
ii = findNextValidPixelWithNullCheck(nx, rowpix, ii);
if (ii == nx) {
continue; /* hit end of row */
}
double v9 = getNextPixelAndCheckMinMax(rowpix, ii);
/* construct tiledImageOperation of absolute differences */
if (!(v5 == v6 && v6 == v7)) {
differences2[nvals2] = Math.abs(v5 - v7);
nvals2++;
}
if (!(v3 == v4 && v4 == v5 && v5 == v6 && v6 == v7)) {
differences3[nvals] = Math.abs(2 * v5 - v3 - v7);
differences5[nvals] = Math.abs(N6 * v5 - N4 * v3 - N4 * v7 + v1 + v9);
nvals++;
} else {
/* ignore constant background regions */
ngoodpix++;
}
/* shift over 1 pixel */
v1 = v2;
v2 = v3;
v3 = v4;
v4 = v5;
v5 = v6;
v6 = v7;
v7 = v8;
v8 = v9;
} /* end of loop over pixels in the row */
// compute the median diffs Note that there are 8 more pixel values
// than there are diffs values.
ngoodpix += nvals;
if (nvals == 0) {
continue; /* cannot compute medians on this row */
} else if (nvals == 1) {
if (nvals2 == 1) {
diffs2[nrows2] = differences2[0];
nrows2++;
}
diffs3[nrows] = differences3[0];
diffs5[nrows] = differences5[0];
} else {
/* quick_select returns the median MUCH faster than using qsort */
if (nvals2 > 1) {
diffs2[nrows2] = quickSelect(differences2, nvals);
nrows2++;
}
diffs3[nrows] = quickSelect(differences3, nvals);
diffs5[nrows] = quickSelect(differences5, nvals);
}
nrows++;
} /* end of loop over rows */
computeMedianOfValuesEachRow(nrows, nrows2, diffs2, diffs3, diffs5);
setNoiseResult(ngoodpix);
}
private boolean calculateNoiseShortRow(DoubleArrayPointer array, int nx, int ny) {
/* rows must have at least 9 pixels */
if (nx < MINIMUM_PIXEL_WIDTH) {
int ngoodpix = 0;
for (int index = 0; index < nx; index++) {
if (isNull(array.get(index))) {
continue;
} else {
if (array.get(index) < this.xminval) {
this.xminval = array.get(index);
}
if (array.get(index) > this.xmaxval) {
this.xmaxval = array.get(index);
}
ngoodpix++;
}
}
setNoiseResult(ngoodpix);
return true;
}
return false;
}
protected void computeMedianOfValuesEachRow(int nrows, int nrows2, double[] diffs2, double[] diffs3, double[] diffs5) {
// compute median of the values for each row.
if (nrows == 0) {
this.xnoise3 = 0;
this.xnoise5 = 0;
} else if (nrows == 1) {
this.xnoise3 = diffs3[0];
this.xnoise5 = diffs5[0];
} else {
Arrays.sort(diffs3, 0, nrows);
Arrays.sort(diffs5, 0, nrows);
this.xnoise3 = (diffs3[(nrows - 1) / 2] + diffs3[nrows / 2]) / 2.;
this.xnoise5 = (diffs5[(nrows - 1) / 2] + diffs5[nrows / 2]) / 2.;
}
if (nrows2 == 0) {
this.xnoise2 = 0;
} else if (nrows2 == 1) {
this.xnoise2 = diffs2[0];
} else {
Arrays.sort(diffs2, 0, nrows2);
this.xnoise2 = (diffs2[(nrows2 - 1) / 2] + diffs2[nrows2 / 2]) / 2.;
}
}
protected int findNextValidPixelWithNullCheck(int nx, DoubleArrayPointer rowpix, int ii) {
return ii;
}
private double getNextPixelAndCheckMinMax(DoubleArrayPointer rowpix, int ii) {
double pixelValue = rowpix.get(ii); /* store the good pixel value */
if (pixelValue < this.xminval) {
this.xminval = pixelValue;
}
if (pixelValue > this.xmaxval) {
this.xmaxval = pixelValue;
}
return pixelValue;
}
protected double getNoise2() {
return this.noise2;
}
protected double getNoise3() {
return this.noise3;
}
protected double getNoise5() {
return this.noise5;
}
private void initializeNoise() {
this.xnoise2 = 0;
this.xnoise3 = 0;
this.xnoise5 = 0;
this.xminval = Double.MAX_VALUE;
this.xmaxval = Double.MIN_VALUE;
}
protected boolean isNull(double d) {
return false;
}
/**
* arguments: long row i: tile number = row number in the binary table
* double fdata[] i: tiledImageOperation of image pixels to be compressed
* long nxpix i: number of pixels in each row of fdata long nypix i: number
* of rows in fdata nullcheck i: check for nullvalues in fdata? double
* in_null_value i: value used to represent undefined pixels in fdata float
* qlevel i: quantization level int dither_method i; which dithering method
* to use int idata[] o: values of fdata after applying bzero and bscale
* double bscale o: scale factor double bzero o: zero offset int iminval o:
* minimum quantized value that is returned int imaxval o: maximum quantized
* value that is returned The function value will be one if the input fdata
* were copied to idata; in this case the parameters bscale and bzero can be
* used to convert back to nearly the original floating point values: fdata
* ~= idata * bscale + bzero. If the function value is zero, the data were
* not copied to idata.
*
* In earlier implementations of the compression code, we only used the
* noise3 value as the most reliable estimate of the background noise in an
* image. If it is not possible to compute a noise3 value, then this serves
* as a red flag to indicate that quantizing the image could cause a loss of
* significant information in the image.
*
*
* At some later date, we decided to take the more conservative approach of
* using the minimum of all three of the noise values (while still requiring
* that noise3 has a defined value) as the best estimate of the noise. Note
* that if an image contains pure Gaussian distributed noise, then noise2,
* noise3, and noise5 will have exactly the same value (within statistical
* measurement errors).
*
*
* @param fdata
* the data to quantinize
* @param nxpix
* the image width
* @param nypix
* the image hight
* @return true if the quantification was possible
*/
public boolean quantize(double[] fdata, int nxpix, int nypix) {
// MAD 2nd, 3rd, and 5th order noise values
double stdev;
double bScale; /* bscale, 1 in intdata = delta in fdata */
long nx = (long) nxpix * (long) nypix;
if (nx <= 1L) {
this.parameter.setBScale(1.);
this.parameter.setBZero(0.);
return false;
}
if (this.parameter.getQLevel() >= 0.) {
/* estimate background noise using MAD pixel differences */
calculateNoise(fdata, nxpix, nypix);
// special case of an image filled with Nulls
if (this.parameter.isCheckNull() && this.ngood == 0) {
/* set parameters to dummy values, which are not used */
this.minValue = 0.;
this.maxValue = 1.;
stdev = 1;
} else {
// use the minimum of noise2, noise3, and noise5 as the best
// noise value
stdev = this.noise3;
if (this.noise2 != 0. && this.noise2 < stdev) {
stdev = this.noise2;
}
if (this.noise5 != 0. && this.noise5 < stdev) {
stdev = this.noise5;
}
}
if (this.parameter.getQLevel() == 0.) {
bScale = stdev / DEFAULT_QUANT_LEVEL; /* default quantization */
} else {
bScale = stdev / this.parameter.getQLevel();
}
if (bScale == 0.) {
return false; /* don't quantize */
}
} else {
/* negative value represents the absolute quantization level */
bScale = -this.parameter.getQLevel();
/* only nned to calculate the min and max values */
calculateNoise(fdata, nxpix, nypix);
}
/* check that the range of quantized levels is not > range of int */
if ((this.maxValue - this.minValue) / bScale > 2. * MAX_INT_AS_DOUBLE - N_RESERVED_VALUES) {
return false; /* don't quantize */
}
this.parameter.setBScale(bScale);
this.parameter.setMinValue(this.minValue);
this.parameter.setMaxValue(this.maxValue);
this.parameter.setCheckNull(this.parameter.isCheckNull() && this.ngood != nx);
return true; /* yes, data have been quantized */
}
private double quickSelect(double[] arr, int n) {
int low, high;
int median;
int middle, ll, hh;
low = 0;
high = n - 1;
median = low + high >>> 1; // was (low + high) / 2;
for (;;) {
if (high <= low) {
return arr[median];
}
if (high == low + 1) { /* Two elements only */
if (arr[low] > arr[high]) {
swapElements(arr, low, high);
}
return arr[median];
}
/* Find median of low, middle and high items; swap into position low */
middle = low + high >>> 1; // was (low + high) / 2;
if (arr[middle] > arr[high]) {
swapElements(arr, middle, high);
}
if (arr[low] > arr[high]) {
swapElements(arr, low, high);
}
if (arr[middle] > arr[low]) {
swapElements(arr, middle, low);
}
/* Swap low item (now in position middle) into position (low+1) */
swapElements(arr, middle, low + 1);
/* Nibble from each end towards middle, swapping items when stuck */
ll = low + 1;
hh = high;
for (;;) {
do {
ll++;
} while (arr[low] > arr[ll]);
do {
hh--;
} while (arr[hh] > arr[low]);
if (hh < ll) {
break;
}
swapElements(arr, ll, hh);
}
/* Swap middle item (in position low) back into correct position */
swapElements(arr, low, hh);
/* Re-set active partition */
if (hh <= median) {
low = ll;
}
if (hh >= median) {
high = hh - 1;
}
}
}
private void setNoiseResult(long ngoodpix) {
this.minValue = this.xminval;
this.maxValue = this.xmaxval;
this.ngood = ngoodpix;
this.noise2 = NOISE_2_MULTIPLICATOR * this.xnoise2;
this.noise3 = NOISE_3_MULTIPLICATOR * this.xnoise3;
this.noise5 = NOISE_5_MULTIPLICATOR * this.xnoise5;
}
private void swapElements(double[] array, int one, int second) {
double value = array[one];
array[one] = array[second];
array[second] = value;
}
}
nom/tam/fits/compression/algorithm/quant/QuantizeProcessor.java 0000664 0000000 0000000 00000037544 12755570700 024144 0 ustar root root package nom.tam.fits.compression.algorithm.quant;
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2015 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* #L%
*/
import java.nio.ByteBuffer;
import java.nio.DoubleBuffer;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import nom.tam.fits.compression.algorithm.api.ICompressor;
public class QuantizeProcessor {
public static class DoubleQuantCompressor extends QuantizeProcessor implements ICompressor {
private final ICompressor