std::string write_image(std::string pathname, float *array, std::string name, int naxis, long *naxes) {
// this function writes a float array to a FITS image file
TRACE_ENTER();
// create new file
fitsfile *fptr;
int status = 0;
fits_create_file(&fptr, pathname.c_str(), &status);
if (status != 0) {
// cannot create the file
// likely, the file already exists
// try to open it, delete it and create it anew
// try to open the file
status = 0;
fits_open_file(&fptr, pathname.c_str(), READWRITE, &status);
if (status != 0) {
// cannot open the file, for some reason
return FORMAT_STATUS(status);
}
// try to delete the file
status = 0;
fits_delete_file(fptr, &status);
if (status != 0) {
// cannot delete the file, for some reason
return FORMAT_STATUS(status);
}
// try to create the file
status = 0;
fits_create_file(&fptr, pathname.c_str(), &status);
if (status != 0) {
// cannot create the file, for some reason
return FORMAT_STATUS(status);
}
}
// create the primary array image
fits_create_img(fptr, FLOAT_IMG, naxis, naxes, &status);
if (status != 0) {
return FORMAT_STATUS(status);
}
// write a keyword
fits_update_key(fptr, TFLOAT, name.c_str(), array, name.c_str(), &status);
if (status != 0) {
return FORMAT_STATUS(status);
}
// write the array of floats to the image
long fpixel = 1;
long nelements = 1;
for (int i = 0; i < naxis; i++) {
nelements = nelements * naxes[i];
}
fits_write_img(fptr, TFLOAT, fpixel, nelements, (void*)array, &status);
if (status != 0) {
return FORMAT_STATUS(status);
}
// close the file
fits_close_file(fptr, &status);
if (status != 0) {
return FORMAT_STATUS(status);
}
return "WRITE_OK";
}
void save_2d_image_potential(SimulationData &sim_data, double *potential, const char * fits_file_name) {
double *save_data;
save_data = (double*)mkl_malloc(sim_data.get_num_x() * sim_data.get_num_y() * sizeof(double), 64);
fitsfile *fptr;
int status = 0;
long fpixel = 1, naxis = 2, nelements;
long naxes[2] = {sim_data.get_num_y(), sim_data.get_num_x()};
for (int i = 0; i < sim_data.get_num_x(); ++i) {
for (int j = 0; j < sim_data.get_num_y(); ++j) {
save_data[i * sim_data.get_num_y() + j] = 0;
for (int k = 0; k < sim_data.get_num_z(); ++k) {
save_data[i * sim_data.get_num_y() + j] += potential[i * sim_data.get_num_y() * sim_data.get_num_z() + j * sim_data.get_num_z() + k];
}
}
}
fits_create_file(&fptr, fits_file_name, &status);
fits_create_img(fptr, DOUBLE_IMG, naxis, naxes, &status);
nelements = naxes[0] * naxes[1];
fits_write_img(fptr, TDOUBLE, fpixel, nelements, save_data, &status);
fits_close_file(fptr, &status);
fits_report_error(stderr, status);
mkl_free(save_data);
}
int CDfits_open_file( char *filename )
{
int status;
int bitpix = 8;
int naxis = 0;
long *naxes;
status = 0;
/* Open file */
fits_create_file( &cfitsptr, filename, &status );
/* Write primary header */
bitpix = 8;
naxis = 0;
fits_create_img( cfitsptr, bitpix, naxis, naxes, &status );
/* Add first keywords */
fits_update_key( cfitsptr, TSTRING, "HDRVER", "1.19", "Header version", &status);
fits_write_date( cfitsptr, &status);
new_file = 1;
return( status );
}
int fitscopy ( char *infile, char *outfile)
{
fitsfile *infptr, *outfptr; /* FITS file pointers defined in fitsio.h */
int status = 0, ii = 1; /* status must always be initialized = 0 */
/* Open the input file */
if ( !fits_open_file(&infptr, infile, READONLY, &status) )
{
/* Create the output file */
if ( !fits_create_file(&outfptr, outfile, &status) )
{
/* Copy every HDU until we get an error */
while( !fits_movabs_hdu(infptr, ii++, NULL, &status) )
fits_copy_hdu(infptr, outfptr, 0, &status);
/* Reset status after normal error */
if (status == END_OF_FILE) status = 0;
fits_close_file(outfptr, &status);
}
fits_close_file(infptr, &status);
}
/* if error occured, print out error message */
if (status) fits_report_error(stderr, status);
return(status);
}
void he_write_healpix_map(float **tmap,int nfields,long nside,char *fname)
{
fitsfile *fptr;
int ii,status=0;
char *ttype[]={"T","Q","U"};
char *tform[]={"1E","1E","1E"};
char *tunit[]={"mK","mK","mK"};
if((nfields!=1)&&(nfields!=3)) {
fprintf(stderr,"CRIME: nfields must be 1 or 3\n");
exit(1);
}
fits_create_file(&fptr,fname,&status);
fits_create_tbl(fptr,BINARY_TBL,0,nfields,ttype,tform,
tunit,"BINTABLE",&status);
fits_write_key(fptr,TSTRING,"PIXTYPE","HEALPIX","HEALPIX Pixelisation",
&status);
fits_write_key(fptr,TSTRING,"ORDERING","RING",
"Pixel ordering scheme, either RING or NESTED",&status);
fits_write_key(fptr,TLONG,"NSIDE",&nside,
"Resolution parameter for HEALPIX",&status);
fits_write_key(fptr,TSTRING,"COORDSYS","G",
"Pixelisation coordinate system",&status);
fits_write_comment(fptr,
"G = Galactic, E = ecliptic, C = celestial = equatorial",
&status);
for(ii=0;ii<nfields;ii++) {
fits_write_col(fptr,TFLOAT,ii+1,1,1,nside2npix(nside),tmap[ii],&status);
}
fits_close_file(fptr, &status);
}
/** Opens a FITS file.
* \param[in] fileName The name of the file to open.
* \param[in] openMode Mask defining how the file should be opened; bits are
* NDFileModeRead, NDFileModeWrite, NDFileModeAppend, NDFileModeMultiple
* \param[in] pArray A pointer to an NDArray; this is used to determine the array and attribute properties.
*/
asynStatus
NDFileFITS::openFile(const char *fileName, NDFileOpenMode_t openMode, NDArray *pArray) {
static const char *functionName = "openFile";
// We don't support reading yet
if (openMode & NDFileModeRead) return(asynError);
// We don't support opening an existing file for appending yet
if (openMode & NDFileModeAppend) return(asynError);
// At present only 16 bits unsigned images are valid.
if (pArray->dataType != NDUInt16) return(asynError);
//>>>>>>>>>>>>>>if (FITSType != 0) return(asynError);
fitsStatus = 0;
if(fits_create_file(&fitsFilePtr, fileName, &fitsStatus)) {// create new FITS file
// get the error description
fits_get_errstatus(fitsStatus, fits_status_str);
asynPrint(pasynUserSelf, ASYN_TRACE_ERROR,
"%s::%s error opening file %s error=%s\n",
driverName, functionName, fileName, fits_status_str);
fits_clear_errmsg();
return (asynError);
}
return(asynSuccess);
}
void save_data_in_fits_file(const char* file_name, double* data,
size_t num_of_elements)
{
fitsfile* file;
int status = 0;
char* ttype[] = { "SAMPLE" };
char* tform[] = { "1D" };
char* tunit[] = { "" };
if (fits_create_file(&file, file_name, &status) != 0)
goto error;
if (fits_create_tbl(file, BINARY_TBL, 0, 1, ttype, tform, tunit,
"DECOMPR", &status) != 0)
goto error;
if (fits_write_col(file, TDOUBLE, 1, 1, 1, num_of_elements, data,
&status) != 0)
goto error;
fits_close_file(file, &status);
return;
error:
fits_report_error(stderr, status);
if (file != NULL)
fits_close_file(file, &status);
exit(1);
}
int main(int argc, char *argv[])
{
fitsfile *infptr, *outfptr; /* FITS file pointers defined in fitsio.h */
int status = 0; /* status must always be initialized = 0 */
if (argc != 3)
{
printf("Usage: fitscopy inputfile outputfile\n");
printf("\n");
printf("Copy an input file to an output file, optionally filtering\n");
printf("the file in the process. This seemingly simple program can\n");
printf("apply powerful filters which transform the input file as\n");
printf("it is being copied. Filters may be used to extract a\n");
printf("subimage from a larger image, select rows from a table,\n");
printf("filter a table with a GTI time extension or a SAO region file,\n");
printf("create or delete columns in a table, create an image by\n");
printf("binning (histogramming) 2 table columns, and convert IRAF\n");
printf("format *.imh or raw binary data files into FITS images.\n");
printf("See the CFITSIO User's Guide for a complete description of\n");
printf("the Extended File Name filtering syntax.\n");
printf("\n");
printf("Examples:\n");
printf("\n");
printf("fitscopy in.fit out.fit (simple file copy)\n");
printf("fitscopy - - (stdin to stdout)\n");
printf("fitscopy in.fit[11:50,21:60] out.fit (copy a subimage)\n");
printf("fitscopy iniraf.imh out.fit (IRAF image to FITS)\n");
printf("fitscopy in.dat[i512,512] out.fit (raw array to FITS)\n");
printf("fitscopy in.fit[events][pi>35] out.fit (copy rows with pi>35)\n");
printf("fitscopy in.fit[events][bin X,Y] out.fit (bin an image) \n");
printf("fitscopy in.fit[events][col x=.9*y] out.fit (new x column)\n");
printf("fitscopy in.fit[events][gtifilter()] out.fit (time filter)\n");
printf("fitscopy in.fit[2][regfilter(\"pow.reg\")] out.fit (spatial filter)\n");
printf("\n");
printf("Note that it may be necessary to enclose the input file name\n");
printf("in single quote characters on the Unix command line.\n");
return(0);
}
/* Open the input file */
if ( !fits_open_file(&infptr, argv[1], READONLY, &status) )
{
/* Create the output file */
if ( !fits_create_file(&outfptr, argv[2], &status) )
{
/* copy the previous, current, and following HDUs */
fits_copy_file(infptr, outfptr, 1, 1, 1, &status);
fits_close_file(outfptr, &status);
}
fits_close_file(infptr, &status);
}
/* if error occured, print out error message */
if (status) fits_report_error(stderr, status);
return(status);
}
//----------------------------------------------------------------------------------
void sfits_to_lfits(char *source_fits,double *posx1, double *posx2, double *alpha1, double *alpha2,double ysc1,double ysc2, double dsi, int nlx, int nly, char *lensed_fits) {
fitsfile *fptr_in;
int status, nfound, anynull;
long naxes[2],fpixel,npixels, i, j, index;
float nullval;
status = 0;
fits_open_file(&fptr_in, source_fits, READONLY, &status);
fits_read_keys_lng(fptr_in, "NAXIS", 1, 2, naxes, &nfound, &status);
long nsx = naxes[0];
long nsy = naxes[1];
npixels = nsx*nsy;
fpixel = 1;
nullval = 0;
double *source_map = calloc(npixels,sizeof(double));
fits_read_img(fptr_in, TDOUBLE, fpixel, npixels, &nullval,
source_map, &anynull, &status);
fits_close_file(fptr_in, &status);
double *posy1 = calloc(nlx*nly,sizeof(double));
double *posy2 = calloc(nlx*nly,sizeof(double));
for(i=0;i<nlx;i++) for(j=0;j<nly;j++){
index = i*nlx+j;
posy1[index] = posx1[index]-alpha1[index];
posy2[index] = posx2[index]-alpha2[index];
}
double *lensed_map = calloc(nlx*nly,sizeof(double));
Interplation_on_source_plane(source_map,posy1,posy2,ysc1,ysc2,dsi,nsx,nsy,nlx,nly,lensed_map);
fitsfile *fptr_out;
int fpixel_out = fpixel;
long bitpix_out = DOUBLE_IMG;
long naxis_out = 2;
long npixels_out = nlx*nly;
long naxes_out[naxis_out];
naxes_out[0] = nlx;
naxes_out[1] = nly;
status = 0;
remove(lensed_fits);
fits_create_file(&fptr_out, lensed_fits, &status);
fits_create_img(fptr_out, bitpix_out, naxis_out, naxes_out, &status);
fits_write_img(fptr_out, TDOUBLE, fpixel_out, npixels_out, lensed_map, &status);
fits_close_file(fptr_out, &status);
free(posy1);
free(posy2);
}
void OutputFileFITS::create(const std::string &filename) {
int status = 0;
fits_create_file(&infptr, filename.c_str(), &status);
if (status)
throwException("Error in OutputFileFITS::create() ", status);
opened = true;
}
static void write_pixels(oskar_Mem* data, const char* filename,
int width, int height, int num_planes, int i_plane, int* status)
{
long naxes[3], firstpix[3], num_pix;
int dims_ok = 0;
fitsfile* f = 0;
if (*status) return;
if (oskar_file_exists(filename))
{
int naxis = 0, imagetype = 0;
fits_open_file(&f, filename, READWRITE, status);
fits_get_img_param(f, 3, &imagetype, &naxis, naxes, status);
if (naxis == 3 &&
naxes[0] == width &&
naxes[1] == height &&
naxes[2] == num_planes)
{
dims_ok = 1;
}
else
{
*status = 0;
fits_close_file(f, status);
remove(filename);
f = 0;
}
}
if (!dims_ok)
{
naxes[0] = width;
naxes[1] = height;
naxes[2] = num_planes;
fits_create_file(&f, filename, status);
fits_create_img(f, oskar_mem_is_double(data) ? DOUBLE_IMG : FLOAT_IMG,
3, naxes, status);
}
if (*status || !f)
{
if (f) fits_close_file(f, status);
*status = OSKAR_ERR_FILE_IO;
return;
}
num_pix = width * height;
firstpix[0] = 1;
firstpix[1] = 1;
firstpix[2] = 1 + i_plane;
if (i_plane < 0)
{
firstpix[2] = 1;
num_pix *= num_planes;
}
fits_write_pix(f, oskar_mem_is_double(data) ? TDOUBLE : TFLOAT,
firstpix, num_pix, oskar_mem_void(data), status);
fits_close_file(f, status);
}
void FitsFile::Create()
{
if(_isOpen) {
throw FitsIOException("File was opened twice");
} else {
int status = 0;
fits_create_file(&_fptr, (std::string("!") + _filename).c_str(), &status);
CheckStatus(status);
_isOpen = true;
}
}
/* This routine provides simple FITS writer. It uses the routines
* provided by the fitsTcl/cfitsio libraries
*
* NOTE : It will fail if the image already exists
*/
int ApogeeAltaManager::saveimage(unsigned short *src_buffer, char *filename, int nx, int ny)
{
fitsfile *fptr; /* pointer to the FITS file, defined in fitsio.h */
long fpixel, nelements;
unsigned short *array;
unsigned short *simg;
int status;
/* initialize FITS image parameters */
int bitpix = USHORT_IMG; /* 16-bit unsigned short pixel values */
long naxis = 2; /* 2-dimensional image */
long naxes[2];
naxes[0] = nx-bcols;
naxes[1] = ny;
array = src_buffer;
status = 0; /* initialize status before calling fitsio routines */
simg = (unsigned short *)CCD_locate_buffer(const_cast<char *>("stemp"),2,nx-bcols,ny,1,1);
if (fits_create_file(&fptr, filename, &status)) /* create new FITS file */
printerror( status ); /* call printerror if error occurs */
/* write the required keywords for the primary array image. */
/* Since bitpix = USHORT_IMG, this will cause cfitsio to create */
/* a FITS image with BITPIX = 16 (signed short integers) with */
/* BSCALE = 1.0 and BZERO = 32768. This is the convention that */
/* FITS uses to store unsigned integers. Note that the BSCALE */
/* and BZERO keywords will be automatically written by cfitsio */
/* in this case. */
if ( fits_create_img(fptr, bitpix, naxis, naxes, &status) )
printerror( status );
fpixel = 1; /* first pixel to write */
nelements = naxes[0] * naxes[1]; /* number of pixels to write */
if (bcols > 0)
{
dobiassubtract(src_buffer,simg,naxes[0],naxes[1]);
/* write the array of unsigned integers to the FITS file */
if ( fits_write_img(fptr, TUSHORT, fpixel, nelements, simg, &status) )
printerror( status );
} else
{
/* write the array of unsigned integers to the FITS file */
if ( fits_write_img(fptr, TUSHORT, fpixel, nelements, src_buffer, &status) )
printerror( status );
}
if ( fits_close_file(fptr, &status) ) /* close the file */
printerror( status );
return(status);
}
/**
* Saves the image to a FITS file using the cfitsio library.
*
* @param output_filename string, where to save the FITS file
* @param sx, integer, horizontal image size
* @param sy, integer, vertical image size
* @param data, rows of a two dimensional integer array, image data
* @return Zero on success, non-zero on failure.
*/
int camera_save_fits_image(char * output_filename, long sx, long sy, unsigned short * data) {
fitsfile *fptr;
int status = 0;
long fpixel, nelements;
float gain;
int bitpix = USHORT_IMG;
long naxis = 2;
long naxes[2] = {sx, sy};
/* Delete old file if it already exists */
remove(output_filename);
/* create new FITS file */
if (fits_create_file(&fptr, output_filename, &status)) {
if (status) fits_report_error(stderr, status);
return status;
}
/* the setting of bitpix = USHORT_IMG implies that BITPIX = 16,
BSCALE = 1.0 and BZERO = 32768, and the latter two keywords are
added automatically. */
if (fits_create_img(fptr, bitpix, naxis, naxes, &status)) {
if (status) fits_report_error(stderr, status);
return status;
}
/* first pixel to write */
fpixel = 1;
/* number of pixels to write */
nelements = naxes[0] * naxes[1];
/* write the array of unsigned integers to the FITS file */
if (fits_write_img(fptr, TUSHORT, fpixel, nelements, data, &status)) {
if (status) fits_report_error(stderr, status);
return status;
}
/* write the gain parameter of the camera to the header */
gain = ML16803_CAMERA_GAIN;
if (fits_update_key(fptr, TFLOAT, "GAIN", &gain, "Camera gain of ML16803", &status)) {
if (status) fits_report_error(stderr, status);
return status;
}
/* close the file */
if (fits_close_file(fptr, &status)) {
if (status) fits_report_error(stderr, status);
return status;
}
return 0;
}
void writeFITS(const cv::Mat& cvImage, const std::string& filename)
{
if(cvImage.channels() != 1)
{
CustomException("writeFITS: Only able to write FITS from single channel images.");
}
fitsfile *fptr; //pointer to the FITS file defined in fitsioh
int status;
char err_text[100];
cv::Mat floatImg = cv::Mat_<float>(cvImage);
long fpixel = 1, naxis = 2, nelements;
long naxes[2] = {cvImage.cols, cvImage.rows};
float array[cvImage.cols][cvImage.rows];
for(int i = 0;i < floatImg.rows ;i++)
{
for(int j = 0;j < floatImg.cols ;j++)
{
array[j][i] = floatImg.at<float>(j,i);
}
}
status=0;
fits_create_file(&fptr, filename.c_str(), &status);
if (status)
{
fits_report_error(stdout, status);
fits_get_errstatus(status,err_text);
fptr = nullptr;
throw CustomException("writeFITS: Cannot create fits file.");
}
fits_create_img(fptr, FLOAT_IMG, naxis, naxes, &status);
if (status)
{
fits_report_error(stdout, status);
fits_get_errstatus(status,err_text);
fptr = nullptr;
throw CustomException("writeFITS: Cannot create image file.");
}
nelements = naxes[0] * naxes[1];
fits_write_img(fptr, TFLOAT, fpixel, nelements, array[0], &status);
if (status)
{
fits_report_error(stdout, status);
fits_get_errstatus(status,err_text);
fptr = nullptr;
throw CustomException("writeFITS: Cannot write image file.");
}
fits_close_file(fptr, &status);
fits_report_error(stderr, status);
}
fitsfile* create_fits_file(const char* filename, int precision,
int width, int height, int num_times, int num_channels,
double centre_deg[2], double fov_deg[2], double start_time_mjd,
double delta_time_sec, double start_freq_hz, double delta_freq_hz,
int* status)
{
long naxes[4];
double delta;
fitsfile* f = 0;
FILE* t = 0;
if (*status) return 0;
/* Create a new FITS file and write the image headers. */
t = fopen(filename, "rb");
if (t)
{
fclose(t);
remove(filename);
}
naxes[0] = width;
naxes[1] = height;
naxes[2] = num_channels;
naxes[3] = num_times;
fits_create_file(&f, filename, status);
fits_create_img(f, (precision == OSKAR_DOUBLE ? DOUBLE_IMG : FLOAT_IMG),
4, naxes, status);
fits_write_date(f, status);
/* Write axis headers. */
delta = oskar_convert_fov_to_cellsize(fov_deg[0] * M_PI/180, width) * 180/M_PI;
write_axis_header(f, 1, "RA---SIN", "Right Ascension",
centre_deg[0], -delta, width / 2 + 1, 0.0, status);
delta = oskar_convert_fov_to_cellsize(fov_deg[1] * M_PI/180, height) * 180/M_PI;
write_axis_header(f, 2, "DEC--SIN", "Declination",
centre_deg[1], delta, height / 2 + 1, 0.0, status);
write_axis_header(f, 3, "FREQ", "Frequency",
start_freq_hz, delta_freq_hz, 1.0, 0.0, status);
write_axis_header(f, 4, "UTC", "Time",
start_time_mjd, delta_time_sec, 1.0, 0.0, status);
/* Write other headers. */
fits_write_key_str(f, "BUNIT", "JY/BEAM", "Brightness units", status);
fits_write_key_str(f, "TIMESYS", "UTC", NULL, status);
fits_write_key_str(f, "TIMEUNIT", "s", "Time axis units", status);
fits_write_key_dbl(f, "MJD-OBS", start_time_mjd, 10, "Start time", status);
fits_write_key_dbl(f, "OBSRA", centre_deg[0], 10, "RA", status);
fits_write_key_dbl(f, "OBSDEC", centre_deg[1], 10, "DEC", status);
/*fits_flush_file(f, status);*/
return f;
}
int write_fits(char* path,unsigned char* image)
{
fitsfile *fptrout;
unsigned int naxis = 2;
long naxes[2];
int status = 0;
long nelements = width*height;
naxes[0] = width;
naxes[1] = height;
fits_create_file(&fptrout,path, &status);
fits_create_img(fptrout, BYTE_IMG, naxis, naxes, &status);
fits_write_img(fptrout, TBYTE, 1, nelements, image, &status);
fits_close_file(fptrout, &status);
}
int main(int argc, char *argv[])
{
fitsfile *infptr, *outfptr;
int status = 0, hdutype, ii;
char infile[FLEN_FILENAME],outfile[FLEN_FILENAME];
if (argc != 3)
{
printf("Usage: fitscopy inputfile outputfile\n");
return(1);
}
strcpy(infile, argv[1] );
strcpy(outfile, argv[2] );
if ( fits_open_file(&infptr, infile, READONLY, &status) )
{
fits_report_error(stderr, status);
return(status);
}
if ( fits_create_file(&outfptr, outfile, &status) )
{
fits_close_file(infptr, &status);
fits_report_error(stderr, status);
return(status);
}
/* attempt to move to next HDU, until we get an EOF error */
for (ii = 1; !(fits_movabs_hdu(infptr, ii, &hdutype, &status) ); ii++)
{
if ( fits_copy_hdu(infptr, outfptr, 0, &status) )
{
fits_report_error(stderr, status);
break;
}
}
if (status == END_OF_FILE)
status = 0; /* got the expected EOF error; reset = 0 */
fits_close_file(infptr, &status);
fits_close_file(outfptr, &status);
if (status)
fits_report_error(stderr, status);
return(0);
}
void save_3d_image(SimulationData &sim_data, WaveFunction &psi, const char * fits_file_name) {
fitsfile *fptr;
int status = 0;
long fpixel = 1, naxis = 3, nelements;
long naxes[3] = {sim_data.get_num_x(), sim_data.get_num_y(), sim_data.get_num_z()};
fits_create_file(&fptr, fits_file_name, &status);
fits_create_img(fptr, DOUBLE_IMG, naxis, naxes, &status);
nelements = naxes[0] * naxes[1] * naxes[2];
fits_write_img(fptr, TDOUBLE, fpixel, nelements, psi.abs_psi, &status);
fits_close_file(fptr, &status);
fits_report_error(stderr, status);
}
int nemo_main(void)
{
fitsfile *fptr; /* pointer to the FITS file; defined in fitsio.h */
int status, ii, jj;
long fpixel = 1, naxis = 2, nelements, exposure;
long naxes[2] = { 300, 200 }; /* image is 300 pixels wide by 200 rows */
short array[200][300];
string fname = getparam("out");
float time4 = PI;
double time8 = PI;
status = 0; /* initialize status before calling fitsio routines */
fits_create_file(&fptr, fname, &status); /* create new file */
/* Create the primary array image (16-bit short integer pixels */
fits_create_img(fptr, SHORT_IMG, naxis, naxes, &status);
/* Write a keyword; must pass the ADDRESS of the value */
exposure = 1500.;
fits_update_key(fptr, TLONG, "EXPOSURE", &exposure,
"Total Exposure Time", &status);
dprintf(1,"exposure %d\n",status);
fits_update_key(fptr, TFLOAT, "TIME4", &time4,
"Sample REAL*4", &status);
dprintf(1,"time4 %d\n",status);
fits_update_key(fptr, TDOUBLE, "TIME8", &time8,
"Sample REAL*8", &status);
dprintf(1,"time8 %d\n",status);
fits_update_key(fptr, TSTRING, "DATEOBS", "2001/09/30",
"Sample STRING", &status);
dprintf(1,"string %d\n",status);
/* Initialize the values in the image with a linear ramp function */
for (jj = 0; jj < naxes[1]; jj++)
for (ii = 0; ii < naxes[0]; ii++)
array[jj][ii] = ii + jj;
nelements = naxes[0] * naxes[1]; /* number of pixels to write */
/* Write the array of integers to the image */
fits_write_img(fptr, TSHORT, fpixel, nelements, array[0], &status);
fits_close_file(fptr, &status); /* close the file */
fits_report_error(stderr, status); /* print out any error messages */
return status ;
}
local void print_ccd(real **ccd, char filename[], real t_exposure) {
fitsfile *fptr;
int status, ii, jj;
long fpixel, nelements, exposure;
// unsigned short array[512][512];
unsigned short array[XCCD_MAX][YCCD_MAX];
// char filename[] = "ccd.fit";
int bitpix = USHORT_IMG;
long naxis = 2;
// long naxes[2] = { 512, 512 };
long naxes[2] = { XCCD_MAX, YCCD_MAX };
remove(filename);
status = 0;
if (fits_create_file(&fptr, filename, &status))
printf("%s\n", status);
if ( fits_create_img(fptr, bitpix, naxis, naxes, &status) )
printf("%s\n", status);
float val;
for (jj = 0; jj < naxes[1]; jj++) {
for (ii = 0; ii < naxes[0]; ii++) {
// cin >> val;
array[jj][ii] = (unsigned short)ccd[jj][ii];
}
}
fpixel = 1;
nelements = naxes[0] * naxes[1];
if ( fits_write_img(fptr, TUSHORT, fpixel, nelements, array[0], &status) )
printf("%s\n", status);
exposure = long(t_exposure);
if ( fits_update_key(fptr, TLONG, "EXPOSURE", &exposure,
"Exposure time in seconds", &status) )
printf("%s\n", status);
if ( fits_close_file(fptr, &status) )
printf("%s\n", status);
}
int write_map(const char *filename, double *intensity, double *q, double *u, long nrows)
{
fitsfile *fptr;
int status = 0;
int hdutype;
int tfields=3;
char extname[] = "BINTABLE"; /* extension name */
char *ttype[] = { "I","Q","U" };
char *tform[] = { "1E","1E","1E" };
char *tunit[] = { " "," ", " " };
if (fits_create_file(&fptr, filename, &status))
fprintf(stderr, "%s (%d): Could not create new fits file.\n",
__FILE__, __LINE__);
/* move to 1st HDU */
fits_movabs_hdu(fptr, 1, &hdutype, &status);
//long nrows = 12L*nside*nside*2;
//long nside = sqrtl(nrows/12L);
long nside = 1024; //FIXME compute it
/* append a new empty binary table onto the FITS file */
fits_create_tbl( fptr, BINARY_TBL, nrows, tfields, ttype, tform,
tunit, extname, &status);
fits_write_key(fptr, TSTRING, "ORDERING", "NESTED",
"Pixel ordering scheme, either RING or NESTED", &status);
fits_write_key(fptr, TLONG, "NSIDE", &nside, "Resolution parameter for HEALPIX", &status);
long firstrow = 1; /* first row in table to write */
long firstelem = 1; /* first element in row (ignored in ASCII tables) */
if (fits_write_col(fptr, TDOUBLE, 1, firstrow, firstelem, nrows, intensity,
&status))
fprintf(stderr, "%s (%d): Could not write signal.\n", __FILE__, __LINE__);
if (fits_write_col(fptr, TDOUBLE, 2, firstrow, firstelem, nrows, q,
&status))
fprintf(stderr, "%s (%d): Could not write signal.\n", __FILE__, __LINE__);
if (fits_write_col(fptr, TDOUBLE, 3, firstrow, firstelem, nrows, u,
&status))
fprintf(stderr, "%s (%d): Could not write signal.\n", __FILE__, __LINE__);
fits_close_file(fptr, &status);
return true;
}
static VipsFits *
vips_fits_new_write( VipsImage *in, const char *filename )
{
VipsFits *fits;
int status;
status = 0;
if( !(fits = VIPS_NEW( in, VipsFits )) )
return( NULL );
fits->filename = vips_strdup( VIPS_OBJECT( in ), filename );
fits->image = in;
fits->fptr = NULL;
fits->lock = NULL;
fits->band_select = -1;
fits->buffer = NULL;
g_signal_connect( in, "close",
G_CALLBACK( vips_fits_close_cb ), fits );
if( !(fits->filename = vips_strdup( NULL, filename )) )
return( NULL );
/* We need to be able to hold one scanline of one band.
*/
if( !(fits->buffer = VIPS_ARRAY( NULL,
VIPS_IMAGE_SIZEOF_ELEMENT( in ) * in->Xsize, VipsPel )) )
return( NULL );
/* fits_create_file() will fail if there's a file of thet name, unless
* we put a "!" in front ofthe filename. This breaks conventions with
* the rest of vips, so just unlink explicitly.
*/
g_unlink( filename );
if( fits_create_file( &fits->fptr, filename, &status ) ) {
vips_error( "fits",
_( "unable to write to \"%s\"" ), filename );
vips_fits_error( status );
return( NULL );
}
fits->lock = vips_g_mutex_new();
return( fits );
}
int write2Dfits(char *fname, double *f, int pwidth, int pheight)
{
/* write out image as a fits file */
fitsfile *afptr;
int status = 0;
int anaxis;
long anaxes[2], fpixel[2]={1,1};
int bitpix;
int size;
bitpix = -32;
anaxis = 2;
anaxes[0] = pwidth;
anaxes[1] = pheight;
size = anaxes[0]*anaxes[1];
fits_create_file(&afptr, fname, &status);
fits_create_img(afptr, bitpix, anaxis, anaxes, &status);
if (status) {
fits_report_error(stderr, status); /* print error message */
return(status);
}
/* write all data into image array */
if (fits_write_pix(afptr, TDOUBLE, fpixel, size, f, &status) )
{
printf(" error reading pixel data \n");
exit (2);
}
/* close the fits file */
fits_close_file(afptr, &status);
if (status) {
fits_report_error(stderr, status); /* print error message */
exit(2);
}
return 0;
}
//----------------------------------------------------------------------------------
void save_to_fits(double *lensed_map, int nlx, int nly, char *lensed_fits) {
fitsfile *fptr_out;
int fpixel_out = 1;
long bitpix_out = DOUBLE_IMG;
long naxis_out = 2;
long npixels_out = nlx*nly;
long naxes_out[naxis_out];
naxes_out[0] = nlx;
naxes_out[1] = nly;
int status = 0;
remove(lensed_fits);
fits_create_file(&fptr_out, lensed_fits, &status);
fits_create_img(fptr_out, bitpix_out, naxis_out, naxes_out, &status);
fits_write_img(fptr_out, TDOUBLE, fpixel_out, npixels_out, lensed_map, &status);
fits_close_file(fptr_out, &status);
}
void writeimage(const image_t *image, const char *filename) {
if (debug) {
fprintf(stderr, "%s:%d: writing image %s\n", __FILE__, __LINE__,
filename);
}
char errmsg[80];
int status = 0;
fitsfile *fits = NULL;
if (fits_create_file(&fits, filename, &status)) {
fits_get_errstatus(status, errmsg);
fprintf(stderr, "cannot create fits file %s: %s\n",
filename, errmsg);
return;
}
// find dimensions of pixel array
int naxis = 2;
long naxes[2] = { image->width, image->height };
if (fits_create_img(fits, DOUBLE_IMG, naxis, naxes, &status)) {
fits_get_errstatus(status, errmsg);
fprintf(stderr, "cannot create image: %s\n", errmsg);
goto bad;
}
// read the pixel data
long npixels = image->width * image->height;
long firstpixel[3] = { 1, 1, 1 };
if (fits_write_pix(fits, TDOUBLE, firstpixel, npixels,
image->data, &status)) {
fits_get_errstatus(status, errmsg);
fprintf(stderr, "cannot write pixel data: %s\n", errmsg);
}
bad:
// close the file
if (fits_close_file(fits, &status)) {
fits_get_errstatus(status, errmsg);
fprintf(stderr, "cannot close fits file %s: %s\n",
filename, errmsg);
goto bad;
}
}
void write_output(const char* filename, size_t width, size_t height, size_t noutput, cl_float* output[], const char* names[])
{
int status = 0;
// the FITS file
fitsfile* fptr;
// create FITS file
fits_create_file(&fptr, filename, &status);
// write FITS file
write_fits(fptr, TFLOAT, width, height, noutput, (void**)output, names, &status);
// close FITS file
fits_close_file(fptr, &status);
// report FITS errors
if(status)
fits_error(filename, status);
}
int WriteFITS(unsigned short *buffer, int cols, int rows, char *filename) {
#ifdef HAVE_FITSIO_H
int status = 0;
fitsfile *fits;
unlink(filename);
fits_create_file(&fits, filename, &status);
if (status) {
std::cerr << "cannot create file " << filename << std::endl;
return -1;
}
long naxes[2] = { cols, rows };
fits_create_img(fits, SHORT_IMG, 2, naxes, &status);
long fpixel[2] = { 1, 1 };
fits_write_pix(fits, TUSHORT, fpixel, cols * rows, buffer, &status);
fits_close_file(fits, &status);
#else
std::cerr << "FITS not supported" << std::endl;
return -1;
#endif
}
void save_file( const std::string& filename, const image_type& img ) {
fitsfile* f;
int status = 0;
std::string fname = "!" + filename;
fits_create_file( &f, fname.c_str(), &status );
long dims[2];
dims[0] = img.extents.first; dims[1] = img.extents.second;
typedef CFitsIOTypeMap< image_type::element > map;
fits_create_img( f, map::image_type, 2, dims, &status );
fits_write_img( f, map::type, 1, img.num_elements(),
(void*)img.ptr(), &status );
fits_close_file( f, &status );
if( status ) {
fits_report_error( stderr, status );
}
}
void makebasisfile( int kk, int datax, int slice, void *address )
{
long int bitpix = -32, nElements, naxis = 2, naxes[2], fpixel = 1;
fitsfile *fptr; /* pointer to output FITS files; defined in fitsio.h */
int status = 0;
char tname[128];
/* Initialize FITS image parameters */
/* First build the file name. */
(void)strcpy( tname, "basis" );
(void)sprintf( strBuf, "%d", kk+1 );
(void)strcat( tname, strBuf );
(void)strcat( tname, ".fits" );
(void)printf( "tname = %s\n", tname );
naxes[0] = datax; /* datax pixels wide */
naxes[1] = slice; /* by slice rows */
if ( fits_create_file( &fptr, tname, &status ) ) { /* Create new FITS file */
printerror( status, __LINE__ );
}
/* Write the required keywords for the primary array image */
if ( fits_create_img( fptr, bitpix, naxis, naxes, &status ) ) {
printerror( status, __LINE__ );
}
nElements = naxes[0] * naxes[1]; /* number of pixels to write */
/* Write the array of floats to the file. */
if ( fits_write_img(fptr, TFLOAT, fpixel, nElements, address, &status) ) {
printerror( status, __LINE__ );
}
if ( fits_close_file(fptr, &status) ) { /* close the file */
printerror( status, __LINE__ );
}
return;
}
