/*--------------------------------------------------------------------------*/
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 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;
/*
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);
ffpcnd(fptr, 2, row, firstelem, nelem, array, nulval, status);
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpcn( 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 */
void *nulval, /* I - pointer to the null value */
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 (nulval == NULL) /* null value not defined? */
{
ffpcl(fptr, datatype, colnum, firstrow, firstelem, nelem, array,
status);
return(*status);
}
if (datatype == TBYTE)
{
ffpcnb(fptr, colnum, firstrow, firstelem, nelem, (unsigned char *) array,
*(unsigned char *) nulval, status);
}
else if (datatype == TUSHORT)
{
ffpcnui(fptr, colnum, firstrow, firstelem, nelem, (unsigned short *) array,
*(unsigned short *) nulval, status);
}
else if (datatype == TSHORT)
{
ffpcni(fptr, colnum, firstrow, firstelem, nelem, (short *) array,
*(unsigned short *) nulval, status);
}
else if (datatype == TUINT)
{
ffpcnuk(fptr, colnum, firstrow, firstelem, nelem, (unsigned int *) array,
*(unsigned int *) nulval, status);
}
else if (datatype == TINT)
{
ffpcnk(fptr, colnum, firstrow, firstelem, nelem, (int *) array,
*(int *) nulval, status);
}
else if (datatype == TULONG)
{
ffpcnuj(fptr, colnum, firstrow, firstelem, nelem, (unsigned long *) array,
*(unsigned long *) nulval, status);
}
else if (datatype == TLONG)
{
ffpcnj(fptr, colnum, firstrow, firstelem, nelem, (long *) array,
*(long *) nulval, status);
}
else if (datatype == TFLOAT)
{
ffpcne(fptr, colnum, firstrow, firstelem, nelem, (float *) array,
*(float *) nulval, status);
}
else if (datatype == TDOUBLE)
{
ffpcnd(fptr, colnum, firstrow, firstelem, nelem, (double *) array,
*(double *) nulval, status);
}
else if (datatype == TLOGICAL)
{
ffpcnl(fptr, colnum, firstrow, firstelem, nelem, (char *) array,
*(char *) nulval, status);
}
else if (datatype == TSTRING)
{
ffpcns(fptr, colnum, firstrow, firstelem, nelem, (char **) array,
(char *) nulval, status);
}
else
*status = BAD_DATATYPE;
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffppn( 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 */
void *nulval, /* I - pointer to the null value */
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);
if (nulval == NULL) /* null value not defined? */
{
ffppr(fptr, datatype, firstelem, nelem, array, 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)
{
ffpcnb(fptr, 2, row, firstelem, nelem, (unsigned char *) array,
*(unsigned char *) nulval, status);
}
else if (datatype == TUSHORT)
{
ffpcnui(fptr, 2, row, firstelem, nelem, (unsigned short *) array,
*(unsigned short *) nulval,status);
}
else if (datatype == TSHORT)
{
ffpcni(fptr, 2, row, firstelem, nelem, (short *) array,
*(short *) nulval, status);
}
else if (datatype == TUINT)
{
ffpcnuk(fptr, 2, row, firstelem, nelem, (unsigned int *) array,
*(unsigned int *) nulval, status);
}
else if (datatype == TINT)
{
ffpcnk(fptr, 2, row, firstelem, nelem, (int *) array,
*(int *) nulval, status);
}
else if (datatype == TULONG)
{
ffpcnuj(fptr, 2, row, firstelem, nelem, (unsigned long *) array,
*(unsigned long *) nulval,status);
}
else if (datatype == TLONG)
{
ffpcnj(fptr, 2, row, firstelem, nelem, (long *) array,
*(long *) nulval, status);
}
else if (datatype == TFLOAT)
{
ffpcne(fptr, 2, row, firstelem, nelem, (float *) array,
*(float *) nulval, status);
}
else if (datatype == TDOUBLE)
{
ffpcnd(fptr, 2, row, firstelem, nelem, (double *) array,
*(double *) nulval, status);
}
else
*status = BAD_DATATYPE;
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffppxn( fitsfile *fptr, /* I - FITS file pointer */
int datatype, /* I - datatype of the value */
long *firstpix, /* 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 */
void *nulval, /* I - pointer to the null value */
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).
*/
{
int naxis, ii;
long naxes[9], firstelem, row = 1;
OFF_T dimsize = 1;
if (*status > 0) /* inherit input status value if > 0 */
return(*status);
if (nulval == NULL) /* null value not defined? */
{
ffppx(fptr, datatype, firstpix, nelem, array, status);
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)
{
ffpcnb(fptr, 2, row, firstelem, nelem, (unsigned char *) array,
*(unsigned char *) nulval, status);
}
else if (datatype == TUSHORT)
{
ffpcnui(fptr, 2, row, firstelem, nelem, (unsigned short *) array,
*(unsigned short *) nulval,status);
}
else if (datatype == TSHORT)
{
ffpcni(fptr, 2, row, firstelem, nelem, (short *) array,
*(short *) nulval, status);
}
else if (datatype == TUINT)
{
ffpcnuk(fptr, 2, row, firstelem, nelem, (unsigned int *) array,
*(unsigned int *) nulval, status);
}
else if (datatype == TINT)
{
ffpcnk(fptr, 2, row, firstelem, nelem, (int *) array,
*(int *) nulval, status);
}
else if (datatype == TULONG)
{
ffpcnuj(fptr, 2, row, firstelem, nelem, (unsigned long *) array,
*(unsigned long *) nulval,status);
}
else if (datatype == TLONG)
{
ffpcnj(fptr, 2, row, firstelem, nelem, (long *) array,
*(long *) nulval, status);
}
else if (datatype == TFLOAT)
{
ffpcne(fptr, 2, row, firstelem, nelem, (float *) array,
*(float *) nulval, status);
}
else if (datatype == TDOUBLE)
{
ffpcnd(fptr, 2, row, firstelem, nelem, (double *) array,
*(double *) nulval, status);
}
else
*status = BAD_DATATYPE;
return(*status);
}