/*--------------------------------------------------------------------------*/
int ffpprn( fitsfile *fptr, /* I - FITS file pointer */
LONGLONG firstelem, /* I - first vector element to write(1 = 1st) */
LONGLONG nelem, /* I - number of values to write */
int *status) /* IO - error status */
/*
Write null values to the primary array. (Doesn't support groups).
*/
{
long row = 1;
/*
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 (fits_is_compressed_image(fptr, status))
{
/* this is a compressed image in a binary table */
ffpmsg("writing to compressed image is not supported");
return(*status = DATA_COMPRESSION_ERR);
}
ffpclu(fptr, 2, row, firstelem, nelem, status);
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpprd( fitsfile *fptr, /* I - FITS file pointer */
long group, /* I - group to write(1 = 1st group) */
long firstelem, /* I - first vector element to write(1 = 1st) */
long nelem, /* I - number of values to write */
double *array, /* I - array of values that are written */
int *status) /* IO - error status */
/*
Write an array of values to the primary array. 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).
*/
{
long row;
/*
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 (fits_is_compressed_image(fptr, status))
{
/* this is a compressed image in a binary table */
ffpmsg("writing to compressed image is not supported");
return(*status = DATA_COMPRESSION_ERR);
}
row=maxvalue(1,group);
ffpcld(fptr, 2, row, firstelem, nelem, array, status);
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpscl(fitsfile *fptr, /* I - FITS file pointer */
double scale, /* I - scaling factor: value of BSCALE */
double zero, /* I - zero point: value of bZero */
int *status) /* IO - error status */
/*
Define the linear scaling factor for the primary array or image extension
pixel values. This routine overrides the scaling values given by the
BSCALE and bZero keywords if present. Note that this routine does not
write or modify the BSCALE and bZero keywords, but instead only modifies
the values temporarily in the internal buffer. Thus, a subsequent call to
the ffrdef routine will reset the scaling back to the BSCALE and bZero
keyword values (or 1. and 0. respectively if the keywords are not present).
*/
{
tcolumn *colptr;
int hdutype;
if (*status > 0)
return(*status);
if (scale == 0)
return(*status = ZERO_SCALE); /* zero scale value is illegal */
if (ffghdt(fptr, &hdutype, status) > 0) /* get HDU type */
return(*status);
if (hdutype != IMAGE_HDU)
return(*status = NOT_IMAGE); /* not proper HDU type */
if (fits_is_compressed_image(fptr, status)) /* compressed images */
{
(fptr->Fptr)->cn_bscale = scale;
(fptr->Fptr)->cn_bZero = zero;
return(*status);
}
/* set pointer to the first 'column' (contains group parameters if any) */
colptr = (fptr->Fptr)->tableptr;
colptr++; /* increment to the 2nd 'column' pointer (the image itself) */
colptr->tscale = scale;
colptr->tzero = zero;
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffppne( fitsfile *fptr, /* I - FITS file pointer */
long group, /* I - group to write(1 = 1st group) */
LONGLONG firstelem, /* I - first vector element to write(1 = 1st) */
LONGLONG nelem, /* I - number of values to write */
float *array, /* I - array of values that are written */
float nulval, /* I - undefined pixel value */
int *status) /* IO - error status */
/*
Write an array of values to the primary array. 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). Any array values
that are equal to the value of nulval will be replaced with the null
pixel value that is appropriate for this column.
This routine cannot be called directly by users to write to large
arrays with > 2**31 pixels (although CFITSIO can do so by passing
the firstelem thru a LONGLONG sized global variable)
*/
{
long row;
float nullvalue;
/*
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 (fits_is_compressed_image(fptr, status))
{
/* this is a compressed image in a binary table */
nullvalue = nulval; /* set local variable */
fits_write_compressed_pixels(fptr, TFLOAT, firstelem, nelem,
1, array, &nullvalue, status);
return(*status);
}
row=maxvalue(1,group);
ffpcne(fptr, 2, row, firstelem, nelem, array, nulval, status);
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffppnd( fitsfile *fptr, /* I - FITS file pointer */
long group, /* I - group to write(1 = 1st group) */
long firstelem, /* I - first vector element to write(1 = 1st) */
long nelem, /* I - number of values to write */
double *array, /* I - array of values that are written */
double nulval, /* I - undefined pixel value */
int *status) /* IO - error status */
/*
Write an array of values to the primary array. 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). Any array values
that are equal to the value of nulval will be replaced with the null
pixel value that is appropriate for this column.
*/
{
long row;
double nullvalue;
/*
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 (fits_is_compressed_image(fptr, status))
{
/* this is a compressed image in a binary table */
/* use the OFF_T variable to pass the first element value */
if (firstelem != USE_LARGE_VALUE)
large_first_elem_val = firstelem;
nullvalue = nulval; /* set local variable */
fits_write_compressed_pixels(fptr, TDOUBLE, large_first_elem_val, nelem,
1, array, &nullvalue, status);
return(*status);
}
row=maxvalue(1,group);
ffpcnd(fptr, 2, row, firstelem, nelem, array, nulval, status);
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpprk( fitsfile *fptr, /* I - FITS file pointer */
long group, /* I - group to write(1 = 1st group) */
long firstelem, /* I - first vector element to write(1 = 1st) */
long nelem, /* I - number of values to write */
int *array, /* I - array of values that are written */
int *status) /* IO - error status */
/*
Write an array of values to the primary array. 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).
*/
{
long row;
int nullvalue;
/*
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 (fits_is_compressed_image(fptr, status))
{
/* this is a compressed image in a binary table */
/* use the OFF_T variable to pass the first element value */
if (firstelem != USE_LARGE_VALUE)
large_first_elem_val = firstelem;
fits_write_compressed_pixels(fptr, TINT, large_first_elem_val, nelem,
0, array, &nullvalue, status);
return(*status);
}
row=maxvalue(1,group);
ffpclk(fptr, 2, row, firstelem, nelem, array, status);
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpnul(fitsfile *fptr, /* I - FITS file pointer */
long nulvalue, /* I - null pixel value: value of BLANK */
int *status) /* IO - error status */
/*
Define the value used to represent undefined pixels in the primary array or
image extension. This only applies to integer image pixel (i.e. BITPIX > 0).
This routine overrides the null pixel value given by the BLANK keyword
if present. Note that this routine does not write or modify the BLANK
keyword, but instead only modifies the value temporarily in the internal
buffer. Thus, a subsequent call to the ffrdef routine will reset the null
value back to the BLANK keyword value (or not defined if the keyword is not
present).
*/
{
tcolumn *colptr;
int hdutype;
if (*status > 0)
return(*status);
if (ffghdt(fptr, &hdutype, status) > 0) /* get HDU type */
return(*status);
if (hdutype != IMAGE_HDU)
return(*status = NOT_IMAGE); /* not proper HDU type */
if (fits_is_compressed_image(fptr, status)) /* ignore compressed images */
return(*status);
/* set pointer to the first 'column' (contains group parameters if any) */
colptr = (fptr->Fptr)->tableptr;
colptr++; /* increment to the 2nd 'column' pointer (the image itself) */
colptr->tnull = nulvalue;
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpprui(fitsfile *fptr, /* I - FITS file pointer */
long group, /* I - group to write (1 = 1st group) */
LONGLONG firstelem, /* I - first vector element to write (1 = 1st) */
LONGLONG nelem, /* I - number of values to write */
unsigned short *array, /* I - array of values that are written */
int *status) /* IO - error status */
/*
Write an array of values to the primary array. 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).
*/
{
long row;
unsigned short nullvalue;
/*
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 (fits_is_compressed_image(fptr, status))
{
/* this is a compressed image in a binary table */
fits_write_compressed_pixels(fptr, TUSHORT, firstelem, nelem,
0, array, &nullvalue, status);
return(*status);
}
row=maxvalue(1,group);
ffpclui(fptr, 2, row, firstelem, nelem, array, status);
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpssd(fitsfile *fptr, /* I - FITS file pointer */
long group, /* I - group to write(1 = 1st group) */
long naxis, /* I - number of data axes in array */
long *naxes, /* I - size of each FITS axis */
long *fpixel, /* I - 1st pixel in each axis to write (1=1st) */
long *lpixel, /* I - last pixel in each axis to write */
double *array, /* I - array to be written */
int *status) /* IO - error status */
/*
Write a subsection of pixels to the primary array or image.
A subsection is defined to be any contiguous rectangular
array of pixels within the n-dimensional FITS data file.
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).
*/
{
long tablerow;
LONGLONG fpix[7], dimen[7], astart, pstart;
LONGLONG off2, off3, off4, off5, off6, off7;
LONGLONG st10, st20, st30, st40, st50, st60, st70;
LONGLONG st1, st2, st3, st4, st5, st6, st7;
long ii, i1, i2, i3, i4, i5, i6, i7, irange[7];
if (*status > 0)
return(*status);
if (fits_is_compressed_image(fptr, status))
{
/* this is a compressed image in a binary table */
fits_write_compressed_img(fptr, TDOUBLE, fpixel, lpixel,
0, array, NULL, status);
return(*status);
}
if (naxis < 1 || naxis > 7)
return(*status = BAD_DIMEN);
tablerow=maxvalue(1,group);
/* calculate the size and number of loops to perform in each dimension */
for (ii = 0; ii < 7; ii++)
{
fpix[ii]=1;
irange[ii]=1;
dimen[ii]=1;
}
for (ii = 0; ii < naxis; ii++)
{
fpix[ii]=fpixel[ii];
irange[ii]=lpixel[ii]-fpixel[ii]+1;
dimen[ii]=naxes[ii];
}
i1=irange[0];
/* compute the pixel offset between each dimension */
off2 = dimen[0];
off3 = off2 * dimen[1];
off4 = off3 * dimen[2];
off5 = off4 * dimen[3];
off6 = off5 * dimen[4];
off7 = off6 * dimen[5];
st10 = fpix[0];
st20 = (fpix[1] - 1) * off2;
st30 = (fpix[2] - 1) * off3;
st40 = (fpix[3] - 1) * off4;
st50 = (fpix[4] - 1) * off5;
st60 = (fpix[5] - 1) * off6;
st70 = (fpix[6] - 1) * off7;
/* store the initial offset in each dimension */
st1 = st10;
st2 = st20;
st3 = st30;
st4 = st40;
st5 = st50;
st6 = st60;
st7 = st70;
astart = 0;
for (i7 = 0; i7 < irange[6]; i7++)
{
for (i6 = 0; i6 < irange[5]; i6++)
{
for (i5 = 0; i5 < irange[4]; i5++)
{
for (i4 = 0; i4 < irange[3]; i4++)
{
for (i3 = 0; i3 < irange[2]; i3++)
{
pstart = st1 + st2 + st3 + st4 + st5 + st6 + st7;
for (i2 = 0; i2 < irange[1]; i2++)
{
if (ffpcld(fptr, 2, tablerow, pstart, i1, &array[astart],
status) > 0)
return(*status);
astart += i1;
pstart += off2;
}
st2 = st20;
st3 = st3+off3;
}
st3 = st30;
st4 = st4+off4;
}
st4 = st40;
st5 = st5+off5;
}
st5 = st50;
st6 = st6+off6;
}
st6 = st60;
st7 = st7+off7;
}
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffp3dd(fitsfile *fptr, /* I - FITS file pointer */
long group, /* I - group to write(1 = 1st group) */
LONGLONG ncols, /* I - number of pixels in each row of array */
LONGLONG nrows, /* I - number of rows in each plane of array */
LONGLONG naxis1, /* I - FITS image NAXIS1 value */
LONGLONG naxis2, /* I - FITS image NAXIS2 value */
LONGLONG naxis3, /* I - FITS image NAXIS3 value */
double *array, /* I - array to be written */
int *status) /* IO - error status */
/*
Write an entire 3-D cube of values to the primary array. 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).
*/
{
long tablerow, ii, jj;
long fpixel[3]= {1,1,1}, lpixel[3];
LONGLONG nfits, narray;
/*
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 (fits_is_compressed_image(fptr, status))
{
/* this is a compressed image in a binary table */
lpixel[0] = (long) ncols;
lpixel[1] = (long) nrows;
lpixel[2] = (long) naxis3;
fits_write_compressed_img(fptr, TDOUBLE, fpixel, lpixel,
0, array, NULL, status);
return(*status);
}
tablerow=maxvalue(1,group);
if (ncols == naxis1 && nrows == naxis2) /* arrays have same size? */
{
/* all the image pixels are contiguous, so write all at once */
ffpcld(fptr, 2, tablerow, 1L, naxis1 * naxis2 * naxis3, array, status);
return(*status);
}
if (ncols < naxis1 || nrows < naxis2)
return(*status = BAD_DIMEN);
nfits = 1; /* next pixel in FITS image to write to */
narray = 0; /* next pixel in input array to be written */
/* loop over naxis3 planes in the data cube */
for (jj = 0; jj < naxis3; jj++)
{
/* loop over the naxis2 rows in the FITS image, */
/* writing naxis1 pixels to each row */
for (ii = 0; ii < naxis2; ii++)
{
if (ffpcld(fptr, 2, tablerow, nfits, naxis1,&array[narray],status) > 0)
return(*status);
nfits += naxis1;
narray += ncols;
}
narray += (nrows - naxis2) * ncols;
}
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);
}
