int coadd_add_image(coadd_t* ca, const number* img,
const number* weightimg,
number weight, const anwcs_t* wcs) {
int W, H;
int i, j;
int xlo,xhi,ylo,yhi;
check_bounds_t cb;
W = anwcs_imagew(wcs);
H = anwcs_imageh(wcs);
// if check_bounds:
cb.xlo = W;
cb.xhi = 0;
cb.ylo = H;
cb.yhi = 0;
cb.wcs = ca->wcs;
anwcs_walk_image_boundary(wcs, 50, check_bounds, &cb);
xlo = MAX(0, floor(cb.xlo));
xhi = MIN(ca->W, ceil(cb.xhi)+1);
ylo = MAX(0, floor(cb.ylo));
yhi = MIN(ca->H, ceil(cb.yhi)+1);
logmsg("Image projects to output image region: [%i,%i), [%i,%i)\n", xlo, xhi, ylo, yhi);
for (i=ylo; i<yhi; i++) {
for (j=xlo; j<xhi; j++) {
double ra, dec;
double px, py;
double wt;
double val;
// +1 for FITS
if (anwcs_pixelxy2radec(ca->wcs, j+1, i+1, &ra, &dec)) {
ERROR("Failed to project pixel (%i,%i) through output WCS\n", j, i);
continue;
}
if (anwcs_radec2pixelxy(wcs, ra, dec, &px, &py)) {
ERROR("Failed to project pixel (%i,%i) through input WCS\n", j, i);
continue;
}
// -1 for FITS
px -= 1;
py -= 1;
if (px < 0 || px >= W)
continue;
if (py < 0 || py >= H)
continue;
val = ca->resample_func(px, py, img, weightimg, W, H, &wt,
ca->resample_token);
ca->img[i*ca->W + j] += val * weight;
ca->weight[i*ca->W + j] += wt * weight;
}
logverb("Row %i of %i\n", i+1, ca->H);
}
return 0;
}
int plotstuff_set_size_wcs(plot_args_t* pargs) {
assert(pargs->wcs);
return plotstuff_set_size(pargs, (int)ceil(anwcs_imagew(pargs->wcs)), (int)ceil(anwcs_imageh(pargs->wcs)));
}
int main(int argc, char** args) {
int argchar;
char* progname = args[0];
char* outfn = NULL;
char* outwcsfn = NULL;
int outwcsext = 0;
anwcs_t* outwcs;
sl* inimgfns = sl_new(16);
sl* inwcsfns = sl_new(16);
sl* inwtfns = sl_new(16);
il* inimgexts = il_new(16);
il* inwcsexts = il_new(16);
il* inwtexts = il_new(16);
int i;
int loglvl = LOG_MSG;
int order = 3;
coadd_t* coadd;
lanczos_args_t largs;
double sigma = 0.0;
anbool nearest = FALSE;
anbool divweight = FALSE;
int plane = 0;
while ((argchar = getopt(argc, args, OPTIONS)) != -1)
switch (argchar) {
case '?':
case 'h':
printHelp(progname);
exit(0);
case 'D':
divweight = TRUE;
break;
case 'p':
plane = atoi(optarg);
break;
case 'N':
nearest = TRUE;
break;
case 's':
sigma = atof(optarg);
break;
case 'v':
loglvl++;
break;
case 'e':
outwcsext = atoi(optarg);
break;
case 'w':
outwcsfn = optarg;
break;
case 'o':
outfn = optarg;
break;
case 'O':
order = atoi(optarg);
break;
}
log_init(loglvl);
fits_use_error_system();
args += optind;
argc -= optind;
if (argc == 0 || argc % 6) {
printHelp(progname);
exit(-1);
}
for (i=0; i<argc/6; i++) {
sl_append(inimgfns, args[6*i+0]);
il_append(inimgexts, atoi(args[6*i+1]));
sl_append(inwtfns, args[6*i+2]);
il_append(inwtexts, atoi(args[6*i+3]));
sl_append(inwcsfns, args[6*i+4]);
il_append(inwcsexts, atoi(args[6*i+5]));
}
logmsg("Reading output WCS file %s\n", outwcsfn);
outwcs = anwcs_open(outwcsfn, outwcsext);
if (!outwcs) {
ERROR("Failed to read WCS from file: %s ext %i\n", outwcsfn, outwcsext);
exit(-1);
}
logmsg("Output image will be %i x %i\n", (int)anwcs_imagew(outwcs), (int)anwcs_imageh(outwcs));
coadd = coadd_new(anwcs_imagew(outwcs), anwcs_imageh(outwcs));
coadd->wcs = outwcs;
if (nearest) {
coadd->resample_func = nearest_resample_f;
coadd->resample_token = NULL;
} else {
coadd->resample_func = lanczos_resample_f;
largs.order = order;
coadd->resample_token = &largs;
}
for (i=0; i<sl_size(inimgfns); i++) {
anqfits_t* anq;
anqfits_t* wanq;
float* img;
float* wt = NULL;
anwcs_t* inwcs;
char* fn;
int ext;
float overallwt = 1.0;
int W, H;
fn = sl_get(inimgfns, i);
ext = il_get(inimgexts, i);
logmsg("Reading input image \"%s\" ext %i\n", fn, ext);
anq = anqfits_open(fn);
if (!anq) {
ERROR("Failed to open file \"%s\"\n", fn);
exit(-1);
}
img = anqfits_readpix(anq, ext, 0, 0, 0, 0, plane,
PTYPE_FLOAT, NULL, &W, &H);
if (!img) {
ERROR("Failed to read image from ext %i of %s\n", ext, fn);
exit(-1);
}
anqfits_close(anq);
logmsg("Read image: %i x %i.\n", W, H);
if (sigma > 0.0) {
int k0, nk;
float* kernel;
logmsg("Smoothing by Gaussian with sigma=%g\n", sigma);
kernel = convolve_get_gaussian_kernel_f(sigma, 4, &k0, &nk);
convolve_separable_f(img, W, H, kernel, k0, nk, img, NULL);
free(kernel);
}
fn = sl_get(inwcsfns, i);
ext = il_get(inwcsexts, i);
logmsg("Reading input WCS file \"%s\" ext %i\n", fn, ext);
inwcs = anwcs_open(fn, ext);
if (!inwcs) {
ERROR("Failed to read WCS from file \"%s\" ext %i\n", fn, ext);
exit(-1);
}
if (anwcs_pixel_scale(inwcs) == 0) {
ERROR("Pixel scale from the WCS file is zero. Usually this means the image has no valid WCS header.\n");
exit(-1);
}
if (anwcs_imagew(inwcs) != W || anwcs_imageh(inwcs) != H) {
ERROR("Size mismatch between image and WCS!");
exit(-1);
}
fn = sl_get(inwtfns, i);
ext = il_get(inwtexts, i);
if (streq(fn, "none")) {
logmsg("Not using weight image.\n");
wt = NULL;
} else if (file_exists(fn)) {
logmsg("Reading input weight image \"%s\" ext %i\n", fn, ext);
wanq = anqfits_open(fn);
if (!wanq) {
ERROR("Failed to open file \"%s\"\n", fn);
exit(-1);
}
int wtW, wtH;
wt = anqfits_readpix(anq, ext, 0, 0, 0, 0, 0,
PTYPE_FLOAT, NULL, &wtW, &wtH);
if (!wt) {
ERROR("Failed to read image from ext %i of %s\n", ext, fn);
exit(-1);
}
anqfits_close(wanq);
logmsg("Read image: %i x %i.\n", wtW, wtH);
if (wtW != W || wtH != H) {
ERROR("Size mismatch between image and weight!");
exit(-1);
}
} else {
char* endp;
overallwt = strtod(fn, &endp);
if (endp == fn) {
ERROR("Weight: \"%s\" is neither a file nor a double.\n", fn);
exit(-1);
}
logmsg("Parsed weight value \"%g\"\n", overallwt);
}
if (divweight && wt) {
int j;
logmsg("Dividing image by weight image...\n");
for (j=0; j<(W*H); j++)
img[j] /= wt[j];
}
coadd_add_image(coadd, img, wt, overallwt, inwcs);
anwcs_free(inwcs);
free(img);
if (wt)
free(wt);
}
//
logmsg("Writing output: %s\n", outfn);
coadd_divide_by_weight(coadd, 0.0);
/*
if (fits_write_float_image_hdr(coadd->img, coadd->W, coadd->H, outfn)) {
ERROR("Failed to write output image %s", outfn);
exit(-1);
}
*/
/*
if (fits_write_float_image(coadd->img, coadd->W, coadd->H, outfn)) {
ERROR("Failed to write output image %s", outfn);
exit(-1);
}
*/
{
qfitsdumper qoutimg;
qfits_header* hdr;
hdr = anqfits_get_header2(outwcsfn, outwcsext);
if (!hdr) {
ERROR("Failed to read WCS file \"%s\" ext %i\n", outwcsfn, outwcsext);
exit(-1);
}
fits_header_mod_int(hdr, "NAXIS", 2, NULL);
fits_header_set_int(hdr, "NAXIS1", coadd->W, "image width");
fits_header_set_int(hdr, "NAXIS2", coadd->H, "image height");
fits_header_modf(hdr, "BITPIX", "-32", "32-bit floats");
memset(&qoutimg, 0, sizeof(qoutimg));
qoutimg.filename = outfn;
qoutimg.npix = coadd->W * coadd->H;
qoutimg.fbuf = coadd->img;
qoutimg.ptype = PTYPE_FLOAT;
qoutimg.out_ptype = BPP_IEEE_FLOAT;
if (fits_write_header_and_image(NULL, &qoutimg, coadd->W)) {
ERROR("Failed to write FITS image to file \"%s\"", outfn);
exit(-1);
}
qfits_header_destroy(hdr);
}
coadd_free(coadd);
sl_free2(inimgfns);
sl_free2(inwcsfns);
sl_free2(inwtfns);
il_free(inimgexts);
il_free(inwcsexts);
il_free(inwtexts);
anwcs_free(outwcs);
return 0;
}
int main(int argc, char** args) {
int ext = 0,c;
double ra,dec;
double sol[2];
const gsl_multiroot_fsolver_type *T;
gsl_multiroot_fsolver *s;
int status;
size_t iter=0;
const size_t n=2;
gsl_multiroot_function f={&fvec,n,NULL};
gsl_vector *x = gsl_vector_alloc(n);
char *wcsfn1=NULL, *wcsfn2=NULL;
while ((c = getopt(argc, args, OPTIONS)) != -1) {
switch(c) {
case 'v':
loglvl++;
break;
case 'h':
print_help(args[0]);
exit(0);
case '1':
wcsfn1 = optarg;
break;
case '2':
wcsfn2 = optarg;
break;
}
}
log_init(loglvl);
if (optind != argc) {
print_help(args[0]);
exit(-1);
}
if (!(wcsfn1) || !(wcsfn2)) {
print_help(args[0]);
exit(-1);
}
/* open the two wcs systems */
wcs1 = anwcs_open(wcsfn1, ext);
if (!wcs1) {
ERROR("Failed to read WCS file");
exit(-1);
}
logverb("Read WCS:\n");
if (log_get_level() >= LOG_VERB) {
anwcs_print(wcs1, log_get_fid());
}
wcs2 = anwcs_open(wcsfn2, ext);
if (!wcs2) {
ERROR("Failed to read WCS file");
exit(-1);
}
logverb("Read WCS:\n");
if (log_get_level() >= LOG_VERB) {
anwcs_print(wcs2, log_get_fid());
}
/* setup the solver, start in the middle */
gsl_vector_set(x,0,anwcs_imagew(wcs1)/2.0);
gsl_vector_set(x,1,anwcs_imageh(wcs1)/2.0);
T = gsl_multiroot_fsolver_hybrids;
s = gsl_multiroot_fsolver_alloc (T,2);
gsl_multiroot_fsolver_set(s,&f,x);
print_state(iter,s);
do {
iter++;
status = gsl_multiroot_fsolver_iterate(s);
print_state(iter,s);
if (status) break;
status = gsl_multiroot_test_residual(s->f,1e-7);
} while (status == GSL_CONTINUE && iter < 1000);
sol[0]=gsl_vector_get(s->x,0);
sol[1]=gsl_vector_get(s->x,1);
/* write some diagnostics on stderr */
/* transform to ra/dec */
anwcs_pixelxy2radec(wcs1, sol[0], sol[1], &ra, &dec);
if (loglvl > LOG_MSG)
fprintf(stderr,"Pixel (%.10f, %.10f) -> RA,Dec (%.10f, %.10f)\n",
sol[0], sol[1], ra, dec);
/* transform to x/y with second wcs
center of rotation should stay the same x/y */
anwcs_radec2pixelxy(wcs2, ra, dec, &sol[0], &sol[1]);
if (loglvl > LOG_MSG)
fprintf(stderr,"RA,Dec (%.10f, %.10f) -> Pixel (%.10f, %.10f) \n",
ra, dec, sol[0], sol[1]);
/* write the solution */
fprintf(stdout,"%f\n",sol[0]);
fprintf(stdout,"%f\n",sol[1]);
return(0);
}