/*--------------------------------------------------------------------------*/
int ffgpxf( fitsfile *fptr, /* I - FITS file pointer */
int datatype, /* I - datatype of the value */
long *firstpix, /* I - coord of first pixel to read (1s based) */
LONGLONG nelem, /* I - number of values to read */
void *array, /* O - array of values that are returned */
char *nullarray, /* O - returned array of null value flags */
int *anynul, /* O - set to 1 if any values are null; else 0 */
int *status) /* IO - error status */
/*
Read an array of values from the primary array. The datatype of the
input array is defined by the 2nd argument. Data conversion
and scaling will be performed if necessary (e.g, if the datatype of
the FITS array is not the same as the array being read).
The nullarray values will = 1 if the corresponding array value is null.
ANYNUL is returned with a value of .true. if any pixels are undefined.
*/
{
LONGLONG tfirstpix[99];
int naxis, ii;
if (*status > 0 || nelem == 0) /* inherit input status value if > 0 */
return(*status);
/* get the size of the image */
ffgidm(fptr, &naxis, status);
for (ii=0; ii < naxis; ii++)
tfirstpix[ii] = firstpix[ii];
ffgpxfll(fptr, datatype, tfirstpix, nelem, array, nullarray, anynul, status);
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffppx( fitsfile *fptr, /* I - FITS file pointer */
int datatype, /* I - datatype of the value */
long *firstpix, /* I - coord of first pixel to write(1 based) */
long nelem, /* I - number of values to write */
void *array, /* I - array of values that are written */
int *status) /* IO - error status */
/*
Write an array of pixels to the primary array. The datatype of the
input array is defined by the 2nd argument. Data conversion
and scaling will be performed if necessary (e.g, if the datatype of
the FITS array is not the same as the array being written). This routine
is simillar to ffppr, except it supports writing large images with
more than 2.1E9 pixels.
*/
{
int naxis, ii;
long naxes[9], firstelem, row = 1;
OFF_T dimsize = 1;
if (*status > 0) /* inherit input status value if > 0 */
return(*status);
/* get the size of the image */
ffgidm(fptr, &naxis, status);
ffgisz(fptr, 9, naxes, status);
/* store the actual first element value in a external variable */
/* because we can't pass the value directly to the lower routine */
/* because the parameter is declared as 'long' instead of 'off_t'. */
large_first_elem_val = 0;
for (ii=0; ii < naxis; ii++)
{
large_first_elem_val += ((firstpix[ii] - 1) * dimsize);
dimsize *= naxes[ii];
}
large_first_elem_val++;
firstelem = USE_LARGE_VALUE; /* special flag value */
/*
the primary array is represented as a binary table:
each group of the primary array is a row in the table,
where the first column contains the group parameters
and the second column contains the image itself.
*/
if (datatype == TBYTE)
{
ffpclb(fptr, 2, row, firstelem, nelem, (unsigned char *) array, status);
}
else if (datatype == TUSHORT)
{
ffpclui(fptr, 2, row, firstelem, nelem, (unsigned short *) array,
status);
}
else if (datatype == TSHORT)
{
ffpcli(fptr, 2, row, firstelem, nelem, (short *) array, status);
}
else if (datatype == TUINT)
{
ffpcluk(fptr, 2, row, firstelem, nelem, (unsigned int *) array, status);
}
else if (datatype == TINT)
{
ffpclk(fptr, 2, row, firstelem, nelem, (int *) array, status);
}
else if (datatype == TULONG)
{
ffpcluj(fptr, 2, row, firstelem, nelem, (unsigned long *) array, status);
}
else if (datatype == TLONG)
{
ffpclj(fptr, 2, row, firstelem, nelem, (long *) array, status);
}
else if (datatype == TFLOAT)
{
ffpcle(fptr, 2, row, firstelem, nelem, (float *) array, status);
}
else if (datatype == TDOUBLE)
{
ffpcld(fptr, 2, row, firstelem, nelem, (double *) array, status);
}
else
*status = BAD_DATATYPE;
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgpxvll( fitsfile *fptr, /* I - FITS file pointer */
int datatype, /* I - datatype of the value */
LONGLONG *firstpix, /* I - coord of first pixel to read (1s based) */
LONGLONG nelem, /* I - number of values to read */
void *nulval, /* I - value for undefined pixels */
void *array, /* O - array of values that are returned */
int *anynul, /* O - set to 1 if any values are null; else 0 */
int *status) /* IO - error status */
/*
Read an array of values from the primary array. The datatype of the
input array is defined by the 2nd argument. Data conversion
and scaling will be performed if necessary (e.g, if the datatype of
the FITS array is not the same as the array being read).
Undefined elements will be set equal to NULVAL, unless NULVAL=0
in which case no checking for undefined values will be performed.
ANYNUL is returned with a value of .true. if any pixels are undefined.
*/
{
int naxis, ii;
char cdummy;
int nullcheck = 1;
LONGLONG naxes[9], trc[9]= {1,1,1,1,1,1,1,1,1};
long inc[9]= {1,1,1,1,1,1,1,1,1};
LONGLONG dimsize = 1, firstelem;
if (*status > 0 || nelem == 0) /* inherit input status value if > 0 */
return(*status);
/* get the size of the image */
ffgidm(fptr, &naxis, status);
ffgiszll(fptr, 9, naxes, status);
if (naxis == 0 || naxes[0] == 0) {
*status = BAD_DIMEN;
return(*status);
}
/* calculate the position of the first element in the array */
firstelem = 0;
for (ii=0; ii < naxis; ii++)
{
firstelem += ((firstpix[ii] - 1) * dimsize);
dimsize *= naxes[ii];
trc[ii] = firstpix[ii];
}
firstelem++;
if (fits_is_compressed_image(fptr, status))
{
/* this is a compressed image in a binary table */
/* test for special case of reading an integral number of */
/* rows in a 2D or 3D image (which includes reading the whole image */
if (naxis > 1 && naxis < 4 && firstpix[0] == 1 &&
(nelem / naxes[0]) * naxes[0] == nelem) {
/* calculate coordinate of last pixel */
trc[0] = naxes[0]; /* reading whole rows */
trc[1] = firstpix[1] + (nelem / naxes[0] - 1);
while (trc[1] > naxes[1]) {
trc[1] = trc[1] - naxes[1];
trc[2] = trc[2] + 1; /* increment to next plane of cube */
}
fits_read_compressed_img(fptr, datatype, firstpix, trc, inc,
1, nulval, array, NULL, anynul, status);
} else {
fits_read_compressed_pixels(fptr, datatype, firstelem,
nelem, nullcheck, nulval, array, NULL, anynul, status);
}
return(*status);
}
/*
the primary array is represented as a binary table:
each group of the primary array is a row in the table,
where the first column contains the group parameters
and the second column contains the image itself.
*/
if (datatype == TBYTE)
{
if (nulval == 0)
ffgclb(fptr, 2, 1, firstelem, nelem, 1, 1, 0,
(unsigned char *) array, &cdummy, anynul, status);
else
ffgclb(fptr, 2, 1, firstelem, nelem, 1, 1, *(unsigned char *) nulval,
(unsigned char *) array, &cdummy, anynul, status);
}
else if (datatype == TSBYTE)
{
if (nulval == 0)
ffgclsb(fptr, 2, 1, firstelem, nelem, 1, 1, 0,
(signed char *) array, &cdummy, anynul, status);
else
ffgclsb(fptr, 2, 1, firstelem, nelem, 1, 1, *(signed char *) nulval,
(signed char *) array, &cdummy, anynul, status);
}
else if (datatype == TUSHORT)
{
if (nulval == 0)
ffgclui(fptr, 2, 1, firstelem, nelem, 1, 1, 0,
(unsigned short *) array, &cdummy, anynul, status);
else
ffgclui(fptr, 2, 1, firstelem, nelem, 1, 1, *(unsigned short *) nulval,
(unsigned short *) array, &cdummy, anynul, status);
}
else if (datatype == TSHORT)
{
if (nulval == 0)
ffgcli(fptr, 2, 1, firstelem, nelem, 1, 1, 0,
(short *) array, &cdummy, anynul, status);
else
ffgcli(fptr, 2, 1, firstelem, nelem, 1, 1, *(short *) nulval,
(short *) array, &cdummy, anynul, status);
}
else if (datatype == TUINT)
{
if (nulval == 0)
ffgcluk(fptr, 2, 1, firstelem, nelem, 1, 1, 0,
(unsigned int *) array, &cdummy, anynul, status);
else
ffgcluk(fptr, 2, 1, firstelem, nelem, 1, 1, *(unsigned int *) nulval,
(unsigned int *) array, &cdummy, anynul, status);
}
else if (datatype == TINT)
{
if (nulval == 0)
ffgclk(fptr, 2, 1, firstelem, nelem, 1, 1, 0,
(int *) array, &cdummy, anynul, status);
else
ffgclk(fptr, 2, 1, firstelem, nelem, 1, 1, *(int *) nulval,
(int *) array, &cdummy, anynul, status);
}
else if (datatype == TULONG)
{
if (nulval == 0)
ffgcluj(fptr, 2, 1, firstelem, nelem, 1, 1, 0,
(unsigned long *) array, &cdummy, anynul, status);
else
ffgcluj(fptr, 2, 1, firstelem, nelem, 1, 1, *(unsigned long *) nulval,
(unsigned long *) array, &cdummy, anynul, status);
}
else if (datatype == TLONG)
{
if (nulval == 0)
ffgclj(fptr, 2, 1, firstelem, nelem, 1, 1, 0,
(long *) array, &cdummy, anynul, status);
else
ffgclj(fptr, 2, 1, firstelem, nelem, 1, 1, *(long *) nulval,
(long *) array, &cdummy, anynul, status);
}
else if (datatype == TLONGLONG)
{
if (nulval == 0)
ffgcljj(fptr, 2, 1, firstelem, nelem, 1, 1, 0,
(LONGLONG *) array, &cdummy, anynul, status);
else
ffgcljj(fptr, 2, 1, firstelem, nelem, 1, 1, *(LONGLONG *) nulval,
(LONGLONG *) array, &cdummy, anynul, status);
}
else if (datatype == TFLOAT)
{
if (nulval == 0)
ffgcle(fptr, 2, 1, firstelem, nelem, 1, 1, 0,
(float *) array, &cdummy, anynul, status);
else
ffgcle(fptr, 2, 1, firstelem, nelem, 1, 1, *(float *) nulval,
(float *) array, &cdummy, anynul, status);
}
else if (datatype == TDOUBLE)
{
if (nulval == 0)
ffgcld(fptr, 2, 1, firstelem, nelem, 1, 1, 0,
(double *) array, &cdummy, anynul, status);
else
ffgcld(fptr, 2, 1, firstelem, nelem, 1, 1, *(double *) nulval,
(double *) array, &cdummy, anynul, status);
}
else
*status = BAD_DATATYPE;
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgsv( fitsfile *fptr, /* I - FITS file pointer */
int datatype, /* I - datatype of the value */
long *blc, /* I - 'bottom left corner' of the subsection */
long *trc , /* I - 'top right corner' of the subsection */
long *inc, /* I - increment to be applied in each dim. */
void *nulval, /* I - value for undefined pixels */
void *array, /* O - array of values that are returned */
int *anynul, /* O - set to 1 if any values are null; else 0 */
int *status) /* IO - error status */
/*
Read an section of values from the primary array. The datatype of the
input array is defined by the 2nd argument. Data conversion
and scaling will be performed if necessary (e.g, if the datatype of
the FITS array is not the same as the array being read).
Undefined elements will be set equal to NULVAL, unless NULVAL=0
in which case no checking for undefined values will be performed.
ANYNUL is returned with a value of .true. if any pixels are undefined.
*/
{
int naxis, ii;
long naxes[9];
LONGLONG nelem = 1;
if (*status > 0) /* inherit input status value if > 0 */
return(*status);
/* get the size of the image */
ffgidm(fptr, &naxis, status);
ffgisz(fptr, 9, naxes, status);
/* test for the important special case where we are reading the whole image */
/* this is only useful for images that are not tile-compressed */
if (!fits_is_compressed_image(fptr, status)) {
for (ii = 0; ii < naxis; ii++) {
if (inc[ii] != 1 || blc[ii] !=1 || trc[ii] != naxes[ii])
break;
nelem = nelem * naxes[ii];
}
if (ii == naxis) {
/* read the whole image more efficiently */
ffgpxv(fptr, datatype, blc, nelem, nulval, array, anynul, status);
return(*status);
}
}
if (datatype == TBYTE)
{
if (nulval == 0)
ffgsvb(fptr, 1, naxis, naxes, blc, trc, inc, 0,
(unsigned char *) array, anynul, status);
else
ffgsvb(fptr, 1, naxis, naxes, blc, trc, inc, *(unsigned char *) nulval,
(unsigned char *) array, anynul, status);
}
else if (datatype == TSBYTE)
{
if (nulval == 0)
ffgsvsb(fptr, 1, naxis, naxes, blc, trc, inc, 0,
(signed char *) array, anynul, status);
else
ffgsvsb(fptr, 1, naxis, naxes, blc, trc, inc, *(signed char *) nulval,
(signed char *) array, anynul, status);
}
else if (datatype == TUSHORT)
{
if (nulval == 0)
ffgsvui(fptr, 1, naxis, naxes, blc, trc, inc, 0,
(unsigned short *) array, anynul, status);
else
ffgsvui(fptr, 1, naxis, naxes,blc, trc, inc, *(unsigned short *) nulval,
(unsigned short *) array, anynul, status);
}
else if (datatype == TSHORT)
{
if (nulval == 0)
ffgsvi(fptr, 1, naxis, naxes, blc, trc, inc, 0,
(short *) array, anynul, status);
else
ffgsvi(fptr, 1, naxis, naxes, blc, trc, inc, *(short *) nulval,
(short *) array, anynul, status);
}
else if (datatype == TUINT)
{
if (nulval == 0)
ffgsvuk(fptr, 1, naxis, naxes, blc, trc, inc, 0,
(unsigned int *) array, anynul, status);
else
ffgsvuk(fptr, 1, naxis, naxes, blc, trc, inc, *(unsigned int *) nulval,
(unsigned int *) array, anynul, status);
}
else if (datatype == TINT)
{
if (nulval == 0)
ffgsvk(fptr, 1, naxis, naxes, blc, trc, inc, 0,
(int *) array, anynul, status);
else
ffgsvk(fptr, 1, naxis, naxes, blc, trc, inc, *(int *) nulval,
(int *) array, anynul, status);
}
else if (datatype == TULONG)
{
if (nulval == 0)
ffgsvuj(fptr, 1, naxis, naxes, blc, trc, inc, 0,
(unsigned long *) array, anynul, status);
else
ffgsvuj(fptr, 1, naxis, naxes, blc, trc, inc, *(unsigned long *) nulval,
(unsigned long *) array, anynul, status);
}
else if (datatype == TLONG)
{
if (nulval == 0)
ffgsvj(fptr, 1, naxis, naxes, blc, trc, inc, 0,
(long *) array, anynul, status);
else
ffgsvj(fptr, 1, naxis, naxes, blc, trc, inc, *(long *) nulval,
(long *) array, anynul, status);
}
else if (datatype == TLONGLONG)
{
if (nulval == 0)
ffgsvjj(fptr, 1, naxis, naxes, blc, trc, inc, 0,
(LONGLONG *) array, anynul, status);
else
ffgsvjj(fptr, 1, naxis, naxes, blc, trc, inc, *(LONGLONG *) nulval,
(LONGLONG *) array, anynul, status);
}
else if (datatype == TFLOAT)
{
if (nulval == 0)
ffgsve(fptr, 1, naxis, naxes, blc, trc, inc, 0,
(float *) array, anynul, status);
else
ffgsve(fptr, 1, naxis, naxes, blc, trc, inc, *(float *) nulval,
(float *) array, anynul, status);
}
else if (datatype == TDOUBLE)
{
if (nulval == 0)
ffgsvd(fptr, 1, naxis, naxes, blc, trc, inc, 0,
(double *) array, anynul, status);
else
ffgsvd(fptr, 1, naxis, naxes, blc, trc, inc, *(double *) nulval,
(double *) array, anynul, status);
}
else
*status = BAD_DATATYPE;
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgpxfll( fitsfile *fptr, /* I - FITS file pointer */
int datatype, /* I - datatype of the value */
LONGLONG *firstpix, /* I - coord of first pixel to read (1s based) */
LONGLONG nelem, /* I - number of values to read */
void *array, /* O - array of values that are returned */
char *nullarray, /* O - returned array of null value flags */
int *anynul, /* O - set to 1 if any values are null; else 0 */
int *status) /* IO - error status */
/*
Read an array of values from the primary array. The datatype of the
input array is defined by the 2nd argument. Data conversion
and scaling will be performed if necessary (e.g, if the datatype of
the FITS array is not the same as the array being read).
The nullarray values will = 1 if the corresponding array value is null.
ANYNUL is returned with a value of .true. if any pixels are undefined.
*/
{
int naxis, ii;
int nullcheck = 2;
LONGLONG naxes[9];
LONGLONG dimsize = 1, firstelem;
if (*status > 0 || nelem == 0) /* inherit input status value if > 0 */
return(*status);
/* get the size of the image */
ffgidm(fptr, &naxis, status);
ffgiszll(fptr, 9, naxes, status);
/* calculate the position of the first element in the array */
firstelem = 0;
for (ii=0; ii < naxis; ii++)
{
firstelem += ((firstpix[ii] - 1) * dimsize);
dimsize *= naxes[ii];
}
firstelem++;
if (fits_is_compressed_image(fptr, status))
{
/* this is a compressed image in a binary table */
fits_read_compressed_pixels(fptr, datatype, firstelem, nelem,
nullcheck, NULL, array, nullarray, anynul, status);
return(*status);
}
/*
the primary array is represented as a binary table:
each group of the primary array is a row in the table,
where the first column contains the group parameters
and the second column contains the image itself.
*/
if (datatype == TBYTE)
{
ffgclb(fptr, 2, 1, firstelem, nelem, 1, 2, 0,
(unsigned char *) array, nullarray, anynul, status);
}
else if (datatype == TSBYTE)
{
ffgclsb(fptr, 2, 1, firstelem, nelem, 1, 2, 0,
(signed char *) array, nullarray, anynul, status);
}
else if (datatype == TUSHORT)
{
ffgclui(fptr, 2, 1, firstelem, nelem, 1, 2, 0,
(unsigned short *) array, nullarray, anynul, status);
}
else if (datatype == TSHORT)
{
ffgcli(fptr, 2, 1, firstelem, nelem, 1, 2, 0,
(short *) array, nullarray, anynul, status);
}
else if (datatype == TUINT)
{
ffgcluk(fptr, 2, 1, firstelem, nelem, 1, 2, 0,
(unsigned int *) array, nullarray, anynul, status);
}
else if (datatype == TINT)
{
ffgclk(fptr, 2, 1, firstelem, nelem, 1, 2, 0,
(int *) array, nullarray, anynul, status);
}
else if (datatype == TULONG)
{
ffgcluj(fptr, 2, 1, firstelem, nelem, 1, 2, 0,
(unsigned long *) array, nullarray, anynul, status);
}
else if (datatype == TLONG)
{
ffgclj(fptr, 2, 1, firstelem, nelem, 1, 2, 0,
(long *) array, nullarray, anynul, status);
}
else if (datatype == TLONGLONG)
{
ffgcljj(fptr, 2, 1, firstelem, nelem, 1, 2, 0,
(LONGLONG *) array, nullarray, anynul, status);
}
else if (datatype == TFLOAT)
{
ffgcle(fptr, 2, 1, firstelem, nelem, 1, 2, 0,
(float *) array, nullarray, anynul, status);
}
else if (datatype == TDOUBLE)
{
ffgcld(fptr, 2, 1, firstelem, nelem, 1, 2, 0,
(double *) array, nullarray, anynul, status);
}
else
*status = BAD_DATATYPE;
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffiimgll(fitsfile *fptr, /* I - FITS file pointer */
int bitpix, /* I - bits per pixel */
int naxis, /* I - number of axes in the array */
LONGLONG *naxes, /* I - size of each axis */
int *status) /* IO - error status */
/*
insert an IMAGE extension following the current HDU
*/
{
int bytlen, nexthdu, maxhdu, ii, onaxis;
long nblocks;
LONGLONG npixels, newstart, datasize;
char errmsg[FLEN_ERRMSG], card[FLEN_CARD], naxiskey[FLEN_KEYWORD];
if (*status > 0)
return(*status);
if (fptr->HDUposition != (fptr->Fptr)->curhdu)
ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);
maxhdu = (fptr->Fptr)->maxhdu;
if (*status != PREPEND_PRIMARY)
{
/* if the current header is completely empty ... */
if (( (fptr->Fptr)->headend == (fptr->Fptr)->headstart[(fptr->Fptr)->curhdu])
/* or, if we are at the end of the file, ... */
|| ( (((fptr->Fptr)->curhdu) == maxhdu ) &&
((fptr->Fptr)->headstart[maxhdu + 1] >= (fptr->Fptr)->logfilesize ) ) )
{
/* then simply append new image extension */
ffcrimll(fptr, bitpix, naxis, naxes, status);
return(*status);
}
}
if (bitpix == 8)
bytlen = 1;
else if (bitpix == 16)
bytlen = 2;
else if (bitpix == 32 || bitpix == -32)
bytlen = 4;
else if (bitpix == 64 || bitpix == -64)
bytlen = 8;
else
{
sprintf(errmsg,
"Illegal value for BITPIX keyword: %d", bitpix);
ffpmsg(errmsg);
return(*status = BAD_BITPIX); /* illegal bitpix value */
}
if (naxis < 0 || naxis > 999)
{
sprintf(errmsg,
"Illegal value for NAXIS keyword: %d", naxis);
ffpmsg(errmsg);
return(*status = BAD_NAXIS);
}
for (ii = 0; ii < naxis; ii++)
{
if (naxes[ii] < 0)
{
sprintf(errmsg,
"Illegal value for NAXIS%d keyword: %ld", ii + 1, (long) naxes[ii]);
ffpmsg(errmsg);
return(*status = BAD_NAXES);
}
}
/* calculate number of pixels in the image */
if (naxis == 0)
npixels = 0;
else
npixels = naxes[0];
for (ii = 1; ii < naxis; ii++)
npixels = npixels * naxes[ii];
datasize = npixels * bytlen; /* size of image in bytes */
nblocks = (long) (((datasize + 2879) / 2880) + 1); /* +1 for the header */
if ((fptr->Fptr)->writemode == READWRITE) /* must have write access */
{ /* close the CHDU */
ffrdef(fptr, status); /* scan header to redefine structure */
ffpdfl(fptr, status); /* insure correct data file values */
}
else
return(*status = READONLY_FILE);
if (*status == PREPEND_PRIMARY)
{
/* inserting a new primary array; the current primary */
/* array must be transformed into an image extension. */
*status = 0;
ffmahd(fptr, 1, NULL, status); /* move to the primary array */
ffgidm(fptr, &onaxis, status);
if (onaxis > 0)
ffkeyn("NAXIS",onaxis, naxiskey, status);
else
strcpy(naxiskey, "NAXIS");
ffgcrd(fptr, naxiskey, card, status); /* read last NAXIS keyword */
ffikyj(fptr, "PCOUNT", 0, "required keyword", status); /* add PCOUNT and */
ffikyj(fptr, "GCOUNT", 1, "required keyword", status); /* GCOUNT keywords */
if (*status > 0)
return(*status);
if (ffdkey(fptr, "EXTEND", status) ) /* delete the EXTEND keyword */
*status = 0;
/* redefine internal structure for this HDU */
ffrdef(fptr, status);
/* insert space for the primary array */
if (ffiblk(fptr, nblocks, -1, status) > 0) /* insert the blocks */
return(*status);
nexthdu = 0; /* number of the new hdu */
newstart = 0; /* starting addr of HDU */
}
else
{
nexthdu = ((fptr->Fptr)->curhdu) + 1; /* number of the next (new) hdu */
newstart = (fptr->Fptr)->headstart[nexthdu]; /* save starting addr of HDU */
(fptr->Fptr)->hdutype = IMAGE_HDU; /* so that correct fill value is used */
/* ffiblk also increments headstart for all following HDUs */
if (ffiblk(fptr, nblocks, 1, status) > 0) /* insert the blocks */
return(*status);
}
((fptr->Fptr)->maxhdu)++; /* increment known number of HDUs in the file */
for (ii = (fptr->Fptr)->maxhdu; ii > (fptr->Fptr)->curhdu; ii--)
(fptr->Fptr)->headstart[ii + 1] = (fptr->Fptr)->headstart[ii]; /* incre start addr */
if (nexthdu == 0)
(fptr->Fptr)->headstart[1] = nblocks * 2880; /* start of the old Primary array */
(fptr->Fptr)->headstart[nexthdu] = newstart; /* set starting addr of HDU */
/* set default parameters for this new empty HDU */
(fptr->Fptr)->curhdu = nexthdu; /* we are now located at the next HDU */
fptr->HDUposition = nexthdu; /* we are now located at the next HDU */
(fptr->Fptr)->nextkey = (fptr->Fptr)->headstart[nexthdu];
(fptr->Fptr)->headend = (fptr->Fptr)->headstart[nexthdu];
(fptr->Fptr)->datastart = ((fptr->Fptr)->headstart[nexthdu]) + 2880;
(fptr->Fptr)->hdutype = IMAGE_HDU; /* might need to be reset... */
/* write the required header keywords */
ffphprll(fptr, TRUE, bitpix, naxis, naxes, 0, 1, TRUE, status);
/* redefine internal structure for this HDU */
ffrdef(fptr, status);
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgsv( fitsfile *fptr, /* I - FITS file pointer */
int datatype, /* I - datatype of the value */
long *blc, /* I - 'bottom left corner' of the subsection */
long *trc , /* I - 'top right corner' of the subsection */
long *inc, /* I - increment to be applied in each dim. */
void *nulval, /* I - value for undefined pixels */
void *array, /* O - array of values that are returned */
int *anynul, /* O - set to 1 if any values are null; else 0 */
int *status) /* IO - error status */
/*
Read an section of values from the primary array. The datatype of the
input array is defined by the 2nd argument. Data conversion
and scaling will be performed if necessary (e.g, if the datatype of
the FITS array is not the same as the array being read).
Undefined elements will be set equal to NULVAL, unless NULVAL=0
in which case no checking for undefined values will be performed.
ANYNUL is returned with a value of .true. if any pixels are undefined.
*/
{
int naxis;
long naxes[9];
if (*status > 0) /* inherit input status value if > 0 */
return(*status);
/* get the size of the image */
ffgidm(fptr, &naxis, status);
ffgisz(fptr, 9, naxes, status);
if (datatype == TBYTE)
{
if (nulval == 0)
ffgsvb(fptr, 1, naxis, naxes, blc, trc, inc, 0,
(unsigned char *) array, anynul, status);
else
ffgsvb(fptr, 1, naxis, naxes, blc, trc, inc, *(unsigned char *) nulval,
(unsigned char *) array, anynul, status);
}
else if (datatype == TSBYTE)
{
if (nulval == 0)
ffgsvsb(fptr, 1, naxis, naxes, blc, trc, inc, 0,
(signed char *) array, anynul, status);
else
ffgsvsb(fptr, 1, naxis, naxes, blc, trc, inc, *(signed char *) nulval,
(signed char *) array, anynul, status);
}
else if (datatype == TUSHORT)
{
if (nulval == 0)
ffgsvui(fptr, 1, naxis, naxes, blc, trc, inc, 0,
(unsigned short *) array, anynul, status);
else
ffgsvui(fptr, 1, naxis, naxes,blc, trc, inc, *(unsigned short *) nulval,
(unsigned short *) array, anynul, status);
}
else if (datatype == TSHORT)
{
if (nulval == 0)
ffgsvi(fptr, 1, naxis, naxes, blc, trc, inc, 0,
(short *) array, anynul, status);
else
ffgsvi(fptr, 1, naxis, naxes, blc, trc, inc, *(short *) nulval,
(short *) array, anynul, status);
}
else if (datatype == TUINT)
{
if (nulval == 0)
ffgsvuk(fptr, 1, naxis, naxes, blc, trc, inc, 0,
(unsigned int *) array, anynul, status);
else
ffgsvuk(fptr, 1, naxis, naxes, blc, trc, inc, *(unsigned int *) nulval,
(unsigned int *) array, anynul, status);
}
else if (datatype == TINT)
{
if (nulval == 0)
ffgsvk(fptr, 1, naxis, naxes, blc, trc, inc, 0,
(int *) array, anynul, status);
else
ffgsvk(fptr, 1, naxis, naxes, blc, trc, inc, *(int *) nulval,
(int *) array, anynul, status);
}
else if (datatype == TULONG)
{
if (nulval == 0)
ffgsvuj(fptr, 1, naxis, naxes, blc, trc, inc, 0,
(unsigned long *) array, anynul, status);
else
ffgsvuj(fptr, 1, naxis, naxes, blc, trc, inc, *(unsigned long *) nulval,
(unsigned long *) array, anynul, status);
}
else if (datatype == TLONG)
{
if (nulval == 0)
ffgsvj(fptr, 1, naxis, naxes, blc, trc, inc, 0,
(long *) array, anynul, status);
else
ffgsvj(fptr, 1, naxis, naxes, blc, trc, inc, *(long *) nulval,
(long *) array, anynul, status);
}
else if (datatype == TLONGLONG)
{
if (nulval == 0)
ffgsvjj(fptr, 1, naxis, naxes, blc, trc, inc, 0,
(LONGLONG *) array, anynul, status);
else
ffgsvjj(fptr, 1, naxis, naxes, blc, trc, inc, *(LONGLONG *) nulval,
(LONGLONG *) array, anynul, status);
}
else if (datatype == TFLOAT)
{
if (nulval == 0)
ffgsve(fptr, 1, naxis, naxes, blc, trc, inc, 0,
(float *) array, anynul, status);
else
ffgsve(fptr, 1, naxis, naxes, blc, trc, inc, *(float *) nulval,
(float *) array, anynul, status);
}
else if (datatype == TDOUBLE)
{
if (nulval == 0)
ffgsvd(fptr, 1, naxis, naxes, blc, trc, inc, 0,
(double *) array, anynul, status);
else
ffgsvd(fptr, 1, naxis, naxes, blc, trc, inc, *(double *) nulval,
(double *) array, anynul, status);
}
else
*status = BAD_DATATYPE;
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgpxv( fitsfile *fptr, /* I - FITS file pointer */
int datatype, /* I - datatype of the value */
long *firstpix, /* I - coord of first pixel to read (1s based) */
long nelem, /* I - number of values to read */
void *nulval, /* I - value for undefined pixels */
void *array, /* O - array of values that are returned */
int *anynul, /* O - set to 1 if any values are null; else 0 */
int *status) /* IO - error status */
/*
Read an array of values from the primary array. The datatype of the
input array is defined by the 2nd argument. Data conversion
and scaling will be performed if necessary (e.g, if the datatype of
the FITS array is not the same as the array being read).
Undefined elements will be set equal to NULVAL, unless NULVAL=0
in which case no checking for undefined values will be performed.
ANYNUL is returned with a value of .true. if any pixels are undefined.
*/
{
int naxis, ii;
long naxes[9];
OFF_T dimsize = 1, firstelem;
if (*status > 0 || nelem == 0) /* inherit input status value if > 0 */
return(*status);
/* get the size of the image */
ffgidm(fptr, &naxis, status);
ffgisz(fptr, 9, naxes, status);
/* calculate the position of the first element in the array */
firstelem = 0;
for (ii=0; ii < naxis; ii++)
{
firstelem += ((firstpix[ii] - 1) * dimsize);
dimsize *= naxes[ii];
}
firstelem++;
/*
the primary array is represented as a binary table:
each group of the primary array is a row in the table,
where the first column contains the group parameters
and the second column contains the image itself.
*/
if (datatype == TBYTE)
{
if (nulval == 0)
ffgpvb(fptr, 1, firstelem, nelem, 0,
(unsigned char *) array, anynul, status);
else
ffgpvb(fptr, 1, firstelem, nelem, *(unsigned char *) nulval,
(unsigned char *) array, anynul, status);
}
else if (datatype == TSBYTE)
{
if (nulval == 0)
ffgpvsb(fptr, 1, firstelem, nelem, 0,
(signed char *) array, anynul, status);
else
ffgpvsb(fptr, 1, firstelem, nelem, *(signed char *) nulval,
(signed char *) array, anynul, status);
}
else if (datatype == TUSHORT)
{
if (nulval == 0)
ffgpvui(fptr, 1, firstelem, nelem, 0,
(unsigned short *) array, anynul, status);
else
ffgpvui(fptr, 1, firstelem, nelem, *(unsigned short *) nulval,
(unsigned short *) array, anynul, status);
}
else if (datatype == TSHORT)
{
if (nulval == 0)
ffgpvi(fptr, 1, firstelem, nelem, 0,
(short *) array, anynul, status);
else
ffgpvi(fptr, 1, firstelem, nelem, *(short *) nulval,
(short *) array, anynul, status);
}
else if (datatype == TUINT)
{
if (nulval == 0)
ffgpvuk(fptr, 1, firstelem, nelem, 0,
(unsigned int *) array, anynul, status);
else
ffgpvuk(fptr, 1, firstelem, nelem, *(unsigned int *) nulval,
(unsigned int *) array, anynul, status);
}
else if (datatype == TINT)
{
if (nulval == 0)
ffgpvk(fptr, 1, firstelem, nelem, 0,
(int *) array, anynul, status);
else
ffgpvk(fptr, 1, firstelem, nelem, *(int *) nulval,
(int *) array, anynul, status);
}
else if (datatype == TULONG)
{
if (nulval == 0)
ffgpvuj(fptr, 1, firstelem, nelem, 0,
(unsigned long *) array, anynul, status);
else
ffgpvuj(fptr, 1, firstelem, nelem, *(unsigned long *) nulval,
(unsigned long *) array, anynul, status);
}
else if (datatype == TLONG)
{
if (nulval == 0)
ffgpvj(fptr, 1, firstelem, nelem, 0,
(long *) array, anynul, status);
else
ffgpvj(fptr, 1, firstelem, nelem, *(long *) nulval,
(long *) array, anynul, status);
}
else if (datatype == TLONGLONG)
{
if (nulval == 0)
ffgpvjj(fptr, 1, firstelem, nelem, 0,
(LONGLONG *) array, anynul, status);
else
ffgpvjj(fptr, 1, firstelem, nelem, *(LONGLONG *) nulval,
(LONGLONG *) array, anynul, status);
}
else if (datatype == TFLOAT)
{
if (nulval == 0)
ffgpve(fptr, 1, firstelem, nelem, 0,
(float *) array, anynul, status);
else
ffgpve(fptr, 1, firstelem, nelem, *(float *) nulval,
(float *) array, anynul, status);
}
else if (datatype == TDOUBLE)
{
if (nulval == 0)
ffgpvd(fptr, 1, firstelem, nelem, 0,
(double *) array, anynul, status);
else
{
ffgpvd(fptr, 1, firstelem, nelem, *(double *) nulval,
(double *) array, anynul, status);
}
}
else
*status = BAD_DATATYPE;
return(*status);
}
std::shared_ptr<IImage> FITS_IO::read(const std::string& filename) {
fitsfile *fitsFilePtr;
int status = 0;
ffopen(&fitsFilePtr, filename.c_str(), READONLY, &status);
if (status) throw Common::Exception() << "ffopen failed with " << status;
int bytesPerPixel = 0;
int bitPixType;
ffgidt(fitsFilePtr, &bitPixType, &status);
if (status) throw Common::Exception() << "ffgidt failed with " << status;
int imgType = 0;
switch (bitPixType) {
case BYTE_IMG:
bytesPerPixel = 1;
imgType = TBYTE;
break;
case SHORT_IMG:
bytesPerPixel = 2;
imgType = TSHORT;
break;
case LONG_IMG:
bytesPerPixel = 4;
imgType = TLONG;
break;
case FLOAT_IMG:
bytesPerPixel = 4;
imgType = TFLOAT;
break;
case DOUBLE_IMG:
bytesPerPixel = 8;
imgType = TDOUBLE;
break;
default:
throw Common::Exception() << "image is an unsupported FITS type " << bitPixType;
}
int dim;
ffgidm(fitsFilePtr, &dim, &status);
if (status) throw Common::Exception() << "ffgidm failed with " << status;
if (dim != 3) throw Common::Exception() << "image is an unsupported dimension " << dim;
long int fpixel[3];
for (int i = 0; i < dim; i++) {
fpixel[i] = 1;
}
long int sizes[3];
ffgisz(fitsFilePtr, 3, sizes, &status);
if (status) throw Common::Exception() << "ffgisz failed with " << status;
int width = sizes[0];
int height = sizes[1];
Tensor::Vector<int,2> size(width,height);
int channels = sizes[2];
int numPixels = width * height * channels;
std::vector<unsigned char> data(numPixels * bytesPerPixel);
ffgpxv(fitsFilePtr, imgType, fpixel, numPixels, NULL, &data[0], NULL, &status);
if (status) throw Common::Exception() << "ffgpxv failed with " << status;
std::shared_ptr<IImage> img;
switch (bitPixType) {
case BYTE_IMG:
img = std::make_shared<ImageType<char>>(size, nullptr, channels, 1);
break;
case SHORT_IMG:
img = std::make_shared<ImageType<short>>(size, nullptr, channels, 1);
break;
case LONG_IMG:
img = std::make_shared<ImageType<int>>(size, nullptr, channels, 1);
break;
case FLOAT_IMG:
img = std::make_shared<ImageType<float>>(size, nullptr, channels, 1);
break;
case DOUBLE_IMG:
img = std::make_shared<ImageType<double>>(size, nullptr, channels, 1);
break;
default:
throw Common::Exception() << "uncoded read type " << bitPixType;
}
memcpy(img->getData(), &data[0], numPixels * bytesPerPixel);
ffclos(fitsFilePtr, &status);
if (status) throw Common::Exception() << "ffclos failed with " << status;
return img;
}