int readFits(char *fluxfile)
{
int status, nfound;
long naxes[2];
double crpix[2];
char errstr[MAXSTR];
status = 0;
checkHdr(fluxfile, 0, 0);
if(fits_open_file(&input.fptr, fluxfile, READONLY, &status))
{
sprintf(errstr, "Image file %s missing or invalid FITS", fluxfile);
printError(errstr);
}
if(fits_read_keys_lng(input.fptr, "NAXIS", 1, 2, naxes, &nfound, &status))
printFitsError(status);
input.naxes[0] = naxes[0];
input.naxes[1] = naxes[1];
if(fits_read_keys_dbl(input.fptr, "CRPIX", 1, 2, crpix, &nfound, &status))
printFitsError(status);
input.crpix1 = crpix[0];
input.crpix2 = crpix[1];
return 0;
}
//----------------------------------------------------------------------------------
double *read_from_fits(char *source_fits, long *nsx, long *nsy) {
fitsfile *fptr_in;
int status, nfound, anynull;
long naxes[2],fpixel,npixels;
double nullval;
status = 0;
fits_open_file(&fptr_in, source_fits, READONLY, &status);
fits_read_keys_lng(fptr_in, "NAXIS", 1, 2, naxes, &nfound, &status);
*nsx = naxes[0];
*nsy = naxes[1];
npixels = naxes[0]*naxes[1];
fpixel = 1;
nullval = 0;
double *source_map = (double *)calloc(npixels,sizeof(double));
fits_read_img(fptr_in, TDOUBLE, fpixel, npixels, &nullval,source_map, &anynull, &status);
fits_close_file(fptr_in, &status);
return source_map;
}
//----------------------------------------------------------------------------------
double *read_from_fits(char *source_fits) {
fitsfile *fptr_in;
int status, nfound, anynull;
long naxes[2],fpixel,npixels;
double nullval;
status = 0;
fits_open_file(&fptr_in, source_fits, READONLY, &status);
fits_read_keys_lng(fptr_in, "NAXIS", 1, 2, naxes, &nfound, &status);
npixels = naxes[0]*naxes[1];
fpixel = 1;
nullval = 0;
double *source_map = (double *)calloc(npixels,sizeof(double));
fits_read_img(fptr_in, TDOUBLE, fpixel, npixels, &nullval,source_map, &anynull, &status);
fits_close_file(fptr_in, &status);
double *source_map_struct;
source_map_struct = (double *)calloc((npixels+2),sizeof(double));
source_map_struct[0] = (double)naxes[0];
source_map_struct[1] = (double)naxes[1];
long i,j,index;
for (i=0;i<naxes[0];i++)for (j=0;j<naxes[1];j++) {
index = i*naxes[1]+j;
source_map_struct[index+2]=source_map[index];
}
free(source_map);
return source_map_struct;
}
flouble *he_read_healpix_map(char *fname,long *nside,int nfield)
{
//////
// Reads a healpix map from file fname. The map will be
// read from column #nfield. It also returns the map's nside.
int status=0,hdutype,nfound,anynul;
long naxes,*naxis,npix;
fitsfile *fptr;
flouble *map,nulval;
char order_in_file[32];
int nested_in_file=0;
fits_open_file(&fptr,fname,READONLY,&status);
fits_movabs_hdu(fptr,2,&hdutype,&status);
fits_read_key_lng(fptr,"NAXIS",&naxes,NULL,&status);
naxis=(long *)malloc(naxes*sizeof(long));
fits_read_keys_lng(fptr,"NAXIS",1,naxes,naxis,&nfound,&status);
fits_read_key_lng(fptr,"NSIDE",nside,NULL,&status);
npix=12*(*nside)*(*nside);
if(npix%naxis[1]!=0) {
fprintf(stderr,"CRIME: WTFFF\n");
exit(1);
}
if (fits_read_key(fptr, TSTRING, "ORDERING", order_in_file, NULL, &status)) {
fprintf(stderr, "WARNING: Could not find %s keyword in in file %s\n",
"ORDERING",fname);
exit(1);
}
if(!strncmp(order_in_file,"NEST",4))
nested_in_file=1;
map=(flouble *)my_malloc(npix*sizeof(flouble));
#ifdef _SPREC
fits_read_col(fptr,TFLOAT,nfield+1,1,1,npix,&nulval,map,&anynul,&status);
#else //_SPREC
fits_read_col(fptr,TDOUBLE,nfield+1,1,1,npix,&nulval,map,&anynul,&status);
#endif //_SPREC
free(naxis);
fits_close_file(fptr,&status);
flouble *map_ring;
if(nested_in_file) {
long ipring,ipnest;
printf("read_healpix_map: input is nested. Transforming to ring.\n");
map_ring=(flouble *)my_malloc(npix*sizeof(flouble));
for(ipnest=0;ipnest<npix;ipnest++) {
nest2ring(*nside,ipnest,&ipring);
map_ring[ipring]=map[ipnest];
}
free(map);
}
else
map_ring=map;
return map_ring;
}
//----------------------------------------------------------------------------------
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);
}
struct WorldCoor *montage_getFileInfo(fitsfile *infptr, char *header[], struct imageParams *params)
{
struct WorldCoor *wcs;
int status = 0;
int i;
if(fits_get_image_wcs_keys(infptr, header, &status))
montage_printFitsError(status);
if(fits_read_key_lng(infptr, "NAXIS", ¶ms->naxis, (char *)NULL, &status))
montage_printFitsError(status);
if(fits_read_keys_lng(infptr, "NAXIS", 1, params->naxis, params->naxes, ¶ms->nfound, &status))
montage_printFitsError(status);
if(debug)
{
for(i=0; i<params->naxis; ++i)
printf("naxis%d = %ld\n", i+1, params->naxes[i]);
fflush(stdout);
}
/****************************************/
/* Initialize the WCS transform library */
/* and find the pixel location of the */
/* sky coordinate specified */
/****************************************/
wcs = wcsinit(header[0]);
params->isDSS = 0;
if(wcs->prjcode == WCS_DSS)
params->isDSS = 1;
if(wcs == (struct WorldCoor *)NULL)
{
fprintf(fstatus, "[struct stat=\"ERROR\", msg=\"Output wcsinit() failed.\"]\n");
fflush(stdout);
exit(1);
}
/* Extract the CRPIX and (equivalent) CDELT values */
/* from the WCS structure */
params->crpix[0] = wcs->xrefpix;
params->crpix[1] = wcs->yrefpix;
if(params->isDSS)
{
params->cnpix[0] = wcs->x_pixel_offset;
params->cnpix[1] = wcs->y_pixel_offset;
}
return wcs;
}
//----------------------------------------------------------------------------------
long *read_shape_fits(char *source_fits) {
fitsfile *fptr_in;
int status, nfound;
long *naxes = (long *)malloc(2*sizeof(long));
status = 0;
fits_open_file(&fptr_in, source_fits, READONLY, &status);
fits_read_keys_lng(fptr_in, "NAXIS", 1, 2, naxes, &nfound, &status);
return naxes;
}
void montage_dataRange(fitsfile *infptr, int *imin, int *imax, int *jmin, int *jmax)
{
long fpixel[4];
long naxis, naxes[10];
int i, j, nullcnt, nfound;
double *buffer;
int status = 0;
/*************************************************/
/* Make a NaN value to use checking blank pixels */
/*************************************************/
union
{
double d;
char c[8];
}
value;
double nan;
for(i=0; i<8; ++i)
value.c[i] = 255;
nan = value.d;
if(fits_read_key_lng(infptr, "NAXIS", &naxis, (char *)NULL, &status))
montage_printFitsError(status);
if(fits_read_keys_lng(infptr, "NAXIS", 1, naxis, naxes, &nfound, &status))
montage_printFitsError(status);
fpixel[0] = 1;
fpixel[1] = 1;
fpixel[2] = 1;
fpixel[3] = 1;
*imin = 1000000000;
*imax = -1;
*jmin = 1000000000;
*jmax = -1;
buffer = (double *)malloc(naxes[0] * sizeof(double));
for (j=1; j<=naxes[1]; ++j)
{
if(debug >= 2)
{
printf("Processing image row %5d\n", j);
fflush(stdout);
}
if(fits_read_pix(infptr, TDOUBLE, fpixel, naxes[0], &nan,
buffer, &nullcnt, &status))
montage_printFitsError(status);
for(i=1; i<=naxes[0]; ++i)
{
if(!mNaN(buffer[i-1]))
{
if(buffer[i-1] != nan)
{
if(i < *imin) *imin = i;
if(i > *imax) *imax = i;
if(j < *jmin) *jmin = j;
if(j > *jmax) *jmax = j;
}
}
}
++fpixel [1];
}
free(buffer);
}
struct mExamineReturn * mExamine(char *infile, int areaMode, int hdu, int plane3, int plane4,
double ra, double dec, double radius, int locinpix, int radinpix, int debug)
{
int i, j, offscl, nullcnt;
int status, clockwise, nfound;
int npix, nnull, first;
int ixpix, iypix;
int maxi, maxj;
char *header;
char tmpstr[32768];
char proj[32];
int csys;
char csys_str[64];
char ctype1[256];
char ctype2[256];
double equinox;
long naxis;
long naxes[10];
double naxis1;
double naxis2;
double crval1;
double crval2;
double crpix1;
double crpix2;
double cdelt1;
double cdelt2;
double crota2;
double lon, lat;
double lonc, latc;
double rac, decc;
double racp, deccp;
double ra1, dec1, ra2, dec2, ra3, dec3, ra4, dec4;
double xpix, ypix, rpix, rap;
double x, y, z;
double xp, yp, zp;
double rot, beta, dtr;
double r;
double sumflux, sumflux2, sumn, mean, background, oldbackground, rms, dot;
double sigmaref, sigmamax, sigmamin;
double val, valx, valy, valra, valdec;
double min, minx, miny, minra, mindec;
double max, maxx, maxy, maxra, maxdec;
double x0, y0, z0;
double fluxMin, fluxMax, fluxRef, sigma;
struct WorldCoor *wcs;
fitsfile *fptr;
int ibegin, iend, jbegin, jend;
long fpixel[4], nelements;
double *data = (double *)NULL;
struct apPhoto *ap = (struct apPhoto *)NULL;
int nflux, maxflux;
struct mExamineReturn *returnStruct;
returnStruct = (struct mExamineReturn *)malloc(sizeof(struct mExamineReturn));
memset((void *)returnStruct, 0, sizeof(returnStruct));
returnStruct->status = 1;
strcpy(returnStruct->msg, "");
nflux = 0;
maxflux = MAXFLUX;
/************************************************/
/* Make a NaN value to use setting blank pixels */
/************************************************/
union
{
double d;
char c[8];
}
value;
double nan;
for(i=0; i<8; ++i)
value.c[i] = (char)255;
nan = value.d;
dtr = atan(1.)/45.;
/* Process basic command-line arguments */
if(debug)
{
printf("DEBUG> areaMode = %d \n", areaMode);
printf("DEBUG> infile = %s \n", infile);
printf("DEBUG> ra = %-g\n", ra);
printf("DEBUG> dec = %-g\n", dec);
printf("DEBUG> radius = %-g\n", radius);
fflush(stdout);
}
rpix = 0.;
if(areaMode == APPHOT)
ap = (struct apPhoto *)malloc(maxflux * sizeof(struct apPhoto));
/* Open the FITS file and initialize the WCS transform */
status = 0;
if(fits_open_file(&fptr, infile, READONLY, &status))
{
if(ap) free(ap);
sprintf(returnStruct->msg, "Cannot open FITS file %s", infile);
return returnStruct;
}
if(hdu > 0)
{
status = 0;
if(fits_movabs_hdu(fptr, hdu+1, NULL, &status))
{
if(ap) free(ap);
sprintf(returnStruct->msg, "Can't find HDU %d", hdu);
return returnStruct;
}
}
status = 0;
if(fits_get_image_wcs_keys(fptr, &header, &status))
{
if(ap) free(ap);
sprintf(returnStruct->msg, "Cannot find WCS keys in FITS file %s", infile);
return returnStruct;
}
status = 0;
if(fits_read_key_lng(fptr, "NAXIS", &naxis, (char *)NULL, &status))
{
if(ap) free(ap);
sprintf(returnStruct->msg, "Cannot find NAXIS keyword in FITS file %s", infile);
return returnStruct;
}
status = 0;
if(fits_read_keys_lng(fptr, "NAXIS", 1, naxis, naxes, &nfound, &status))
{
if(ap) free(ap);
sprintf(returnStruct->msg, "Cannot find NAXIS1,2 keywords in FITS file %s", infile);
return returnStruct;
}
wcs = wcsinit(header);
if(wcs == (struct WorldCoor *)NULL)
{
if(ap) free(ap);
sprintf(returnStruct->msg, "WCS initialization failed.");
return returnStruct;
}
/* A bunch of the parameters we want are in the WCS structure */
clockwise = 0;
strcpy(ctype1, wcs->ctype[0]);
strcpy(ctype2, wcs->ctype[1]);
naxis1 = wcs->nxpix;
naxis2 = wcs->nypix;
crval1 = wcs->xref;
crval2 = wcs->yref;
crpix1 = wcs->xrefpix;
crpix2 = wcs->yrefpix;
cdelt1 = wcs->xinc;
cdelt2 = wcs->yinc;
crota2 = wcs->rot;
if((cdelt1 < 0 && cdelt2 < 0)
|| (cdelt1 > 0 && cdelt2 > 0)) clockwise = 1;
strcpy(proj, "");
if(strlen(ctype1) > 5)
strcpy (proj, ctype1+5);
/* We get the Equinox from the WCS. If not */
/* there we take the command-line value. We */
/* then infer Julian/Besselian as best we can. */
equinox = wcs->equinox;
csys = EQUJ;
strcpy(csys_str, "EQUJ");
if(strncmp(ctype1, "RA--", 4) == 0)
{
csys = EQUJ;
strcpy(csys_str, "EQUJ");
if(equinox < 1975.)
{
csys = EQUB;
strcpy(csys_str, "EQUB");
}
}
if(strncmp(ctype1, "LON-", 4) == 0)
{
csys = GAL;
strcpy(csys_str, "GAL");
}
if(strncmp(ctype1, "GLON", 4) == 0)
{
csys = GAL;
strcpy(csys_str, "GAL");
}
if(strncmp(ctype1, "ELON", 4) == 0)
{
csys = ECLJ;
strcpy(csys_str, "ECLJ");
if(equinox < 1975.)
{
csys = ECLB;
strcpy(csys_str, "ECLB");
}
}
if(debug)
{
printf("DEBUG> proj = [%s]\n", proj);
printf("DEBUG> csys = %d\n", csys);
printf("DEBUG> clockwise = %d\n", clockwise);
printf("DEBUG> ctype1 = [%s]\n", ctype1);
printf("DEBUG> ctype2 = [%s]\n", ctype2);
printf("DEBUG> equinox = %-g\n", equinox);
printf("\n");
fflush(stdout);
}
/* To get corners and rotation in EQUJ we need the */
/* locations of the center pixel and the one above it. */
pix2wcs(wcs, wcs->nxpix/2.+0.5, wcs->nypix/2.+0.5, &lonc, &latc);
convertCoordinates (csys, equinox, lonc, latc,
EQUJ, 2000., &rac, &decc, 0.);
pix2wcs(wcs, wcs->nxpix/2.+0.5, wcs->nypix/2.+1.5, &lonc, &latc);
convertCoordinates (csys, equinox, lonc, latc,
EQUJ, 2000., &racp, &deccp, 0.);
/* Use spherical trig to get the Equatorial rotation angle */
x = cos(decc*dtr) * cos(rac*dtr);
y = cos(decc*dtr) * sin(rac*dtr);
z = sin(decc*dtr);
xp = cos(deccp*dtr) * cos(racp*dtr);
yp = cos(deccp*dtr) * sin(racp*dtr);
zp = sin(deccp*dtr);
beta = acos(x*xp + y*yp + z*zp) / dtr;
rot = asin(cos(deccp*dtr) * sin((rac-racp)*dtr)/sin(beta*dtr)) / dtr;
/* And for the four corners we want them uniformly clockwise */
if(!clockwise)
{
pix2wcs(wcs, -0.5, -0.5, &lon, &lat);
convertCoordinates (csys, equinox, lon, lat,
EQUJ, 2000., &ra1, &dec1, 0.);
pix2wcs(wcs, wcs->nxpix+0.5, -0.5, &lon, &lat);
convertCoordinates (csys, equinox, lon, lat,
EQUJ, 2000., &ra2, &dec2, 0.);
pix2wcs(wcs, wcs->nxpix+0.5, wcs->nypix+0.5, &lon, &lat);
convertCoordinates (csys, equinox, lon, lat,
EQUJ, 2000., &ra3, &dec3, 0.);
pix2wcs(wcs, -0.5, wcs->nypix+0.5, &lon, &lat);
convertCoordinates (csys, equinox, lon, lat,
EQUJ, 2000., &ra4, &dec4, 0.);
}
else
{
pix2wcs(wcs, -0.5, -0.5, &lon, &lat);
convertCoordinates (csys, equinox, lon, lat,
EQUJ, 2000., &ra2, &dec2, 0.);
pix2wcs(wcs, wcs->nxpix+0.5, -0.5, &lon, &lat);
convertCoordinates (csys, equinox, lon, lat,
EQUJ, 2000., &ra1, &dec1, 0.);
pix2wcs(wcs, wcs->nxpix+0.5, wcs->nypix+0.5, &lon, &lat);
convertCoordinates (csys, equinox, lon, lat,
EQUJ, 2000., &ra4, &dec4, 0.);
pix2wcs(wcs, -0.5, wcs->nypix+0.5, &lon, &lat);
convertCoordinates (csys, equinox, lon, lat,
EQUJ, 2000., &ra3, &dec3, 0.);
}
// Treat the default region (ALL) as a circle
// containing the whole image
if(areaMode == ALL)
{
locinpix = 1;
radinpix = 1;
ra = wcs->nxpix / 2.;
dec = wcs->nypix / 2.;
radius = sqrt(wcs->nxpix*wcs->nxpix + wcs->nypix*wcs->nypix)/2.;
}
/* Get region statistics */
ixpix = 1;
iypix = 1;
if(radinpix)
{
rpix = radius;
radius = rpix * fabs(cdelt2);
}
else
rpix = radius / fabs(cdelt2);
if(locinpix)
{
xpix = ra;
ypix = dec;
pix2wcs(wcs, xpix, ypix, &lon, &lat);
if(wcs->offscl)
{
if(ap) free(ap);
sprintf(returnStruct->msg, "Location off the image.");
return returnStruct;
}
convertCoordinates (csys, equinox, lon, lat,
EQUJ, 2000., &ra, &dec, 0);
}
else
{
convertCoordinates (EQUJ, 2000., ra, dec,
csys, equinox, &lon, &lat, 0.);
wcs2pix(wcs, lon, lat, &xpix, &ypix, &offscl);
if(offscl)
{
if(ap) free(ap);
sprintf(returnStruct->msg, "Location off the image.");
return returnStruct;
}
}
x0 = cos(ra*dtr) * cos(dec*dtr);
y0 = sin(ra*dtr) * cos(dec*dtr);
z0 = sin(dec*dtr);
ixpix = (int)(xpix+0.5);
iypix = (int)(ypix+0.5);
if(debug)
{
printf("DEBUG> Region statististics for %-g pixels around (%-g,%-g) [%d,%d] [Equatorial (%-g, %-g)\n",
rpix, xpix, ypix, ixpix, iypix, ra, dec);
fflush(stdout);
}
// Then read the data
jbegin = iypix - rpix - 1;
jend = iypix + rpix + 1;
ibegin = ixpix - rpix - 1;
iend = ixpix + rpix + 1;
if(ibegin < 1 ) ibegin = 1;
if(iend > wcs->nxpix) iend = wcs->nxpix;
nelements = iend - ibegin + 1;
if(jbegin < 1 ) jbegin = 1;
if(jend > wcs->nypix) jend = wcs->nxpix;
fpixel[0] = ibegin;
fpixel[1] = jbegin;
fpixel[2] = 1;
fpixel[3] = 1;
fpixel[2] = plane3;
fpixel[3] = plane4;
data = (double *)malloc(nelements * sizeof(double));
status = 0;
sumflux = 0.;
sumflux2 = 0.;
npix = 0;
nnull = 0;
val = 0.;
valx = 0.;
valy = 0.;
valra = 0.;
valdec = 0.;
max = 0.;
maxx = 0.;
maxy = 0.;
maxra = 0.;
maxdec = 0.;
min = 0.;
minx = 0.;
miny = 0.;
minra = 0.;
mindec = 0.;
first = 1;
if(radius > 0.)
{
if(debug)
{
printf("\nDEBUG> Location: (%.6f %.6f) -> (%d,%d)\n\n", xpix, ypix, ixpix, iypix);
printf("DEBUG> Radius: %.6f\n\n", rpix);
printf("DEBUG> i: %d to %d\n", ibegin, iend);
printf("DEBUG> j: %d to %d\n", jbegin, jend);
}
for (j=jbegin; j<=jend; ++j)
{
status = 0;
if(fits_read_pix(fptr, TDOUBLE, fpixel, nelements, &nan,
(void *)data, &nullcnt, &status))
{
++fpixel[1];
continue;
}
for(i=0; i<nelements; ++i)
{
if(mNaN(data[i]))
{
if(debug)
printf("%10s ", "NULL");
++nnull;
continue;
}
sumflux += data[i];
sumflux2 += data[i]*data[i];
++npix;
x = ibegin + i;
y = j;
pix2wcs(wcs, x, y, &lon, &lat);
convertCoordinates(csys, equinox, lon, lat, EQUJ, 2000., &ra, &dec, 0.);
xp = cos(ra*dtr) * cos(dec*dtr);
yp = sin(ra*dtr) * cos(dec*dtr);
zp = sin(dec*dtr);
dot = xp*x0 + yp*y0 + zp*z0;
if(dot > 1.)
dot = 1.;
r = acos(dot)/dtr / fabs(cdelt2);
if(debug)
{
if(r <= rpix)
printf("%10.3f ", data[i]);
else
printf("%10s ", ".");
}
if(r > rpix)
continue;
if(x == ixpix && y == iypix)
{
val = data[i];
valx = x;
valy = y;
}
if(first)
{
first = 0;
min = data[i];
minx = x;
miny = y;
max = data[i];
maxx = x;
maxy = y;
maxi = i+ibegin;
maxj = j;
}
if(data[i] > max)
{
max = data[i];
maxx = x;
maxy = y;
maxi = i+ibegin;
maxj = j;
}
if(data[i] < min)
{
min = data[i];
minx = x;
miny = y;
}
}
pix2wcs(wcs, valx, valy, &lon, &lat);
convertCoordinates(csys, equinox, lon, lat, EQUJ, 2000., &valra, &valdec, 0.);
pix2wcs(wcs, minx, miny, &lon, &lat);
convertCoordinates(csys, equinox, lon, lat, EQUJ, 2000., &minra, &mindec, 0.);
pix2wcs(wcs, maxx, maxy, &lon, &lat);
convertCoordinates(csys, equinox, lon, lat, EQUJ, 2000., &maxra, &maxdec, 0.);
if(debug)
printf("\n");
++fpixel[1];
}
mean = 0.;
rms = 0.;
sigmaref = 0.;
sigmamin = 0.;
sigmamax = 0.;
if(npix > 0)
{
mean = sumflux / npix;
rms = sqrt(sumflux2/npix - mean*mean);
sigmaref = (val - mean) / rms;
sigmamin = (min - mean) / rms;
sigmamax = (max - mean) / rms;
}
}
/* Finally, print out parameters */
strcpy(montage_json, "{");
strcpy(montage_msgstr, "");
if(areaMode == ALL || areaMode == REGION)
{
sprintf(tmpstr, "\"proj\":\"%s\",", proj); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"csys\":\"%s\",", csys_str); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"equinox\":%.1f,", equinox); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"naxis\":%ld,", naxis); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"naxis1\":%d,", (int)naxis1); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"naxis2\":%d,", (int)naxis2); strcat(montage_json, tmpstr);
if(naxis > 2)
{
sprintf(tmpstr, " \"naxis3\":%ld,", naxes[2]); strcat(montage_json, tmpstr);
}
if(naxis > 3)
{
sprintf(tmpstr, " \"naxis4\":%ld,", naxes[3]); strcat(montage_json, tmpstr);
}
sprintf(tmpstr, " \"crval1\":%.7f,", crval1); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"crval2\":%.7f,", crval2); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"crpix1\":%-g,", crpix1); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"crpix2\":%-g,", crpix2); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"cdelt1\":%.7f,", cdelt1); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"cdelt2\":%.7f,", cdelt2); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"crota2\":%.4f,", crota2); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"lonc\":%.7f,", lonc); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"latc\":%.7f,", latc); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"ximgsize\":%.6f,", fabs(naxis1*cdelt1)); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"yimgsize\":%.6f,", fabs(naxis1*cdelt2)); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"rotequ\":%.4f,", rot); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"rac\":%.7f,", rac); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"decc\":%.7f,", decc); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"ra1\":%.7f,", ra1); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"dec1\":%.7f,", dec1); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"ra2\":%.7f,", ra2); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"dec2\":%.7f,", dec2); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"ra3\":%.7f,", ra3); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"dec3\":%.7f,", dec3); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"ra4\":%.7f,", ra4); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"dec4\":%.7f,", dec4); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"radius\":%.7f,", radius); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"radpix\":%.2f,", rpix); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"npixel\":%d,", npix); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"nnull\":%d,", nnull); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"aveflux\":%-g,", mean); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"rmsflux\":%-g,", rms); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"fluxref\":%-g,", val); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"sigmaref\":%-g,", sigmaref); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"xref\":%.0f,", valx); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"yref\":%.0f,", valy); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"raref\":%.7f,", valra); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"decref\":%.7f,", valdec); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"fluxmin\":%-g,", min); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"sigmamin\":%-g,", sigmamin); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"xmin\":%.0f,", minx); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"ymin\":%.0f,", miny); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"ramin\":%.7f,", minra); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"decmin\":%.7f,", mindec); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"fluxmax\":%-g,", max); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"sigmamax\":%-g,", sigmamax); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"xmax\":%.0f,", maxx); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"ymax\":%.0f,", maxy); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"ramax\":%.7f,", maxra); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"decmax\":%.7f", maxdec); strcat(montage_json, tmpstr);
sprintf(tmpstr, "proj=\"%s\",", proj); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " csys=\"%s\",", csys_str); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " equinox=%.1f,", equinox); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " naxis=%ld,", naxis); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " naxis1=%d,", (int)naxis1); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " naxis2=%d,", (int)naxis2); strcat(montage_msgstr, tmpstr);
if(naxis > 2)
{
sprintf(tmpstr, " naxis3=%ld,", naxes[2]); strcat(montage_msgstr, tmpstr);
}
if(naxis > 3)
{
sprintf(tmpstr, " naxis4=%ld,", naxes[3]); strcat(montage_msgstr, tmpstr);
}
sprintf(tmpstr, " crval1=%.7f,", crval1); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " crval2=%.7f,", crval2); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " crpix1=%-g,", crpix1); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " crpix2=%-g,", crpix2); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " cdelt1=%.7f,", cdelt1); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " cdelt2=%.7f,", cdelt2); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " crota2=%.4f,", crota2); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " lonc=%.7f,", lonc); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " latc=%.7f,", latc); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " ximgsize=%.6f,", fabs(naxis1*cdelt1)); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " yimgsize=%.6f,", fabs(naxis1*cdelt2)); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " rotequ=%.4f,", rot); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " rac=%.7f,", rac); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " decc=%.7f,", decc); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " ra1=%.7f,", ra1); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " dec1=%.7f,", dec1); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " ra2=%.7f,", ra2); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " dec2=%.7f,", dec2); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " ra3=%.7f,", ra3); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " dec3=%.7f,", dec3); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " ra4=%.7f,", ra4); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " dec4=%.7f,", dec4); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " radius=%.7f,", radius); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " radpix=%.2f,", rpix); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " npixel=%d,", npix); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " nnull=%d,", nnull); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " aveflux=%-g,", mean); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " rmsflux=%-g,", rms); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " fluxref=%-g,", val); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " sigmaref=%-g,", sigmaref); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " xref=%.0f,", valx); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " yref=%.0f,", valy); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " raref=%.7f,", valra); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " decref=%.7f,", valdec); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " fluxmin=%-g,", min); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " sigmamin=%-g,", sigmamin); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " xmin=%.0f,", minx); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " ymin=%.0f,", miny); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " ramin=%.7f,", minra); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " decmin=%.7f,", mindec); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " fluxmax=%-g,", max); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " sigmamax=%-g,", sigmamax); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " xmax=%.0f,", maxx); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " ymax=%.0f,", maxy); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " ramax=%.7f,", maxra); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " decmax=%.7f", maxdec); strcat(montage_msgstr, tmpstr);
}
else if(areaMode == APPHOT)
{
// For aperture photometry mode we process the flux vs. radius data
// to get the integrated source flux.
rap = radius;
jbegin = maxj - rap - 1;
jend = maxj + rap + 1;
ibegin = maxi - rap - 1;
iend = maxi + rap + 1;
nelements = iend - ibegin + 1;
fpixel[0] = ibegin;
fpixel[1] = jbegin;
fpixel[2] = 1;
fpixel[3] = 1;
for (j=jbegin; j<=jend; ++j)
{
status = 0;
if(fits_read_pix(fptr, TDOUBLE, fpixel, nelements, &nan,
(void *)data, &nullcnt, &status))
{
if(ap) free(ap);
free(data);
sprintf(returnStruct->msg, "Error reading FITS data.");
return returnStruct;
}
for(i=0; i<nelements; ++i)
{
if(mNaN(data[i]))
continue;
r = sqrt(((double)i+ibegin-maxi)*((double)i+ibegin-maxi) + ((double)j-maxj)*((double)j-maxj));
if(r > rap)
continue;
ap[nflux].rad = r;
ap[nflux].flux = data[i];
ap[nflux].fit = 0.;
++nflux;
if(nflux >= maxflux)
{
maxflux += MAXFLUX;
ap = (struct apPhoto *)realloc(ap, maxflux * sizeof(struct apPhoto));
}
}
++fpixel[1];
}
// Sort the data by radius
qsort(ap, (size_t)nflux, sizeof(struct apPhoto), mExamine_radCompare);
// Find the peak flux and the minimum flux.
// The max is constrained to be in the first quarter of the
// data, just to be careful.
fluxMax = -1.e99;
fluxMin = 1.e99;
for(i=0; i<nflux; ++i)
{
if(i < nflux/4 && ap[i].flux > fluxMax)
fluxMax = ap[i].flux;
if(ap[i].flux < fluxMin)
fluxMin = ap[i].flux;
}
// Fit the minimum a little more carefully, iterating
// and excluding points more than 3 sigma above the
// minimum.
background = fluxMin;
sigma = fluxMax - fluxMin;
for(j=0; j<1000; ++j)
{
oldbackground = background;
sumn = 0.;
sumflux = 0.;
sumflux2 = 0.;
for(i=0; i<nflux; ++i)
{
if(fabs(ap[i].flux - background) > 3.*sigma)
continue;
sumn += 1.;
sumflux += ap[i].flux;
sumflux2 += ap[i].flux * ap[i].flux;
}
background = sumflux / sumn;
sigma = sqrt(sumflux2/sumn - background*background);
if(fabs((background - oldbackground) / oldbackground) < 1.e-3)
break;
}
fluxRef = (fluxMax-fluxMin) / exp(1.);
for(i=0; i<nflux; ++i)
{
if(ap[i].flux < fluxRef)
{
sigma = ap[i].rad;
break;
}
}
for(i=0; i<nflux; ++i)
{
ap[i].fit = (fluxMax-background) * exp(-(ap[i].rad * ap[i].rad) / (sigma * sigma)) + background;
if(i == 0)
ap[i].sum = ap[i].flux - background;
else
ap[i].sum = ap[i-1].sum + (ap[i].flux - background);
}
if(debug)
{
printf("| rad | flux | fit | sum |\n");
fflush(stdout);
for(i=0; i<nflux; ++i)
{
printf("%12.6f %12.6f %12.6f %12.6f \n", ap[i].rad, ap[i].flux, ap[i].fit, ap[i].sum);
fflush(stdout);
}
}
sprintf(tmpstr, "\"proj\":\"%s\",", proj); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"csys\":\"%s\",", csys_str); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"equinox\":%.1f,", equinox); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"naxis\":%ld,", naxis); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"naxis1\":%d,", (int)naxis1); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"naxis2\":%d,", (int)naxis2); strcat(montage_json, tmpstr);
if(naxis > 2)
{
sprintf(tmpstr, " \"naxis3\":%ld,", naxes[2]); strcat(montage_json, tmpstr);
}
if(naxis > 3)
{
sprintf(tmpstr, " \"naxis4\":%ld,", naxes[3]); strcat(montage_json, tmpstr);
}
sprintf(tmpstr, " \"crval1\":%.7f,", crval1); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"crval2\":%.7f,", crval2); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"crpix1\":%-g,", crpix1); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"crpix2\":%-g,", crpix2); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"cdelt1\":%.7f,", cdelt1); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"cdelt2\":%.7f,", cdelt2); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"crota2\":%.4f,", crota2); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"lonc\":%.7f,", lonc); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"latc\":%.7f,", latc); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"ximgsize\":%.6f,", fabs(naxis1*cdelt1)); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"yimgsize\":%.6f,", fabs(naxis1*cdelt2)); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"rotequ\":%.4f,", rot); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"rac\":%.7f,", rac); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"decc\":%.7f,", decc); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"ra1\":%.7f,", ra1); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"dec1\":%.7f,", dec1); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"ra2\":%.7f,", ra2); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"dec2\":%.7f,", dec2); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"ra3\":%.7f,", ra3); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"dec3\":%.7f,", dec3); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"ra4\":%.7f,", ra4); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"dec4\":%.7f,", dec4); strcat(montage_json, tmpstr);
sprintf(tmpstr, " \"totalflux\":%.7e", ap[nflux/2].sum); strcat(montage_json, tmpstr);
sprintf(tmpstr, "proj=\"%s\",", proj); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " csys=\"%s\",", csys_str); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " equinox=%.1f,", equinox); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " naxis=%ld,", naxis); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " naxis1=%d,", (int)naxis1); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " naxis2=%d,", (int)naxis2); strcat(montage_msgstr, tmpstr);
if(naxis > 2)
{
sprintf(tmpstr, " naxis3=%ld,", naxes[2]); strcat(montage_msgstr, tmpstr);
}
if(naxis > 3)
{
sprintf(tmpstr, " naxis4=%ld,", naxes[3]); strcat(montage_msgstr, tmpstr);
}
sprintf(tmpstr, " crval1=%.7f,", crval1); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " crval2=%.7f,", crval2); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " crpix1=%-g,", crpix1); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " crpix2=%-g,", crpix2); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " cdelt1=%.7f,", cdelt1); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " cdelt2=%.7f,", cdelt2); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " crota2=%.4f,", crota2); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " lonc=%.7f,", lonc); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " latc=%.7f,", latc); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " ximgsize=%.6f,", fabs(naxis1*cdelt1)); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " yimgsize=%.6f,", fabs(naxis1*cdelt2)); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " rotequ=%.4f,", rot); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " rac=%.7f,", rac); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " decc=%.7f,", decc); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " ra1=%.7f,", ra1); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " dec1=%.7f,", dec1); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " ra2=%.7f,", ra2); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " dec2=%.7f,", dec2); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " ra3=%.7f,", ra3); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " dec3=%.7f,", dec3); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " ra4=%.7f,", ra4); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " dec4=%.7f,", dec4); strcat(montage_msgstr, tmpstr);
sprintf(tmpstr, " totalflux=%.7e", ap[nflux/2].sum); strcat(montage_msgstr, tmpstr);
}
strcat(montage_json, "}");
if(ap) free(ap);
free(data);
returnStruct->status = 0;
strcpy(returnStruct->msg, montage_msgstr);
strcpy(returnStruct->json, montage_json);
strcpy(returnStruct->proj, proj);
strcpy(returnStruct->csys, csys_str);
returnStruct->equinox = equinox;
returnStruct->naxis = naxis;
returnStruct->naxis1 = naxis1;
returnStruct->naxis2 = naxis2;
returnStruct->naxis3 = naxes[2];
returnStruct->naxis4 = naxes[3];
returnStruct->crval1 = crval1;
returnStruct->crval2 = crval2;
returnStruct->crpix1 = crpix1;
returnStruct->crpix2 = crpix2;
returnStruct->cdelt1 = cdelt1;
returnStruct->cdelt2 = cdelt2;
returnStruct->crota2 = crota2;
returnStruct->lonc = lonc;
returnStruct->latc = latc;
returnStruct->ximgsize = fabs(naxis1*cdelt1);
returnStruct->yimgsize = fabs(naxis2*cdelt2);
returnStruct->rotequ = rot;
returnStruct->rac = rac;
returnStruct->decc = decc;
returnStruct->ra1 = ra1;
returnStruct->dec1 = dec1;
returnStruct->ra2 = ra2;
returnStruct->dec2 = dec2;
returnStruct->ra3 = ra3;
returnStruct->dec3 = dec3;
returnStruct->ra4 = ra4;
returnStruct->dec4 = dec4;
returnStruct->radius = radius;
returnStruct->radpix = rpix;
returnStruct->npixel = npix;
returnStruct->nnull = nnull;
returnStruct->aveflux = mean;
returnStruct->rmsflux = rms;
returnStruct->fluxref = val;
returnStruct->sigmaref = sigmaref;
returnStruct->xref = valx;
returnStruct->yref = valy;
returnStruct->raref = valra;
returnStruct->decref = valdec;
returnStruct->fluxmin = min;
returnStruct->sigmamin = sigmamin;
returnStruct->xmin = minx;
returnStruct->ymin = miny;
returnStruct->ramin = minra;
returnStruct->decmin = mindec;
returnStruct->fluxmax = max;
returnStruct->sigmamax = sigmamax;
returnStruct->xmax = maxx;
returnStruct->ymax = maxy;
returnStruct->ramax = maxra;
returnStruct->decmax = maxdec;
if(areaMode == APPHOT)
returnStruct->totalflux = ap[nflux/2].sum;
else
returnStruct->totalflux = 0.;
return returnStruct;
}
int HEALPixIn(struct healpix *hpxdat)
{
char crdsys[32], ordering[32];
int anynul, hdutype, iaxis, nfound, status;
long firstpix, ipix, lastpix, naxis, *naxes = 0x0, nside = 0, repeat;
float *datap, nulval;
LONGLONG firstelem, irow, nelem, npix = 0, nrow = 0;
fitsfile *fptr;
status = 0;
hpxdat->data = 0x0;
/* Open the FITS file and move to the first HDU with NAXIS != 0. */
if (fits_open_data(&fptr, hpxdat->infile, READONLY, &status)) goto fitserr;
/* Is this the primary HDU or an extension? */
if (fits_get_hdu_type(fptr, &hdutype, &status)) goto fitserr;
if (!(hdutype == IMAGE_HDU || hdutype == BINARY_TBL)) {
fprintf(stderr, "ERROR: %s does not contain HEALPix data.\n",
hpxdat->infile);
return 1;
}
/* Get the image size. */
if (fits_read_key_lng(fptr, "NAXIS", &naxis, 0x0, &status)) goto fitserr;
naxes = malloc(naxis*sizeof(long));
if (fits_read_keys_lng(fptr, "NAXIS", 1, (int)naxis, naxes, &nfound,
&status)) goto fitserr;
if (hdutype == IMAGE_HDU) {
/* Look for the first non-degenerate image axis. */
for (iaxis = 0; iaxis < nfound; iaxis++) {
if (naxes[iaxis] > 1) {
/* Assume for now that it is the total number of pixels. */
npix = naxes[iaxis];
break;
}
}
} else if (hdutype == BINARY_TBL) {
/* Binary tables are simpler. */
if (nfound > 1) nrow = naxes[1];
/* (Note that fits_get_coltypell() is not available in cfitsio 2.x.) */
if (fits_get_coltype(fptr, hpxdat->col, 0x0, &repeat, 0x0, &status)) {
goto fitserr;
}
nelem = (LONGLONG)repeat;
}
if (!npix && !nrow) {
fprintf(stderr, "ERROR: Could not determine image size.\n");
goto cleanup;
}
/* Number of pixels per side of each base-resolution pixel. */
if (fits_read_key_lng(fptr, "NSIDE", &nside, 0x0, &status)) {
/* Some HEALPix files, e.g. SFD dust maps, don't record NSIDE. */
if (status != KEY_NO_EXIST) goto fitserr;
status = 0;
}
/* FIRSTPIX and LASTPIX, if present, record the 0-relative pixel numbers of
* the first and last pixels stored in the data. */
firstpix = -1;
if (fits_read_key_lng(fptr, "FIRSTPIX", &firstpix, 0x0, &status)) {
if (status != KEY_NO_EXIST) goto fitserr;
status = 0;
}
lastpix = -1;
if (fits_read_key_lng(fptr, "LASTPIX", &lastpix, 0x0, &status)) {
if (status != KEY_NO_EXIST) goto fitserr;
status = 0;
}
if (!nside) {
/* Deduce NSIDE. */
if (lastpix >= 0) {
/* If LASTPIX is present without NSIDE we can only assume it's npix. */
nside = (int)(sqrt((double)((lastpix+1) / 12)) + 0.5);
} else if (npix) {
nside = (int)(sqrt((double)(npix / 12)) + 0.5);
} else if (nrow) {
nside = (int)(sqrt((double)((nrow * nelem) / 12)) + 0.5);
}
}
hpxdat->nside = (int)nside;
hpxdat->npix = 12*nside*nside;
/* Ensure that FIRSTPIX and LASTPIX are set. */
if (firstpix < 0) firstpix = 0;
if (lastpix < 0) lastpix = hpxdat->npix - 1;
/* Any sign of a coordinate system identifier? */
if (fits_read_key_str(fptr, "COORDSYS", crdsys, 0x0, &status)) {
if (status != KEY_NO_EXIST) goto fitserr;
status = 0;
} else if (crdsys[0] == 'G') {
hpxdat->crdsys = 'G';
} else if (crdsys[0] == 'E') {
hpxdat->crdsys = 'E';
} else if (crdsys[0] == 'C') {
/* ("celestial") */
hpxdat->crdsys = 'Q';
}
/* Nested or ring ordering? */
if (fits_read_key_str(fptr, "ORDERING", ordering, 0x0, &status)) {
/* Some HEALPix files, e.g. SFD dust maps, don't record ORDERING. */
if (status != KEY_NO_EXIST) goto fitserr;
status = 0;
} else if (strcmp(ordering, "NESTED") == 0) {
hpxdat->ordering = 'N';
} else if (strcmp(ordering, "RING") == 0) {
hpxdat->ordering = 'R';
} else {
fprintf(stderr, "WARNING: Invalid ORDERING keyword: %s.\n", ordering);
}
/* Allocate memory and read the data. */
if ((hpxdat->data = malloc((hpxdat->npix)*sizeof(float))) == NULL) {
perror("HPXcvt");
goto cleanup;
}
nulval = HEALPIX_NULLVAL;
datap = hpxdat->data;
for (ipix = 0; ipix < firstpix; ipix++) {
*(datap++) = nulval;
}
firstelem = (LONGLONG)1;
if (hdutype == IMAGE_HDU) {
if (fits_read_img_flt(fptr, 0l, firstelem, npix, nulval, datap, &anynul,
&status)) goto fitserr;
} else if (hdutype == BINARY_TBL) {
for (irow = 0; irow < nrow; irow++) {
if (fits_read_col_flt(fptr, hpxdat->col, irow+1, firstelem, nelem,
nulval, datap, &anynul, &status)) goto fitserr;
datap += nelem;
}
}
datap = hpxdat->data + (lastpix + 1);
for (ipix = (lastpix+1); ipix < hpxdat->npix; ipix++) {
*(datap++) = nulval;
}
/* Clean up. */
fits_close_file(fptr, &status);
status = 0;
return 0;
fitserr:
fits_report_error(stderr, status);
cleanup:
if (naxes) free(naxes);
if (hpxdat->data) free(hpxdat->data);
hpxdat->data = 0x0;
return 1;
}
//Signed 8bits char -128~127
bool Fits2D::readFits8C(Mat &img){
char * ptr = NULL;
char * ptr1 = NULL;
int status = 0, nfound, anynull;
long naxes[2], fpixel, nbuffer, npixels;
float nullval;
fitsfile *fptr;
const char * filename;
filename = mFitsPath.c_str();
if(fits_open_file(&fptr, filename, READONLY, &status)){
printerror(status);
return false;
}
// Read the NAXIS1 and NAXIS2 keyword to get image size.
if(fits_read_keys_lng(fptr, "NAXIS", 1, 2, naxes, &nfound, &status)){
printerror(status);
return false;
}
Mat image = Mat::zeros( naxes[1],naxes[0], CV_8SC1);
npixels = naxes[0] * naxes[1]; // number of pixels in the image
fpixel = 1; // first pixel
nullval = 0; // don't check for null values in the image
nbuffer = npixels;
// char buffer[npixels];
char* buffer = new char[npixels];
if(fits_read_img(fptr, TSBYTE, fpixel, nbuffer, &nullval,buffer, &anynull, &status)){
printerror(status);
delete buffer;
return false;
}
memcpy(image.ptr(), buffer, npixels * 2);
Mat loadImg = Mat::zeros( naxes[1],naxes[0], CV_8SC1 );
// y
for(int i = 0; i < naxes[1]; i++){
char * ptr = image.ptr<char>(i);
char * ptr1 = loadImg.ptr<char >(naxes[1] - 1 - i);
// x
for(int j = 0; j < naxes[0]; j++){
ptr1[j] = ptr[j];
}
}
loadImg.copyTo(img);
delete buffer;
if(fits_close_file(fptr, &status)){
printerror(status);
return false;
}
return true;
}
double *readfits(char *fits_name, int nmax)
/************************************************************************/
/* Read a FITS image and determine the minimum and maximum pixel values */
/************************************************************************/
{
double *output=new double[2*nmax*nmax];// PAUL
fprintf(stderr, "\nReading fits data\n");
fitsfile *fptr; /* pointer to the FITS file, defined in fitsio.h */
int status, nfound, anynull;
long naxes[2], fpixel, nbuffer, npixels, ii;
#define buffsize 1000
//#define buffsize 1000000
float datamin, datamax, nullval, buffer[buffsize];
//char filename[] = "atestfil.fit"; /* name of existing FITS file */
char *filename=new char[50];
strcpy(filename, fits_name);
status = 0;
if ( fits_open_file(&fptr, filename, READONLY, &status) )
printerror( status );
/* read the NAXIS1 and NAXIS2 keyword to get image size */
if ( fits_read_keys_lng(fptr, "NAXIS", 1, 2, naxes, &nfound, &status) )
printerror( status );
npixels = naxes[0] * naxes[1]; /* number of pixels in the image */
fpixel = 1;
nullval = 0; /* don't check for null values in the image */
datamin = 1.0E30;
datamax = -1.0E30;
int i=0;
while (npixels > 0)
{
nbuffer = npixels;
if (npixels > buffsize)
nbuffer = buffsize; /* read as many pixels as will fit in buffer */
/* Note that even though the FITS images contains unsigned integer */
/* pixel values (or more accurately, signed integer pixels with */
/* a bias of 32768), this routine is reading the values into a */
/* float array. Cfitsio automatically performs the datatype */
/* conversion in cases like this. */
if ( fits_read_img(fptr, TFLOAT, fpixel, nbuffer, &nullval,
buffer, &anynull, &status) )
printerror( status );
for (ii = 0; ii < nbuffer; ii++) {
//if(isnan(double(buffer[ii]))) buffer[ii]=0;
output[i]=double(buffer[ii]); //PAUL copy image
output[i+1]=0; //Imaginary part (assumes image is real)
if(isnan(double(output[i]))){fprintf(stderr, "Nan error in readfits\n"); exit(1);}
i=i+2;
if ( buffer[ii] < datamin )
datamin = buffer[ii];
if ( buffer[ii] > datamax )
datamax = buffer[ii];
}
npixels -= nbuffer; /* increment remaining number of pixels */
fpixel += nbuffer; /* next pixel to be read in image */
}
//printf("\nMin and max image pixels = %.0f, %.0f\nN pix %d\n", datamin, datamax, i);
//fprintf(stderr, "N pixels = %d\n", i);
if ( fits_close_file(fptr, &status) )
printerror( status );
return output;
}
int edit_image(char filename[], char newfilename[], double **ppix )
{
fitsfile *fptr, *newfptr;
int status, nfound, day, month, year, timeref;
int naxis = 2; /* 2-dimensional image */
int bitpix = DOUBLE_IMG; /* Output image type is double */
int datatype = TDOUBLE;
long naxes[2]; /* dimensions of the image */
long fpixel, npixels;
char date[FLEN_VALUE], time[FLEN_VALUE];
char *nullcomment;
char outfilename[MAXLENGTH];
nullcomment=0;
/***********************************************************************/
status = 0; /* Initialize status before calling fitsio routines */
/***********************************************************************/
/* Copy newfilename to outfilename. 'newfilename' is passed has a reference,
* therefore any change to it will be passed back to the calling routine
* which is not really what one wants. (as I discovered...)
* The addition of the '!' is meaningful here but not necessarly useful in
* the calling routine. */
if (!strcmp(newfilename,filename)) {
strcpy(outfilename,"!");
strcat(outfilename,filename);
}
else {
strcpy(outfilename,newfilename);
}
printf("Writing %s ... ",newfilename);
fflush(stdout);
/* Open the existing FITS file */
if ( fits_open_file(&fptr, filename, READONLY, &status) )
printerror( status );
/* Create the new FITS file (should I use a template?)*/
if ( fits_create_file(&newfptr, outfilename, &status) )
printerror( status );
/* No need to create an image in the new FITS file because the primary
* array is automatically created when the header is copied */
/* Copy the header from the existing FITS file to the new FITS file */
if ( fits_copy_header(fptr, newfptr, &status) )
printerror( status );
/* Get the length of the axes */
if ( fits_read_keys_lng(newfptr, "NAXIS", 1, 2, naxes, &nfound, &status) )
printerror( status );
/* Write the image (array of pixel values) in the new FITS file */
fpixel = 1; /* first pixel to write */
npixels = naxes[0] * naxes[1]; /* number of pixels to write */
if ( fits_write_img(newfptr, datatype, fpixel, npixels, ppix[0], &status) )
printerror( status );
/* Edit header */
if ( fits_get_system_date(&day, &month, &year, &status) )
printerror( status );
if ( fits_date2str(year, month, day, date, &status) )
printerror( status );
if ( fits_update_key(newfptr, TSTRING, "DATE", date, "", &status) )
printerror( status );
if ( fits_get_system_time(time, &timeref, &status) )
printerror( status );
if ( timeref == 0 ) /* Convert UTC/GMT to Local time */
if ( utc2local(time, FITS_FMT) ) {
printf("Error : Unable to convert time.\n");
exit(1);
}
if ( status = cnvtimefmt(time, FITS_FMT, IRAF_FMT))
printerror( status ); /* Stupid IRAF cannot read the new FITS
* date-time Y2K format */
if ( fits_update_key(newfptr, TSTRING, "IRAF-TLM", time, nullcomment, &status) )
printerror( status );
/* Close the existing FITS file */
if ( fits_close_file(fptr, &status) )
printerror( status );
/* Close the new FITS file */
if ( fits_close_file(newfptr, &status) )
printerror( status );
printf("done\n");
return(0);
}
GivImage *giv_plugin_load_file(const char *filename,
GError **error)
{
fitsfile *fptr; /* pointer to the FITS file; defined in fitsio.h */
long nnaxes, naxes[3];
int status;
int width, height, depth;
GivImageType type;
int nfound;
int bitpix;
GivImage *img = NULL;
void *flip_data = NULL;
int wsize;
int anynull;
int fpixel = 1;
/* Check that file exists without the use of the cfits library
as it is doing strange things if the file doesn't exists... */
status = 0;
{
struct stat buf;
if (stat(filename, &buf) != 0) {
fprintf(stderr, "Failed opening the file %s!\n", filename);
goto CATCH;
}
}
status = 0;
if (fits_open_file(&fptr, filename, READONLY, &status) != 0)
goto CATCH;
if (fits_read_key(fptr, TLONG, "NAXIS", &nnaxes, NULL, &status) != 0)
goto CATCH;
/* Read the header data */
if ( fits_read_keys_lng(fptr, "NAXIS", 1, nnaxes, naxes, &nfound, &status) )
goto CATCH;
width = naxes[0];
height = naxes[1];
depth = naxes[2];
if (nnaxes == 2 || depth == 0)
depth = 1;
if (nnaxes < 2 || nnaxes > 3) {
fprintf(stderr, "Sorry. Only support 2D and 3D fits files!\n");
goto CATCH;
}
if (fits_read_key(fptr, TLONG, "BITPIX", &bitpix, NULL, &status) != 0)
goto CATCH;
type = bitpix_to_data_type(bitpix);
wsize = giv_image_type_get_size(type)/8; /* Size in bytes */
img = giv_image_new_full(type,
width,
width * wsize,
height,
height * wsize * width,
2,
depth);
wsize = giv_image_type_get_size(type)/8; /* Size in bytes */
flip_data = malloc(wsize * width * height*depth);
if ( fits_read_img(fptr, giv_image_type_to_fits_type(type), fpixel, width*height * depth, 0,
flip_data, &anynull, &status) )
goto CATCH;
#ifdef DO_FLIP
{
int slice_size, row_idx, z_idx;
/* Flip the image */
slice_size = width * wsize * height;
for (z_idx = 0; z_idx < depth; z_idx++)
for (row_idx = 0; row_idx < height; row_idx++)
memcpy(img->buf.buf + z_idx * slice_size
+ (height - row_idx - 1) * width * wsize,
(guchar*)flip_data + z_idx * slice_size + row_idx * width * wsize,
width * wsize);
}
#else
memcpy(img->buf.buf,
flip_data,
width * height * wsize * depth);
#endif
fits_close_file(fptr, &status); /* close the file */
CATCH:
free(flip_data);
if (status!= 0)
fits_report_error(stderr, status); /* print out any error messages */
return img;
}
void
process_file (char *filename)
{
fitsfile *fptr;
int status, nfound, anynull;
double median;
long naxes[4], fpixel, nbuffer, npixels, npix, ii;
char camera_name[80];
#define BUFFSIZE 1000
float nullval, buffer[BUFFSIZE];
#define printerror(sta) fits_report_error (stderr, status)
status = 0;
if (fits_open_file (&fptr, filename, READONLY, &status))
{
printerror (status);
return;
}
if (fits_read_keys_lng (fptr, (char *) "NAXIS", 1, 2, naxes, &nfound, &status))
goto err;
if (nfound < 1)
{
if (verbose)
printf ("No image found in %s\n", filename);
fits_close_file (fptr, &status);
check_unlink (filename);
return;
}
nfound--;
npixels = naxes[nfound];
for (; nfound > 0; nfound--)
npixels *= naxes[nfound];
npix = npixels;
if (fits_read_key_str (fptr, (char *) "CAM_NAME", camera_name, NULL, &status))
{
if (verbose)
printf ("No CAM_NAME in %s, default will be used\n", filename);
if (isnan (min))
{
if (config->getDouble ("flatprocess", "min", min))
min = -INFINITY;
}
if (isnan (max))
{
if (config->getDouble ("flatprocess", "max", max))
max = INFINITY;
}
status = 0;
}
else
{
if (isnan (min))
{
if (config->getDouble (camera_name, "flatmin", min))
min = -INFINITY;
}
if (isnan (max))
{
if (config->getDouble (camera_name, "flatmax", max))
max = INFINITY;
}
}
if (verbose > 1)
printf ("%s: min %f, max %f, npix: %li\n", filename, min, max, npixels);
fpixel = 1;
median = 0;
while (npixels > 0)
{
if (npixels > BUFFSIZE)
nbuffer = BUFFSIZE;
else
nbuffer = npixels;
if (fits_read_img
(fptr, TFLOAT, fpixel, nbuffer, &nullval, buffer, &anynull,
&status))
goto err;
for (ii = 0; ii < nbuffer; ii++)
median += buffer[ii];
npixels -= nbuffer;
fpixel += nbuffer;
}
median = median / npix;
if (verbose)
printf ("%s %f\n", filename, median);
if (fits_close_file (fptr, &status))
printerror (status);
if (median < min || median > max)
check_unlink (filename);
return;
err:
printerror (status);
if (fits_close_file (fptr, &status))
printerror (status);
return;
}
float *read_healpix_map(const char *infile, long *nside, char *coordsys, char *ordering) {
/* Local Declarations */
long naxes, *naxis, npix, npercol, irow;
int status, hdutype, nfound, anynul;
float nulval, *map;
char comment[FLEN_COMMENT];
fitsfile *fptr;
/* Initializations */
status = 0;
/* Open the file */
if ( fits_open_file(&fptr, infile, READONLY, &status) ) {
printerror( status );
return (float *)NULL;
}
/* Move to the HDU */
if ( fits_movabs_hdu(fptr, 2, &hdutype, &status) ) {
printerror( status );
return (float *)NULL;
}
if (hdutype != BINARY_TBL) {
fprintf(stderr, "%s (%d): Extension is not binary!\n", __FILE__, __LINE__);
return (float *)NULL;
}
/* Read the sizes of the array */
if ( fits_read_key_lng(fptr, "NAXIS", &naxes, comment, &status) ) {
printerror( status );
return (float *)NULL;
}
naxis = (long *)malloc(((size_t)naxes)*sizeof(long));
if ( fits_read_keys_lng(fptr, "NAXIS", 1, naxes, naxis, &nfound, &status)
|| nfound != naxes ) {
printerror( status );
return (float *)NULL;
}
if ( fits_read_key_lng(fptr, "NSIDE", nside, comment, &status) ) {
printerror(status);
return (float *)NULL;
}
npix = 12*(*nside)*(*nside);
if ( (npix%naxis[1]) != 0 ) {
fprintf(stderr, "%s (%d): Problem with npix.\n", __FILE__, __LINE__);
return (float *)NULL;
}
npercol = npix/naxis[1];
if (fits_read_key(fptr, TSTRING, "COORDSYS",coordsys, comment, &status)) {
fprintf(stderr, "WARNING: Could not find %s keyword in in file %s\n",
"COORDSYS",infile);
status = 0;
}
if (fits_read_key(fptr, TSTRING, "ORDERING", ordering, comment, &status)) {
fprintf(stderr, "WARNING: Could not find %s keyword in in file %s\n",
"ORDERING",infile);
status = 0;
}
/* Read the array */
map = (float *)malloc(((size_t)npix)*sizeof(float));
nulval = HEALPIX_NULLVAL;
for (irow = 0; irow < naxis[1]; irow++) {
if ( fits_read_col(fptr, TFLOAT, 1, irow+1, 1, npercol, &nulval,
&(map[irow*npercol]), &anynul, &status) ) {
printerror(status);
return (float *)NULL;
}
}
/* Close the file */
if ( fits_close_file(fptr, &status) ) {
printerror( status );
return (float *)NULL;
}
/* Later */
return map;
}
// / Converts a FITS file into a matrix of double values.
void fits2mat(const char *fname, Matrix < double >&m)
{
int status = 0;
char comment[200]; // should be enough for most comments
fitsfile *fptr; // pointer to the FITS file, defined in
// fitsio.h
int nfound, anynull;
long naxes[2], fpixel, npixels;
float nullval;
if (status == 0)
fits_open_file(&fptr, fname, READONLY, &status);
if (status == 0)
fits_read_keys_lng(fptr, "NAXIS", 1, 2, naxes, &nfound, &status);
// The pixellation parameter has been moved to the SOURCE/Target definition file.
// if (status == 0) // Get the pixellation parameter
// {
// float xyint;
// fits_read_key_flt(fptr, "PIXEL", &xyint, comment, &status);
// if (status != 0) // in the case where the keyword is missing
// {
// status = 0;
// pixellation = 0.;
// // The file should have a pixelation value. Throw an exception.
// /// \exception runtime_error The Target FITS file is missing PIXEL keyword!
// /// This means that the input FITS file is missing the PIXEL(lation) parameter
// /// which should be defined somewhere in the FITS header.
// throw std::runtime_error("Target FITS File missing PIXEL keyword!");
// }
// else
// {
// pixellation = double (xyint);
// }
// }
npixels = naxes[0] * naxes[1]; // number of pixels in the image
fpixel = 1;
nullval = 0; // do not check for null values
double *ptrimg = (double *)malloc(npixels * sizeof(double));
if (status == 0)
fits_read_img(fptr, TDOUBLE, fpixel, npixels, &nullval, ptrimg,
&anynull, &status);
if (status == 0)
fits_close_file(fptr, &status);
m.setsize(naxes[0], naxes[1]);
for (int ii = 0; ii < naxes[0]; ii++)
for (int jj = 0; jj < naxes[1]; jj++)
m[ ii ][ jj ] = ptrimg[ ii + jj * naxes[ 0 ] ];
free(ptrimg);
// Report any errors
fits_report_error(stderr, status);
}