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 *argv[]) {
int argchar;
char* infn = NULL;
char* outfn = NULL;
FILE* fout;
anbool tostdout = FALSE;
anqfits_t* anq;
int W, H;
qfits_header* hdr;
const anqfits_image_t* animg;
float* img;
int loglvl = LOG_MSG;
int scale = 2;
int winw;
int winh;
int plane;
int out_bitpix = -32;
float* outimg;
int outw, outh;
int edge = EDGE_TRUNCATE;
int ext = 0;
int npixout = 0;
while ((argchar = getopt (argc, argv, OPTIONS)) != -1)
switch (argchar) {
case 'v':
loglvl++;
break;
case 's':
scale = atoi(optarg);
break;
case 'e':
ext = atoi(optarg);
break;
case '?':
case 'h':
printHelp(argv[0]);
return 0;
default:
return -1;
}
log_init(loglvl);
log_to(stderr);
errors_log_to(stderr);
fits_use_error_system();
if (argc - optind != 2) {
logerr("Need two arguments: input and output files.\n");
printHelp(argv[0]);
exit(-1);
}
infn = argv[optind];
outfn = argv[optind+1];
if (streq(outfn, "-")) {
tostdout = TRUE;
fout = stdout;
} else {
fout = fopen(outfn, "wb");
if (!fout) {
SYSERROR("Failed to open output file \"%s\"", outfn);
exit(-1);
}
}
anq = anqfits_open(infn);
if (!anq) {
ERROR("Failed to open input file \"%s\"", infn);
exit(-1);
}
animg = anqfits_get_image_const(anq, ext);
W = (int)animg->width;
H = (int)animg->height;
if (!animg) {
ERROR("Failde to read image from \"%s\"", infn);
exit(-1);
}
/*
if (tostdout)
dump.filename = "STDOUT";
else
dump.filename = outfn;
dump.ptype = PTYPE_FLOAT;
dump.out_ptype = out_bitpix;
*/
get_output_image_size(W % scale, H % scale,
scale, edge, &outw, &outh);
outw += (W / scale);
outh += (H / scale);
hdr = qfits_header_default();
fits_header_add_int(hdr, "BITPIX", out_bitpix, "bits per pixel");
if (animg->planes > 1)
fits_header_add_int(hdr, "NAXIS", 3, "number of axes");
else
fits_header_add_int(hdr, "NAXIS", 2, "number of axes");
fits_header_add_int(hdr, "NAXIS1", outw, "image width");
fits_header_add_int(hdr, "NAXIS2", outh, "image height");
if (animg->planes > 1)
fits_header_add_int(hdr, "NAXIS3", animg->planes, "number of planes");
if (qfits_header_dump(hdr, fout)) {
ERROR("Failed to write FITS header to \"%s\"", outfn);
exit(-1);
}
qfits_header_destroy(hdr);
winw = W;
winh = (int)ceil(ceil(1024*1024 / (float)winw) / (float)scale) * scale;
outimg = malloc((int)ceil(winw/scale)*(int)ceil(winh/scale) * sizeof(float));
logmsg("Image is %i x %i x %i\n", W, H, (int)animg->planes);
logmsg("Output will be %i x %i x %i\n", outw, outh, (int)animg->planes);
logverb("Reading in blocks of %i x %i\n", winw, winh);
for (plane=0; plane<animg->planes; plane++) {
int bx, by;
int nx, ny;
for (by=0; by<(int)ceil(H / (float)winh); by++) {
for (bx=0; bx<(int)ceil(W / (float)winw); bx++) {
int i;
int lox, loy, hix, hiy, outw, outh;
nx = MIN(winw, W - bx*winw);
ny = MIN(winh, H - by*winh);
lox = bx*winw;
loy = by*winh;
hix = lox + nx;
hiy = loy + ny;
logverb(" reading %i,%i + %i,%i\n", lox, loy, nx, ny);
img = anqfits_readpix(anq, ext, lox, hix, loy, hiy, plane,
PTYPE_FLOAT, NULL, &W, &H);
if (!img) {
ERROR("Failed to load pixel window: x=[%i, %i), y=[%i,%i), plane %i\n",
lox, hix, loy, hiy, plane);
exit(-1);
}
average_image_f(img, nx, ny, scale, edge,
&outw, &outh, outimg);
free(img);
logverb(" writing %i x %i\n", outw, outh);
if (outw * outh == 0)
continue;
for (i=0; i<outw*outh; i++) {
int nbytes = abs(out_bitpix)/8;
char buf[nbytes];
if (qfits_pixel_ctofits(PTYPE_FLOAT, out_bitpix,
outimg + i, buf)) {
ERROR("Failed to convert pixel to FITS type\n");
exit(-1);
}
if (fwrite(buf, nbytes, 1, fout) != 1) {
ERROR("Failed to write pixels\n");
exit(-1);
}
}
npixout += outw*outh;
}
}
}
free(outimg);
anqfits_close(anq);
if (tostdout) {
// pad.
int N;
char pad[2880];
N = (npixout * (abs(out_bitpix) / 8)) % 2880;
memset(pad, 0, 2880);
fwrite(pad, 1, N, fout);
} else {
if (fits_pad_file(fout)) {
ERROR("Failed to pad output file");
exit(-1);
}
if (fclose(fout)) {
SYSERROR("Failed to close output file");
exit(-1);
}
}
logverb("Done!\n");
return 0;
}