/*--------------------------------------------------------------------------*/
int ffp3db(fitsfile *fptr, /* I - FITS file pointer */
long group, /* I - group to write(1 = 1st group) */
long ncols, /* I - number of pixels in each row of array */
long nrows, /* I - number of rows in each plane of array */
long naxis1, /* I - FITS image NAXIS1 value */
long naxis2, /* I - FITS image NAXIS2 value */
long naxis3, /* I - FITS image NAXIS3 value */
unsigned char *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, nfits, narray, ii, jj;
/*
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.
*/
tablerow=maxvalue(1,group);
if (ncols == naxis1 && nrows == naxis2) /* arrays have same size? */
{
/* all the image pixels are contiguous, so write all at once */
ffpclb(fptr, 2, tablerow, 1L, naxis1 * naxis2 * naxis3, array, status);
return(*status);
}
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 (ffpclb(fptr, 2, tablerow, nfits, naxis1,&array[narray],status) > 0)
return(*status);
nfits += naxis1;
narray += ncols;
}
}
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpgpb( 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 */
unsigned char *array, /* I - array of values that are written */
int *status) /* IO - error status */
/*
Write an array of group parameters 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.
*/
row=maxvalue(1,group);
ffpclb(fptr, 1L, row, firstelem, nelem, array, status);
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpprb( 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 */
unsigned char *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 char 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, TBYTE, large_first_elem_val, nelem,
0, array, &nullvalue, status);
return(*status);
}
row=maxvalue(1,group);
ffpclb(fptr, 2, row, firstelem, nelem, array, status);
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpcl( fitsfile *fptr, /* I - FITS file pointer */
int datatype, /* I - datatype of the value */
int colnum, /* I - number of column to write (1 = 1st col) */
long firstrow, /* I - first row to write (1 = 1st row) */
long firstelem, /* I - first vector element to write (1 = 1st) */
long nelem, /* I - number of elements to write */
void *array, /* I - array of values that are written */
int *status) /* IO - error status */
/*
Write an array of values to a table column. 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 column is not the same as the array being written).
*/
{
if (*status > 0) /* inherit input status value if > 0 */
return(*status);
if (datatype == TBIT)
{
ffpclx(fptr, colnum, firstrow, firstelem, nelem, (char *) array,
status);
}
else if (datatype == TBYTE)
{
ffpclb(fptr, colnum, firstrow, firstelem, nelem, (unsigned char *) array,
status);
}
else if (datatype == TUSHORT)
{
ffpclui(fptr, colnum, firstrow, firstelem, nelem,
(unsigned short *) array, status);
}
else if (datatype == TSHORT)
{
ffpcli(fptr, colnum, firstrow, firstelem, nelem, (short *) array,
status);
}
else if (datatype == TUINT)
{
ffpcluk(fptr, colnum, firstrow, firstelem, nelem, (unsigned int *) array,
status);
}
else if (datatype == TINT)
{
ffpclk(fptr, colnum, firstrow, firstelem, nelem, (int *) array,
status);
}
else if (datatype == TULONG)
{
ffpcluj(fptr, colnum, firstrow, firstelem, nelem, (unsigned long *) array,
status);
}
else if (datatype == TLONG)
{
ffpclj(fptr, colnum, firstrow, firstelem, nelem, (long *) array,
status);
}
else if (datatype == TFLOAT)
{
ffpcle(fptr, colnum, firstrow, firstelem, nelem, (float *) array,
status);
}
else if (datatype == TDOUBLE)
{
ffpcld(fptr, colnum, firstrow, firstelem, nelem, (double *) array,
status);
}
else if (datatype == TCOMPLEX)
{
ffpcle(fptr, colnum, firstrow, (firstelem - 1) * 2 + 1, nelem * 2,
(float *) array, status);
}
else if (datatype == TDBLCOMPLEX)
{
ffpcld(fptr, colnum, firstrow, (firstelem - 1) * 2 + 1, nelem * 2,
(double *) array, status);
}
else if (datatype == TLOGICAL)
{
ffpcll(fptr, colnum, firstrow, firstelem, nelem, (char *) array,
status);
}
else if (datatype == TSTRING)
{
ffpcls(fptr, colnum, firstrow, firstelem, nelem, (char **) array,
status);
}
else
*status = BAD_DATATYPE;
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffppr( fitsfile *fptr, /* I - FITS file pointer */
int datatype, /* I - datatype of the value */
long firstelem, /* I - first vector element to write(1 = 1st) */
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 values 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).
*/
{
long row = 1;
if (*status > 0) /* inherit input status value if > 0 */
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)
{
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 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 ffpcnb( fitsfile *fptr, /* I - FITS file pointer */
int colnum, /* I - number of column to write (1 = 1st col) */
long firstrow, /* I - first row to write (1 = 1st row) */
long firstelem, /* I - first vector element to write (1 = 1st) */
long nelem, /* I - number of values to write */
unsigned char *array, /* I - array of values to write */
unsigned char nulvalue, /* I - flag for undefined pixels */
int *status) /* IO - error status */
/*
Write an array of elements to the specified column of a table. Any input
pixels equal to the value of nulvalue will be replaced by the appropriate
null value in the output FITS file.
The input array of values will be converted to the datatype of the column
and will be inverse-scaled by the FITS TSCALn and TZEROn values if necessary
*/
{
tcolumn *colptr;
long ngood = 0, nbad = 0, ii, fstrow;
OFF_T large_elem, repeat, first, fstelm;
if (*status > 0)
return(*status);
/* reset position to the correct HDU if necessary */
if (fptr->HDUposition != (fptr->Fptr)->curhdu)
{
ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);
}
else if ((fptr->Fptr)->datastart == DATA_UNDEFINED)
{
if ( ffrdef(fptr, status) > 0) /* rescan header */
return(*status);
}
colptr = (fptr->Fptr)->tableptr; /* point to first column */
colptr += (colnum - 1); /* offset to correct column structure */
repeat = colptr->trepeat; /* repeat count for this column */
if (firstelem == USE_LARGE_VALUE)
large_elem = large_first_elem_val;
else
large_elem = firstelem;
/* hereafter, pass first element parameter via global variable */
firstelem = USE_LARGE_VALUE;
/* absolute element number in the column */
first = (firstrow - 1) * repeat + large_elem;
for (ii = 0; ii < nelem; ii++)
{
if (array[ii] != nulvalue) /* is this a good pixel? */
{
if (nbad) /* write previous string of bad pixels */
{
fstelm = ii - nbad + first; /* absolute element number */
fstrow = (fstelm - 1) / repeat + 1; /* starting row number */
fstelm = fstelm - (fstrow - 1) * repeat; /* relative number */
large_first_elem_val = fstelm;
if (ffpclu(fptr, colnum, fstrow, firstelem, nbad, status) > 0)
return(*status);
nbad=0;
}
ngood = ngood + 1; /* the consecutive number of good pixels */
}
else
{
if (ngood) /* write previous string of good pixels */
{
fstelm = ii - ngood + first; /* absolute element number */
fstrow = (fstelm - 1) / repeat + 1; /* starting row number */
fstelm = fstelm - (fstrow - 1) * repeat; /* relative number */
large_first_elem_val = fstelm;
if (ffpclb(fptr, colnum, fstrow, firstelem, ngood, &array[ii-ngood],
status) > 0)
return(*status);
ngood=0;
}
nbad = nbad + 1; /* the consecutive number of bad pixels */
}
}
/* finished loop; now just write the last set of pixels */
if (ngood) /* write last string of good pixels */
{
fstelm = ii - ngood + first; /* absolute element number */
fstrow = (fstelm - 1) / repeat + 1; /* starting row number */
fstelm = fstelm - (fstrow - 1) * repeat; /* relative number */
large_first_elem_val = fstelm;
ffpclb(fptr, colnum, fstrow, firstelem, ngood, &array[ii-ngood], status);
}
else if (nbad) /* write last string of bad pixels */
{
fstelm = ii - nbad + first; /* absolute element number */
fstrow = (fstelm - 1) / repeat + 1; /* starting row number */
fstelm = fstelm - (fstrow - 1) * repeat; /* relative number */
large_first_elem_val = fstelm;
ffpclu(fptr, colnum, fstrow, firstelem, nbad, status);
}
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpssb(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 */
unsigned char *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;
long fpix[7], irange[7], dimen[7], astart, pstart;
long off2, off3, off4, off5, off6, off7;
long st10, st20, st30, st40, st50, st60, st70;
long st1, st2, st3, st4, st5, st6, st7;
long ii, i1, i2, i3, i4, i5, i6, i7;
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, TBYTE, 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 (ffpclb(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 ffpcnb( fitsfile *fptr, /* I - FITS file pointer */
int colnum, /* I - number of column to write (1 = 1st col) */
LONGLONG firstrow, /* I - first row to write (1 = 1st row) */
LONGLONG firstelem, /* I - first vector element to write (1 = 1st) */
LONGLONG nelem, /* I - number of values to write */
unsigned char *array, /* I - array of values to write */
unsigned char nulvalue, /* I - flag for undefined pixels */
int *status) /* IO - error status */
/*
Write an array of elements to the specified column of a table. Any input
pixels equal to the value of nulvalue will be replaced by the appropriate
null value in the output FITS file.
The input array of values will be converted to the datatype of the column
and will be inverse-scaled by the FITS TSCALn and TZEROn values if necessary
*/
{
tcolumn *colptr;
long ngood = 0, nbad = 0, ii;
LONGLONG repeat, first, fstelm, fstrow;
int tcode, overflow = 0;
if (*status > 0)
return(*status);
/* reset position to the correct HDU if necessary */
if (fptr->HDUposition != (fptr->Fptr)->curhdu)
{
ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);
}
else if ((fptr->Fptr)->datastart == DATA_UNDEFINED)
{
if ( ffrdef(fptr, status) > 0) /* rescan header */
return(*status);
}
colptr = (fptr->Fptr)->tableptr; /* point to first column */
colptr += (colnum - 1); /* offset to correct column structure */
tcode = colptr->tdatatype;
if (tcode > 0)
repeat = colptr->trepeat; /* repeat count for this column */
else
repeat = firstelem -1 + nelem; /* variable length arrays */
/* if variable length array, first write the whole input vector,
then go back and fill in the nulls */
if (tcode < 0) {
if (ffpclb(fptr, colnum, firstrow, firstelem, nelem, array, status) > 0) {
if (*status == NUM_OVERFLOW)
{
/* ignore overflows, which are possibly the null pixel values */
/* overflow = 1; */
*status = 0;
} else {
return(*status);
}
}
}
/* absolute element number in the column */
first = (firstrow - 1) * repeat + firstelem;
for (ii = 0; ii < nelem; ii++)
{
if (array[ii] != nulvalue) /* is this a good pixel? */
{
if (nbad) /* write previous string of bad pixels */
{
fstelm = ii - nbad + first; /* absolute element number */
fstrow = (fstelm - 1) / repeat + 1; /* starting row number */
fstelm = fstelm - (fstrow - 1) * repeat; /* relative number */
if (ffpclu(fptr, colnum, fstrow, fstelm, nbad, status) > 0)
return(*status);
nbad=0;
}
ngood = ngood + 1; /* the consecutive number of good pixels */
}
else
{
if (ngood) /* write previous string of good pixels */
{
fstelm = ii - ngood + first; /* absolute element number */
fstrow = (fstelm - 1) / repeat + 1; /* starting row number */
fstelm = fstelm - (fstrow - 1) * repeat; /* relative number */
if (tcode > 0) { /* variable length arrays have already been written */
if (ffpclb(fptr, colnum, fstrow, fstelm, ngood, &array[ii-ngood],
status) > 0) {
if (*status == NUM_OVERFLOW)
{
overflow = 1;
*status = 0;
} else {
return(*status);
}
}
}
ngood=0;
}
nbad = nbad + 1; /* the consecutive number of bad pixels */
}
}
/* finished loop; now just write the last set of pixels */
if (ngood) /* write last string of good pixels */
{
fstelm = ii - ngood + first; /* absolute element number */
fstrow = (fstelm - 1) / repeat + 1; /* starting row number */
fstelm = fstelm - (fstrow - 1) * repeat; /* relative number */
if (tcode > 0) { /* variable length arrays have already been written */
ffpclb(fptr, colnum, fstrow, fstelm, ngood, &array[ii-ngood], status);
}
}
else if (nbad) /* write last string of bad pixels */
{
fstelm = ii - nbad + first; /* absolute element number */
fstrow = (fstelm - 1) / repeat + 1; /* starting row number */
fstelm = fstelm - (fstrow - 1) * repeat; /* relative number */
ffpclu(fptr, colnum, fstrow, fstelm, nbad, status);
}
if (*status <= 0) {
if (overflow) {
*status = NUM_OVERFLOW;
}
}
return(*status);
}