static int plot_annotations(augment_xylist_t* axy, const char* me, anbool verbose,
const char* annfn, double plotscale, const char* bgfn) {
sl* cmdline = sl_new(16);
char* cmd;
sl* lines;
char* imgfn;
imgfn = axy->pnmfn;
if (bgfn) {
append_executable(cmdline, "jpegtopnm", me);
append_escape(cmdline, bgfn);
sl_append(cmdline, "|");
imgfn = "-";
} else if (axy->imagefn && plotscale != 1.0) {
append_executable(cmdline, "pnmscale", me);
sl_appendf(cmdline, "%f", plotscale);
append_escape(cmdline, axy->pnmfn);
sl_append(cmdline, "|");
imgfn = "-";
}
append_executable(cmdline, "plot-constellations", me);
if (verbose)
sl_append(cmdline, "-v");
sl_append(cmdline, "-w");
assert(axy->wcsfn);
append_escape(cmdline, axy->wcsfn);
sl_append(cmdline, "-i");
append_escape(cmdline, imgfn);
if (plotscale != 1.0) {
sl_append(cmdline, "-s");
sl_appendf(cmdline, "%f", plotscale);
}
sl_append(cmdline, "-N");
sl_append(cmdline, "-B");
sl_append(cmdline, "-C");
sl_append(cmdline, "-o");
assert(annfn);
append_escape(cmdline, annfn);
cmd = sl_implode(cmdline, " ");
sl_free2(cmdline);
logverb("Running:\n %s\n", cmd);
if (run_command_get_outputs(cmd, &lines, NULL)) {
ERROR("plot-constellations failed");
return -1;
}
free(cmd);
if (lines && sl_size(lines)) {
int i;
if (strlen(sl_get(lines, 0))) {
logmsg("Your field contains:\n");
for (i=0; i<sl_size(lines); i++)
logmsg(" %s\n", sl_get(lines, i));
}
}
if (lines)
sl_free2(lines);
return 0;
}
char* ngc_get_name_list(ngc_entry* entry, const char* separator) {
char* str;
sl* lst = ngc_get_names(entry, NULL);
str = sl_implode(lst, separator);
sl_free2(lst);
return str;
}
int plotstuff_append_doubles(const char* str, dl* lst) {
int i;
sl* strs = sl_split(NULL, str, " ");
for (i=0; i<sl_size(strs); i++)
dl_append(lst, atof(sl_get(strs, i)));
sl_free2(strs);
return 0;
}
void test_log_ts(CuTest* tc) {
pthread_t t1, t2;
FILE *f1, *f2;
char *fn1, *fn2;
sl* lst;
log_init(LOG_VERB);
logmsg("Logging initialized.\n");
log_set_thread_specific();
logmsg("Logging set thread specific.\n");
fn1 = create_temp_file("log", "/tmp");
fn2 = create_temp_file("log", "/tmp");
logmsg("File 1 is %s\n", fn1);
logmsg("File 2 is %s\n", fn2);
f1 = fopen(fn1, "w");
f2 = fopen(fn2, "w");
CuAssertIntEquals(tc, 0, pthread_create(&t1, NULL, thread1, f1));
CuAssertIntEquals(tc, 0, pthread_create(&t2, NULL, thread2, f2));
CuAssertIntEquals(tc, 0, pthread_join(t1, NULL));
CuAssertIntEquals(tc, 0, pthread_join(t2, NULL));
fclose(f1);
fclose(f2);
lst = file_get_lines(fn1, FALSE);
CuAssertIntEquals(tc, 0, strcmp(sl_get(lst, 0), STRING1A));
CuAssertIntEquals(tc, 1, sl_size(lst));
sl_free2(lst);
lst = file_get_lines(fn2, FALSE);
CuAssertIntEquals(tc, 0, strcmp(sl_get(lst, 0), STRING2A));
CuAssertIntEquals(tc, 0, strcmp(sl_get(lst, 1), STRING2B));
CuAssertIntEquals(tc, 2, sl_size(lst));
sl_free2(lst);
unlink(fn1);
unlink(fn2);
free(fn1);
free(fn2);
}
void test_sl_split_1(CuTest* tc) {
sl* s = sl_split(NULL, "hello world this is a test", " ");
CuAssertPtrNotNull(tc, s);
CuAssertIntEquals(tc, 6, sl_size(s));
CuAssertIntEquals(tc, 0, strcmp(sl_get(s, 0), "hello"));
CuAssertIntEquals(tc, 0, strcmp(sl_get(s, 1), "world"));
CuAssertIntEquals(tc, 0, strcmp(sl_get(s, 2), "this"));
CuAssertIntEquals(tc, 0, strcmp(sl_get(s, 3), "is"));
CuAssertIntEquals(tc, 0, strcmp(sl_get(s, 4), "a"));
CuAssertIntEquals(tc, 0, strcmp(sl_get(s, 5), "test"));
sl_free2(s);
}
void fitstable_error_report_missing(fitstable_t* tab) {
int i;
sl* missing = sl_new(4);
char* mstr;
for (i=0; i<ncols(tab); i++) {
fitscol_t* col = getcol(tab, i);
if (col->col == -1 && col->required)
sl_append(missing, col->colname);
}
mstr = sl_join(missing, ", ");
sl_free2(missing);
ERROR("Missing required columns: %s", mstr);
free(mstr);
}
void test_sl_split_3(CuTest* tc) {
sl* s, *s2;
s = sl_new(1);
sl_append(s, "guard");
s2 = sl_split(s, "XYhelloXYworldXYXY", "XY");
CuAssertPtrNotNull(tc, s2);
CuAssertPtrEquals(tc, s, s2);
CuAssertIntEquals(tc, 5, sl_size(s));
CuAssertIntEquals(tc, 0, strcmp(sl_get(s, 0), "guard"));
CuAssertIntEquals(tc, 0, strcmp(sl_get(s, 1), ""));
CuAssertIntEquals(tc, 0, strcmp(sl_get(s, 2), "hello"));
CuAssertIntEquals(tc, 0, strcmp(sl_get(s, 3), "world"));
CuAssertIntEquals(tc, 0, strcmp(sl_get(s, 4), ""));
sl_free2(s);
}
int main(int argc, char *argv[]) {
char* progname = argv[0];
int argchar;
char* infn;
sl* methods = NULL;
dl* scales = NULL;
int i;
int loglvl = LOG_MSG;
while ((argchar = getopt (argc, argv, OPTIONS)) != -1)
switch (argchar) {
case '?':
case 'h':
printHelp(progname);
return 0;
case 'v':
loglvl++;
break;
default:
return -1;
}
if (optind != (argc - 1)) {
printHelp(progname);
exit(-1);
}
infn = argv[optind];
log_init(loglvl);
fits_use_error_system();
if (fits_guess_scale(infn, &methods, &scales))
exit(-1);
for (i=0; i<sl_size(methods); i++) {
printf("scale %s %g\n", sl_get(methods, i), dl_get(scales, i));
}
sl_free2(methods);
dl_free(scales);
return 0;
}
void test_sl_split_2(CuTest* tc) {
int i;
sl* s = sl_split(NULL, "hello world this is a test ", " ");
CuAssertPtrNotNull(tc, s);
printf("got: ");
for (i=0; i<sl_size(s); i++)
printf("/%s/ ", sl_get(s, i));
printf("\n");
CuAssertIntEquals(tc, 8, sl_size(s));
CuAssertIntEquals(tc, 0, strcmp(sl_get(s, 0), "hello"));
CuAssertIntEquals(tc, 0, strcmp(sl_get(s, 1), "world"));
CuAssertIntEquals(tc, 0, strcmp(sl_get(s, 2), "this"));
CuAssertIntEquals(tc, 0, strcmp(sl_get(s, 3), "is"));
CuAssertIntEquals(tc, 0, strcmp(sl_get(s, 4), "a"));
CuAssertIntEquals(tc, 0, strcmp(sl_get(s, 5), "test"));
CuAssertIntEquals(tc, 0, strcmp(sl_get(s, 6), ""));
CuAssertIntEquals(tc, 0, strcmp(sl_get(s, 7), " "));
sl_free2(s);
}
void test_sl_join(CuTest* tc) {
char* s1;
sl* s = sl_new(4);
sl_append(s, "123");
sl_appendf(s, "%1$s%1$s", "testing");
addsome(s, "%i", 456);
sl_insert(s, 1, "inserted");
sl_insertf(s, 2, "%s%s", "ins", "ertedf");
s1 = sl_join(s, "");
CuAssertStrEquals(tc, "123insertedinsertedftestingtesting456", s1);
free(s1);
s1 = sl_join(s, "--");
CuAssertStrEquals(tc, "123--inserted--insertedf--testingtesting--456", s1);
free(s1);
s1 = sl_join_reverse(s, "--");
CuAssertStrEquals(tc, "456--testingtesting--insertedf--inserted--123", s1);
free(s1);
sl_free2(s);
}
/**
fitscopy ~/DATA/tycho2-cut.fits"[RA<10 && DEC > 0 && DEC < 10]" t.fits
build-index -i t.fits -o t10.index -P 10 -E -M -v -S mag
build-index -1 t10.index -o t11.index -P 11 -E -M -v -S mag
build-index -1 t10.index -o t12.index -P 12 -E -M -v -S mag
fitsgetext -i t10.index -o t10.skdt -e 0 -e 7 -e 8 -e 9 -e 10 -e 11 -e 12 -e 13
fitsgetext -i t10.index -o t10.ind -e 0 -e 1 -e 2 -e 3 -e 4 -e 5 -e 6
fitsgetext -i t11.index -o t11.ind -e 0 -e 1 -e 2 -e 3 -e 4 -e 5 -e 6
fitsgetext -i t12.index -o t12.ind -e 0 -e 1 -e 2 -e 3 -e 4 -e 5 -e 6
*/
void test_multiindex(CuTest* ct) {
sl* fns;
multiindex_t* mi;
int i;
fns = sl_new(4);
sl_append(fns, "t10.ind");
sl_append(fns, "t11.ind");
sl_append(fns, "t12.ind");
mi = multiindex_open("t10.skdt", fns);
printf("Got %i indices\n", multiindex_n(mi));
for (i=0; i<multiindex_n(mi); i++) {
index_t* ind = multiindex_get(mi, i);
printf(" %i: %s, %i stars, %i quads (%g to %g arcmin)\n",
i, ind->indexname, index_nquads(ind), index_nstars(ind),
ind->index_scale_lower/60., ind->index_scale_upper/60.);
}
multiindex_free(mi);
sl_free2(fns);
}
int main(int argc, char** args) {
int c;
char* wcsfn = NULL;
char* outfn = NULL;
char* infn = NULL;
sip_t sip;
double scale = 1.0;
anbool pngformat = TRUE;
char* hdpath = NULL;
anbool HD = FALSE;
cairos_t thecairos;
cairos_t* cairos = &thecairos;
cairo_surface_t* target = NULL;
cairo_t* cairot = NULL;
cairo_surface_t* surfbg = NULL;
cairo_t* cairobg = NULL;
cairo_surface_t* surfshapes = NULL;
cairo_t* cairoshapes = NULL;
cairo_surface_t* surfshapesmask = NULL;
cairo_t* cairoshapesmask = NULL;
cairo_surface_t* surffg = NULL;
cairo_t* cairo = NULL;
double lw = 2.0;
// circle linewidth.
double cw = 2.0;
double ngc_fraction = 0.02;
// NGC linewidth
double nw = 2.0;
// leave a gap short of connecting the points.
double endgap = 5.0;
// circle radius.
double crad = endgap;
double fontsize = 14.0;
double label_offset = 15.0;
int W = 0, H = 0;
unsigned char* img = NULL;
anbool NGC = FALSE, constell = FALSE;
anbool bright = FALSE;
anbool common_only = FALSE;
anbool print_common_only = FALSE;
int Nbright = 0;
double ra, dec, px, py;
int i, N;
anbool justlist = FALSE;
anbool only_messier = FALSE;
anbool grid = FALSE;
double gridspacing = 0.0;
double gridcolor[3] = { 0.2, 0.2, 0.2 };
int loglvl = LOG_MSG;
char halign = 'L';
char valign = 'C';
sl* json = NULL;
anbool whitetext = FALSE;
while ((c = getopt(argc, args, OPTIONS)) != -1) {
switch (c) {
case 'V':
valign = optarg[0];
break;
case 'O':
halign = optarg[0];
break;
case 'F':
ngc_fraction = atof(optarg);
break;
case 'h':
print_help(args[0]);
exit(0);
case 'J':
json = sl_new(4);
break;
case 'G':
gridspacing = atof(optarg);
break;
case 'g':
{
char *tail = NULL;
gridcolor[0] = strtod(optarg,&tail);
if (*tail) { tail++; gridcolor[1] = strtod(tail,&tail); }
if (*tail) { tail++; gridcolor[2] = strtod(tail,&tail); }
}
break;
case 'D':
HD = TRUE;
break;
case 'd':
hdpath = optarg;
break;
case 'M':
only_messier = TRUE;
break;
case 'n':
nw = atof(optarg);
break;
case 'f':
fontsize = atof(optarg);
break;
case 'L':
justlist = TRUE;
outfn = NULL;
break;
case 'x':
whitetext = TRUE;
break;
case 'v':
loglvl++;
break;
break;
case 'j':
print_common_only = TRUE;
break;
case 'c':
common_only = TRUE;
break;
case 'b':
Nbright = atoi(optarg);
break;
case 'B':
bright = TRUE;
break;
case 'N':
NGC = TRUE;
break;
case 'C':
constell = TRUE;
break;
case 'p':
pngformat = FALSE;
break;
case 's':
scale = atof(optarg);
break;
case 'o':
outfn = optarg;
break;
case 'i':
infn = optarg;
break;
case 'w':
wcsfn = optarg;
break;
case 'W':
W = atoi(optarg);
break;
case 'H':
H = atoi(optarg);
break;
}
}
log_init(loglvl);
log_to(stderr);
fits_use_error_system();
if (optind != argc) {
print_help(args[0]);
exit(-1);
}
if (!(outfn || justlist) || !wcsfn) {
logerr("Need (-o or -L) and -w args.\n");
print_help(args[0]);
exit(-1);
}
// read WCS.
logverb("Trying to parse SIP/TAN header from %s...\n", wcsfn);
if (!file_exists(wcsfn)) {
ERROR("No such file: \"%s\"", wcsfn);
exit(-1);
}
if (sip_read_header_file(wcsfn, &sip)) {
logverb("Got SIP header.\n");
} else {
ERROR("Failed to parse SIP/TAN header from %s", wcsfn);
exit(-1);
}
if (!(NGC || constell || bright || HD || grid)) {
logerr("Neither constellations, bright stars, HD nor NGC/IC overlays selected!\n");
print_help(args[0]);
exit(-1);
}
if (gridspacing > 0.0)
grid = TRUE;
// adjust for scaling...
lw /= scale;
cw /= scale;
nw /= scale;
crad /= scale;
endgap /= scale;
fontsize /= scale;
label_offset /= scale;
if (!W || !H) {
W = sip.wcstan.imagew;
H = sip.wcstan.imageh;
}
if (!(infn || (W && H))) {
logerr("Image width/height unspecified, and no input image given.\n");
exit(-1);
}
if (infn) {
cairoutils_fake_ppm_init();
img = cairoutils_read_ppm(infn, &W, &H);
if (!img) {
ERROR("Failed to read input image %s", infn);
exit(-1);
}
cairoutils_rgba_to_argb32(img, W, H);
} else if (!justlist) {
// Allocate a black image.
img = calloc(4 * W * H, 1);
if (!img) {
SYSERROR("Failed to allocate a blank image on which to plot!");
exit(-1);
}
}
if (HD && !hdpath) {
logerr("If you specify -D (plot Henry Draper objs), you also have to give -d (path to Henry Draper catalog)\n");
exit(-1);
}
if (!justlist) {
/*
Cairo layers:
-background: surfbg / cairobg
--> gets drawn first, in black, masked by surfshapesmask
-shapes: surfshapes / cairoshapes
--> gets drawn second, masked by surfshapesmask
-foreground/text: surffg / cairo
--> gets drawn last.
*/
surffg = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, W, H);
cairo = cairo_create(surffg);
cairo_set_line_join(cairo, CAIRO_LINE_JOIN_BEVEL);
cairo_set_antialias(cairo, CAIRO_ANTIALIAS_GRAY);
cairo_set_source_rgba(cairo, 1.0, 1.0, 1.0, 1.0);
cairo_scale(cairo, scale, scale);
//cairo_select_font_face(cairo, "helvetica", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_BOLD);
cairo_select_font_face(cairo, "DejaVu Sans Mono Book", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_BOLD);
cairo_set_font_size(cairo, fontsize);
surfshapes = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, W, H);
cairoshapes = cairo_create(surfshapes);
cairo_set_line_join(cairoshapes, CAIRO_LINE_JOIN_BEVEL);
cairo_set_antialias(cairoshapes, CAIRO_ANTIALIAS_GRAY);
cairo_set_source_rgba(cairoshapes, 1.0, 1.0, 1.0, 1.0);
cairo_scale(cairoshapes, scale, scale);
cairo_select_font_face(cairoshapes, "DejaVu Sans Mono Book", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_BOLD);
cairo_set_font_size(cairoshapes, fontsize);
surfshapesmask = cairo_image_surface_create(CAIRO_FORMAT_A8, W, H);
cairoshapesmask = cairo_create(surfshapesmask);
cairo_set_line_join(cairoshapesmask, CAIRO_LINE_JOIN_BEVEL);
cairo_set_antialias(cairoshapesmask, CAIRO_ANTIALIAS_GRAY);
cairo_set_source_rgba(cairoshapesmask, 1.0, 1.0, 1.0, 1.0);
cairo_scale(cairoshapesmask, scale, scale);
cairo_select_font_face(cairoshapesmask, "DejaVu Sans Mono Book", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_BOLD);
cairo_set_font_size(cairoshapesmask, fontsize);
cairo_paint(cairoshapesmask);
cairo_stroke(cairoshapesmask);
surfbg = cairo_image_surface_create(CAIRO_FORMAT_A8, W, H);
cairobg = cairo_create(surfbg);
cairo_set_line_join(cairobg, CAIRO_LINE_JOIN_BEVEL);
cairo_set_antialias(cairobg, CAIRO_ANTIALIAS_GRAY);
cairo_set_source_rgba(cairobg, 0, 0, 0, 1);
cairo_scale(cairobg, scale, scale);
cairo_select_font_face(cairobg, "DejaVu Sans Mono Book", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_BOLD);
cairo_set_font_size(cairobg, fontsize);
cairos->bg = cairobg;
cairos->fg = cairo;
cairos->shapes = cairoshapes;
cairos->shapesmask = cairoshapesmask;
cairos->imgW = (float)W/scale;
cairos->imgH = (float)H/scale;
// }
if (grid) {
double ramin, ramax, decmin, decmax;
double ra, dec;
double rastep = gridspacing / 60.0;
double decstep = gridspacing / 60.0;
// how many line segments
int N = 10;
double px, py;
int i;
cairo_set_source_rgba(cairo, gridcolor[0], gridcolor[1], gridcolor[2], 1.0);
sip_get_radec_bounds(&sip, 100, &ramin, &ramax, &decmin, &decmax);
logverb("Plotting grid lines from RA=%g to %g in steps of %g; Dec=%g to %g in steps of %g\n",
ramin, ramax, rastep, decmin, decmax, decstep);
for (dec = decstep * floor(decmin / decstep); dec<=decmax; dec+=decstep) {
logverb(" dec=%g\n", dec);
for (i=0; i<=N; i++) {
ra = ramin + ((double)i / (double)N) * (ramax - ramin);
if (!sip_radec2pixelxy(&sip, ra, dec, &px, &py))
continue;
// first time, move_to; else line_to
((ra == ramin) ? cairo_move_to : cairo_line_to)(cairo, px, py);
}
cairo_stroke(cairo);
}
for (ra = rastep * floor(ramin / rastep); ra <= ramax; ra += rastep) {
//for (dec=decmin; dec<=decmax; dec += (decmax - decmin)/(double)N) {
logverb(" ra=%g\n", ra);
for (i=0; i<=N; i++) {
dec = decmin + ((double)i / (double)N) * (decmax - decmin);
if (!sip_radec2pixelxy(&sip, ra, dec, &px, &py))
continue;
// first time, move_to; else line_to
((dec == decmin) ? cairo_move_to : cairo_line_to)(cairo, px, py);
}
cairo_stroke(cairo);
}
cairo_set_source_rgba(cairo, 1.0, 1.0, 1.0, 1.0);
}
}
if (constell) {
N = constellations_n();
logverb("Checking %i constellations.\n", N);
for (c=0; c<N; c++) {
const char* shortname = NULL;
const char* longname;
il* lines;
il* uniqstars;
il* inboundstars;
float r,g,b;
int Ninbounds;
int Nunique;
cairo_text_extents_t textents;
double cmass[3];
uniqstars = constellations_get_unique_stars(c);
inboundstars = il_new(16);
Nunique = il_size(uniqstars);
debug("%s: %zu unique stars.\n", shortname, il_size(uniqstars));
// Count the number of unique stars belonging to this contellation
// that are within the image bounds
Ninbounds = 0;
for (i=0; i<il_size(uniqstars); i++) {
int star;
star = il_get(uniqstars, i);
constellations_get_star_radec(star, &ra, &dec);
debug("star %i: ra,dec (%g,%g)\n", il_get(uniqstars, i), ra, dec);
if (!sip_radec2pixelxy(&sip, ra, dec, &px, &py))
continue;
if (px < 0 || py < 0 || px*scale > W || py*scale > H)
continue;
Ninbounds++;
il_append(inboundstars, star);
}
il_free(uniqstars);
debug("%i are in-bounds.\n", Ninbounds);
// Only draw this constellation if at least 2 of its stars
// are within the image bounds.
if (Ninbounds < 2) {
il_free(inboundstars);
continue;
}
// Set the color based on the location of the first in-bounds star.
// This is a hack -- we have two different constellation
// definitions with different numbering schemes!
if (!justlist && (il_size(inboundstars) > 0)) {
// This is helpful for videos: ensuring that the same
// color is chosen for a constellation in each frame.
int star = il_get(inboundstars, 0);
constellations_get_star_radec(star, &ra, &dec);
if (whitetext) {
r = g = b = 1;
} else {
color_for_radec(ra, dec, &r, &g, &b);
}
cairo_set_source_rgba(cairoshapes, r,g,b,0.8);
cairo_set_line_width(cairoshapes, cw);
cairo_set_source_rgba(cairo, r,g,b,0.8);
cairo_set_line_width(cairo, cw);
}
// Draw circles around each star.
// Find center of mass (of the in-bounds stars)
cmass[0] = cmass[1] = cmass[2] = 0.0;
for (i=0; i<il_size(inboundstars); i++) {
double xyz[3];
int star = il_get(inboundstars, i);
constellations_get_star_radec(star, &ra, &dec);
if (!sip_radec2pixelxy(&sip, ra, dec, &px, &py))
continue;
if (px < 0 || py < 0 || px*scale > W || py*scale > H)
continue;
if (!justlist) {
cairo_arc(cairobg, px, py, crad+1.0, 0.0, 2.0*M_PI);
cairo_stroke(cairobg);
cairo_arc(cairoshapes, px, py, crad, 0.0, 2.0*M_PI);
cairo_stroke(cairoshapes);
}
radecdeg2xyzarr(ra, dec, xyz);
cmass[0] += xyz[0];
cmass[1] += xyz[1];
cmass[2] += xyz[2];
}
cmass[0] /= il_size(inboundstars);
cmass[1] /= il_size(inboundstars);
cmass[2] /= il_size(inboundstars);
xyzarr2radecdeg(cmass, &ra, &dec);
il_free(inboundstars);
if (!sip_radec2pixelxy(&sip, ra, dec, &px, &py))
continue;
shortname = constellations_get_shortname(c);
longname = constellations_get_longname(c);
assert(shortname && longname);
logverb("%s at (%g, %g)\n", longname, px, py);
if (Ninbounds == Nunique) {
printf("The constellation %s (%s)\n", longname, shortname);
} else {
printf("Part of the constellation %s (%s)\n", longname, shortname);
}
if (justlist)
continue;
// If the label will be off-screen, move it back on.
cairo_text_extents(cairo, shortname, &textents);
if (px < 0)
px = 0;
if (py < textents.height)
py = textents.height;
if ((px + textents.width)*scale > W)
px = W/scale - textents.width;
if ((py+textents.height)*scale > H)
py = H/scale - textents.height;
logverb("%s at (%g, %g)\n", shortname, px, py);
add_text(cairos, longname, px, py, halign, valign);
// Draw the lines.
cairo_set_line_width(cairo, lw);
lines = constellations_get_lines(c);
for (i=0; i<il_size(lines)/2; i++) {
int star1, star2;
double ra1, dec1, ra2, dec2;
double px1, px2, py1, py2;
double dx, dy;
double dist;
double gapfrac;
star1 = il_get(lines, i*2+0);
star2 = il_get(lines, i*2+1);
constellations_get_star_radec(star1, &ra1, &dec1);
constellations_get_star_radec(star2, &ra2, &dec2);
if (!sip_radec2pixelxy(&sip, ra1, dec1, &px1, &py1) ||
!sip_radec2pixelxy(&sip, ra2, dec2, &px2, &py2))
continue;
dx = px2 - px1;
dy = py2 - py1;
dist = hypot(dx, dy);
gapfrac = endgap / dist;
cairo_move_to(cairoshapes, px1 + dx*gapfrac, py1 + dy*gapfrac);
cairo_line_to(cairoshapes, px1 + dx*(1.0-gapfrac), py1 + dy*(1.0-gapfrac));
cairo_stroke(cairoshapes);
}
il_free(lines);
}
logverb("done constellations.\n");
}
if (bright) {
double dy = 0;
cairo_font_extents_t extents;
pl* brightstars = pl_new(16);
if (!justlist) {
cairo_set_source_rgba(cairoshapes, 0.75, 0.75, 0.75, 0.8);
cairo_font_extents(cairo, &extents);
dy = extents.ascent * 0.5;
cairo_set_line_width(cairoshapes, cw);
}
N = bright_stars_n();
logverb("Checking %i bright stars.\n", N);
for (i=0; i<N; i++) {
const brightstar_t* bs = bright_stars_get(i);
if (!sip_radec2pixelxy(&sip, bs->ra, bs->dec, &px, &py))
continue;
if (px < 0 || py < 0 || px*scale > W || py*scale > H)
continue;
if (!(bs->name && strlen(bs->name)))
continue;
if (common_only && !(bs->common_name && strlen(bs->common_name)))
continue;
if (strcmp(bs->common_name, "Maia") == 0)
continue;
pl_append(brightstars, bs);
}
// keep only the Nbright brightest?
if (Nbright && (pl_size(brightstars) > Nbright)) {
pl_sort(brightstars, sort_by_mag);
pl_remove_index_range(brightstars, Nbright, pl_size(brightstars)-Nbright);
}
for (i=0; i<pl_size(brightstars); i++) {
char* text;
const brightstar_t* bs = pl_get(brightstars, i);
if (!sip_radec2pixelxy(&sip, bs->ra, bs->dec, &px, &py))
continue;
if (bs->common_name && strlen(bs->common_name))
if (print_common_only || common_only)
text = strdup(bs->common_name);
else
asprintf_safe(&text, "%s (%s)", bs->common_name, bs->name);
else
text = strdup(bs->name);
logverb("%s at (%g, %g)\n", text, px, py);
if (json) {
sl* names = sl_new(4);
char* namearr;
if (bs->common_name && strlen(bs->common_name))
sl_append(names, bs->common_name);
if (bs->name)
sl_append(names, bs->name);
namearr = sl_join(names, "\", \"");
sl_appendf(json,
"{ \"type\" : \"star\", "
" \"pixelx\": %g, "
" \"pixely\": %g, "
" \"name\" : \"%s\", "
" \"names\" : [ \"%s\" ] } "
, px, py,
(bs->common_name && strlen(bs->common_name)) ? bs->common_name : bs->name,
namearr);
free(namearr);
sl_free2(names);
}
if (bs->common_name && strlen(bs->common_name))
printf("The star %s (%s)\n", bs->common_name, bs->name);
else
printf("The star %s\n", bs->name);
if (!justlist) {
float r,g,b;
// set color based on RA,Dec to match constellations above.
if (whitetext) {
r = g = b = 1;
} else {
color_for_radec(bs->ra, bs->dec, &r, &g, &b);
}
cairo_set_source_rgba(cairoshapes, r,g,b,0.8);
cairo_set_source_rgba(cairo, r,g,b, 0.8);
}
if (!justlist)
add_text(cairos, text, px + label_offset, py + dy,
halign, valign);
free(text);
if (!justlist) {
// plot a black circle behind the light circle...
cairo_arc(cairobg, px, py, crad+1.0, 0.0, 2.0*M_PI);
cairo_stroke(cairobg);
cairo_arc(cairoshapes, px, py, crad, 0.0, 2.0*M_PI);
cairo_stroke(cairoshapes);
}
}
pl_free(brightstars);
}
if (NGC) {
double imscale;
double imsize;
double dy = 0;
cairo_font_extents_t extents;
if (!justlist) {
cairo_set_source_rgb(cairoshapes, 1.0, 1.0, 1.0);
cairo_set_source_rgb(cairo, 1.0, 1.0, 1.0);
cairo_set_line_width(cairo, nw);
cairo_font_extents(cairo, &extents);
dy = extents.ascent * 0.5;
}
// arcsec/pixel
imscale = sip_pixel_scale(&sip);
// arcmin
imsize = imscale * (imin(W, H) / scale) / 60.0;
N = ngc_num_entries();
logverb("Checking %i NGC/IC objects.\n", N);
for (i=0; i<N; i++) {
ngc_entry* ngc = ngc_get_entry(i);
sl* str;
sl* names;
double pixsize;
float ara, adec;
char* text;
if (!ngc)
break;
if (ngc->size < imsize * ngc_fraction)
continue;
if (ngcic_accurate_get_radec(ngc->is_ngc, ngc->id, &ara, &adec) == 0) {
ngc->ra = ara;
ngc->dec = adec;
}
if (!sip_radec2pixelxy(&sip, ngc->ra, ngc->dec, &px, &py))
continue;
if (px < 0 || py < 0 || px*scale > W || py*scale > H)
continue;
str = sl_new(4);
//sl_appendf(str, "%s %i", (ngc->is_ngc ? "NGC" : "IC"), ngc->id);
names = ngc_get_names(ngc, NULL);
if (names) {
int n;
for (n=0; n<sl_size(names); n++) {
if (only_messier && strncmp(sl_get(names, n), "M ", 2))
continue;
sl_append(str, sl_get(names, n));
}
}
sl_free2(names);
text = sl_implode(str, " / ");
printf("%s\n", text);
pixsize = ngc->size * 60.0 / imscale;
if (!justlist) {
// black circle behind the white one...
cairo_arc(cairobg, px, py, pixsize/2.0+1.0, 0.0, 2.0*M_PI);
cairo_stroke(cairobg);
cairo_move_to(cairoshapes, px + pixsize/2.0, py);
cairo_arc(cairoshapes, px, py, pixsize/2.0, 0.0, 2.0*M_PI);
debug("size: %f arcsec, pixsize: %f pixels\n", ngc->size, pixsize);
cairo_stroke(cairoshapes);
add_text(cairos, text, px + label_offset, py + dy,
halign, valign);
}
if (json) {
char* namelist = sl_implode(str, "\", \"");
sl_appendf(json,
"{ \"type\" : \"ngc\", "
" \"names\" : [ \"%s\" ], "
" \"pixelx\" : %g, "
" \"pixely\" : %g, "
" \"radius\" : %g }"
, namelist, px, py, pixsize/2.0);
free(namelist);
}
free(text);
sl_free2(str);
}
}
if (HD) {
double rac, decc, ra2, dec2;
double arcsec;
hd_catalog_t* hdcat;
bl* hdlist;
int i;
if (!justlist)
cairo_set_source_rgb(cairo, 1.0, 1.0, 1.0);
logverb("Reading HD catalog: %s\n", hdpath);
hdcat = henry_draper_open(hdpath);
if (!hdcat) {
ERROR("Failed to open HD catalog");
exit(-1);
}
logverb("Got %i HD stars\n", henry_draper_n(hdcat));
sip_pixelxy2radec(&sip, W/(2.0*scale), H/(2.0*scale), &rac, &decc);
sip_pixelxy2radec(&sip, 0.0, 0.0, &ra2, &dec2);
arcsec = arcsec_between_radecdeg(rac, decc, ra2, dec2);
// Fudge
arcsec *= 1.1;
hdlist = henry_draper_get(hdcat, rac, decc, arcsec);
logverb("Found %zu HD stars within range (%g arcsec of RA,Dec %g,%g)\n", bl_size(hdlist), arcsec, rac, decc);
for (i=0; i<bl_size(hdlist); i++) {
double px, py;
char* txt;
hd_entry_t* hd = bl_access(hdlist, i);
if (!sip_radec2pixelxy(&sip, hd->ra, hd->dec, &px, &py)) {
continue;
}
if (px < 0 || py < 0 || px*scale > W || py*scale > H) {
logverb(" HD %i at RA,Dec (%g, %g) -> pixel (%.1f, %.1f) is out of bounds\n",
hd->hd, hd->ra, hd->dec, px, py);
continue;
}
asprintf_safe(&txt, "HD %i", hd->hd);
if (!justlist) {
cairo_text_extents_t textents;
cairo_text_extents(cairo, txt, &textents);
cairo_arc(cairobg, px, py, crad+1.0, 0.0, 2.0*M_PI);
cairo_stroke(cairobg);
cairo_arc(cairoshapes, px, py, crad, 0.0, 2.0*M_PI);
cairo_stroke(cairoshapes);
px -= (textents.width * 0.5);
py -= (crad + 4.0);
add_text(cairos, txt, px, py, halign, valign);
}
if (json)
sl_appendf(json,
"{ \"type\" : \"hd\","
" \"pixelx\": %g, "
" \"pixely\": %g, "
" \"name\" : \"HD %i\" }"
, px, py, hd->hd);
printf("%s\n", txt);
free(txt);
}
bl_free(hdlist);
henry_draper_close(hdcat);
}
if (json) {
FILE* fout = stderr;
char* annstr = sl_implode(json, ",\n");
fprintf(fout, "{ \n");
fprintf(fout, " \"status\": \"solved\",\n");
fprintf(fout, " \"git-revision\": %s,\n", AN_GIT_REVISION);
fprintf(fout, " \"git-date\": \"%s\",\n", AN_GIT_DATE);
fprintf(fout, " \"annotations\": [\n%s\n]\n", annstr);
fprintf(fout, "}\n");
free(annstr);
}
sl_free2(json);
json = NULL;
if (justlist)
return 0;
target = cairo_image_surface_create_for_data(img, CAIRO_FORMAT_ARGB32, W, H, W*4);
cairot = cairo_create(target);
cairo_set_source_rgba(cairot, 0, 0, 0, 1);
// Here's where you set the background surface's properties...
cairo_set_source_surface(cairot, surfbg, 0, 0);
cairo_mask_surface(cairot, surfshapesmask, 0, 0);
cairo_stroke(cairot);
// Add on the shapes.
cairo_set_source_surface(cairot, surfshapes, 0, 0);
//cairo_mask_surface(cairot, surfshapes, 0, 0);
cairo_mask_surface(cairot, surfshapesmask, 0, 0);
cairo_stroke(cairot);
// Add on the foreground.
cairo_set_source_surface(cairot, surffg, 0, 0);
cairo_mask_surface(cairot, surffg, 0, 0);
cairo_stroke(cairot);
// Convert image for output...
cairoutils_argb32_to_rgba(img, W, H);
if (pngformat) {
if (cairoutils_write_png(outfn, img, W, H)) {
ERROR("Failed to write PNG");
exit(-1);
}
} else {
if (cairoutils_write_ppm(outfn, img, W, H)) {
ERROR("Failed to write PPM");
exit(-1);
}
}
cairo_surface_destroy(target);
cairo_surface_destroy(surfshapesmask);
cairo_surface_destroy(surffg);
cairo_surface_destroy(surfbg);
cairo_surface_destroy(surfshapes);
cairo_destroy(cairo);
cairo_destroy(cairot);
cairo_destroy(cairobg);
cairo_destroy(cairoshapes);
cairo_destroy(cairoshapesmask);
free(img);
return 0;
}
void test_solve_multiindex(CuTest* ct) {
sl* fns;
multiindex_t* mi;
int i;
solver_t* s = NULL;
starxy_t* field = NULL;
MatchObj* mo = NULL;
xylist_t* xy = NULL;
log_init(LOG_VERB);
fns = sl_new(4);
sl_append(fns, "../util/t10.ind");
sl_append(fns, "../util/t11.ind");
sl_append(fns, "../util/t12.ind");
mi = multiindex_open("../util/t10.skdt", fns, 0);
printf("Got %i indices\n", multiindex_n(mi));
for (i=0; i<multiindex_n(mi); i++) {
index_t* ind = multiindex_get(mi, i);
printf(" %i: %s, %i stars, %i quads (%g to %g arcmin)\n",
i, ind->indexname, index_nquads(ind), index_nstars(ind),
ind->index_scale_lower/60., ind->index_scale_upper/60.);
}
s = solver_new();
// 10.8
s->funits_lower = 5.0;
s->funits_upper = 15.0;
xy = xylist_open("../util/t1.xy");
if (!xy) {
ERROR("Failed to open xylist\n");
CuFail(ct, "xylist");
}
field = xylist_read_field(xy, NULL);
solver_set_field(s, field);
solver_set_field_bounds(s, 0, 1000, 0, 1000);
for (i=0; i<multiindex_n(mi); i++) {
index_t* ind = multiindex_get(mi, i);
solver_add_index(s, ind);
}
solver_run(s);
if (solver_did_solve(s)) {
mo = solver_get_best_match(s);
matchobj_print(mo, LOG_MSG);
// HACK -- ugly!!
verify_free_matchobj(mo);
}
xylist_close(xy);
solver_cleanup_field(s);
solver_free(s);
multiindex_free(mi);
sl_free2(fns);
}
int main(int argc, char *argv[]) {
int argchar;
char* progname = argv[0];
sl* infns = sl_new(16);
char* outfnpat = NULL;
char* racol = "RA";
char* deccol = "DEC";
char* tempdir = "/tmp";
anbool gzip = FALSE;
sl* cols = sl_new(16);
int loglvl = LOG_MSG;
int nside = 1;
double margin = 0.0;
int NHP;
double md;
char* backref = NULL;
fitstable_t* intable;
fitstable_t** outtables;
char** myargs;
int nmyargs;
int i;
while ((argchar = getopt (argc, argv, OPTIONS)) != -1)
switch (argchar) {
case 'b':
backref = optarg;
break;
case 't':
tempdir = optarg;
break;
case 'c':
sl_append(cols, optarg);
break;
case 'g':
gzip = TRUE;
break;
case 'o':
outfnpat = optarg;
break;
case 'r':
racol = optarg;
break;
case 'd':
deccol = optarg;
break;
case 'n':
nside = atoi(optarg);
break;
case 'm':
margin = atof(optarg);
break;
case 'v':
loglvl++;
break;
case '?':
fprintf(stderr, "Unknown option `-%c'.\n", optopt);
case 'h':
printHelp(progname);
return 0;
default:
return -1;
}
if (sl_size(cols) == 0) {
sl_free2(cols);
cols = NULL;
}
nmyargs = argc - optind;
myargs = argv + optind;
for (i=0; i<nmyargs; i++)
sl_append(infns, myargs[i]);
if (!sl_size(infns)) {
printHelp(progname);
printf("Need input filenames!\n");
exit(-1);
}
log_init(loglvl);
fits_use_error_system();
NHP = 12 * nside * nside;
logmsg("%i output healpixes\n", NHP);
outtables = calloc(NHP, sizeof(fitstable_t*));
assert(outtables);
md = deg2dist(margin);
/**
About the mincaps/maxcaps:
These have a center and radius-squared, describing the region
inside a small circle on the sphere.
The "mincaps" describe the regions that are definitely owned by a
single healpix -- ie, more than MARGIN distance from any edge.
That is, the mincap is the small circle centered at (0.5, 0.5) in
the healpix and with radius = the distance to the closest healpix
boundary, MINUS the margin distance.
Below, we first check whether a new star is within the "mincap"
of any healpix. If so, we stick it in that healpix and continue.
Otherwise, we check all the "maxcaps" -- these are the healpixes
it could *possibly* be in. We then refine with
healpix_within_range_of_xyz. The maxcap distance is the distance
to the furthest boundary point, PLUS the margin distance.
*/
cap_t* mincaps = malloc(NHP * sizeof(cap_t));
cap_t* maxcaps = malloc(NHP * sizeof(cap_t));
for (i=0; i<NHP; i++) {
// center
double r2;
double xyz[3];
double* cxyz;
double step = 1e-3;
double v;
double r2b, r2a;
cxyz = mincaps[i].xyz;
healpix_to_xyzarr(i, nside, 0.5, 0.5, mincaps[i].xyz);
memcpy(maxcaps[i].xyz, cxyz, 3 * sizeof(double));
logverb("Center of HP %i: (%.3f, %.3f, %.3f)\n", i, cxyz[0], cxyz[1], cxyz[2]);
// radius-squared:
// max is the easy one: max of the four corners (I assume)
r2 = 0.0;
healpix_to_xyzarr(i, nside, 0.0, 0.0, xyz);
logverb(" HP %i corner 1: (%.3f, %.3f, %.3f), distsq %.3f\n", i, xyz[0], xyz[1], xyz[2], distsq(xyz, cxyz, 3));
r2 = MAX(r2, distsq(xyz, cxyz, 3));
healpix_to_xyzarr(i, nside, 1.0, 0.0, xyz);
logverb(" HP %i corner 1: (%.3f, %.3f, %.3f), distsq %.3f\n", i, xyz[0], xyz[1], xyz[2], distsq(xyz, cxyz, 3));
r2 = MAX(r2, distsq(xyz, cxyz, 3));
healpix_to_xyzarr(i, nside, 0.0, 1.0, xyz);
logverb(" HP %i corner 1: (%.3f, %.3f, %.3f), distsq %.3f\n", i, xyz[0], xyz[1], xyz[2], distsq(xyz, cxyz, 3));
r2 = MAX(r2, distsq(xyz, cxyz, 3));
healpix_to_xyzarr(i, nside, 1.0, 1.0, xyz);
logverb(" HP %i corner 1: (%.3f, %.3f, %.3f), distsq %.3f\n", i, xyz[0], xyz[1], xyz[2], distsq(xyz, cxyz, 3));
r2 = MAX(r2, distsq(xyz, cxyz, 3));
logverb(" max distsq: %.3f\n", r2);
logverb(" margin dist: %.3f\n", md);
maxcaps[i].r2 = square(sqrt(r2) + md);
logverb(" max cap distsq: %.3f\n", maxcaps[i].r2);
r2a = r2;
r2 = 1.0;
r2b = 0.0;
for (v=0; v<=1.0; v+=step) {
healpix_to_xyzarr(i, nside, 0.0, v, xyz);
r2 = MIN(r2, distsq(xyz, cxyz, 3));
r2b = MAX(r2b, distsq(xyz, cxyz, 3));
healpix_to_xyzarr(i, nside, 1.0, v, xyz);
r2 = MIN(r2, distsq(xyz, cxyz, 3));
r2b = MAX(r2b, distsq(xyz, cxyz, 3));
healpix_to_xyzarr(i, nside, v, 0.0, xyz);
r2 = MIN(r2, distsq(xyz, cxyz, 3));
r2b = MAX(r2b, distsq(xyz, cxyz, 3));
healpix_to_xyzarr(i, nside, v, 1.0, xyz);
r2 = MIN(r2, distsq(xyz, cxyz, 3));
r2b = MAX(r2b, distsq(xyz, cxyz, 3));
}
mincaps[i].r2 = square(MAX(0, sqrt(r2) - md));
logverb("\nhealpix %i: min rad %g\n", i, sqrt(r2));
logverb("healpix %i: max rad %g\n", i, sqrt(r2a));
logverb("healpix %i: max rad(b) %g\n", i, sqrt(r2b));
assert(r2a >= r2b);
}
if (backref) {
fitstable_t* tab = fitstable_open_for_writing(backref);
int maxlen = 0;
char* buf;
for (i=0; i<sl_size(infns); i++) {
char* infn = sl_get(infns, i);
maxlen = MAX(maxlen, strlen(infn));
}
fitstable_add_write_column_array(tab, fitscolumn_char_type(), maxlen,
"filename", NULL);
fitstable_add_write_column(tab, fitscolumn_i16_type(), "index", NULL);
if (fitstable_write_primary_header(tab) ||
fitstable_write_header(tab)) {
ERROR("Failed to write header of backref table \"%s\"", backref);
exit(-1);
}
buf = malloc(maxlen+1);
assert(buf);
for (i=0; i<sl_size(infns); i++) {
char* infn = sl_get(infns, i);
int16_t ind;
memset(buf, 0, maxlen);
strcpy(buf, infn);
ind = i;
if (fitstable_write_row(tab, buf, &ind)) {
ERROR("Failed to write row %i of backref table: %s = %i",
i, buf, ind);
exit(-1);
}
}
if (fitstable_fix_header(tab) ||
fitstable_close(tab)) {
ERROR("Failed to fix header & close backref table");
exit(-1);
}
logmsg("Wrote backref table %s\n", backref);
free(buf);
}
for (i=0; i<sl_size(infns); i++) {
char* infn = sl_get(infns, i);
char* originfn = infn;
int r, NR;
tfits_type any, dubl;
il* hps = NULL;
bread_t* rowbuf;
int R;
char* tempfn = NULL;
char* padrowdata = NULL;
int ii;
logmsg("Reading input \"%s\"...\n", infn);
if (gzip) {
char* cmd;
int rtn;
tempfn = create_temp_file("hpsplit", tempdir);
asprintf_safe(&cmd, "gunzip -cd %s > %s", infn, tempfn);
logmsg("Running: \"%s\"\n", cmd);
rtn = run_command_get_outputs(cmd, NULL, NULL);
if (rtn) {
ERROR("Failed to run command: \"%s\"", cmd);
exit(-1);
}
free(cmd);
infn = tempfn;
}
intable = fitstable_open(infn);
if (!intable) {
ERROR("Couldn't read catalog %s", infn);
exit(-1);
}
NR = fitstable_nrows(intable);
logmsg("Got %i rows\n", NR);
any = fitscolumn_any_type();
dubl = fitscolumn_double_type();
fitstable_add_read_column_struct(intable, dubl, 1, 0, any, racol, TRUE);
fitstable_add_read_column_struct(intable, dubl, 1, sizeof(double), any, deccol, TRUE);
fitstable_use_buffered_reading(intable, 2*sizeof(double), 1000);
R = fitstable_row_size(intable);
rowbuf = buffered_read_new(R, 1000, NR, refill_rowbuffer, intable);
if (fitstable_read_extension(intable, 1)) {
ERROR("Failed to find RA and DEC columns (called \"%s\" and \"%s\" in the FITS file)", racol, deccol);
exit(-1);
}
for (r=0; r<NR; r++) {
int hp = -1;
double ra, dec;
int j;
double* rd;
void* rowdata;
void* rdata;
if (r && ((r % 100000) == 0)) {
logmsg("Reading row %i of %i\n", r, NR);
}
//printf("reading RA,Dec for row %i\n", r);
rd = fitstable_next_struct(intable);
ra = rd[0];
dec = rd[1];
logverb("row %i: ra,dec %g,%g\n", r, ra, dec);
if (margin == 0) {
hp = radecdegtohealpix(ra, dec, nside);
logverb(" --> healpix %i\n", hp);
} else {
double xyz[3];
anbool gotit = FALSE;
double d2;
if (!hps)
hps = il_new(4);
radecdeg2xyzarr(ra, dec, xyz);
for (j=0; j<NHP; j++) {
d2 = distsq(xyz, mincaps[j].xyz, 3);
if (d2 <= mincaps[j].r2) {
logverb(" -> in mincap %i (dist %g vs %g)\n", j, sqrt(d2), sqrt(mincaps[j].r2));
il_append(hps, j);
gotit = TRUE;
break;
}
}
if (!gotit) {
for (j=0; j<NHP; j++) {
d2 = distsq(xyz, maxcaps[j].xyz, 3);
if (d2 <= maxcaps[j].r2) {
logverb(" -> in maxcap %i (dist %g vs %g)\n", j, sqrt(d2), sqrt(maxcaps[j].r2));
if (healpix_within_range_of_xyz(j, nside, xyz, margin)) {
logverb(" -> and within range.\n");
il_append(hps, j);
}
}
}
}
//hps = healpix_rangesearch_radec(ra, dec, margin, nside, hps);
logverb(" --> healpixes: [");
for (j=0; j<il_size(hps); j++)
logverb(" %i", il_get(hps, j));
logverb(" ]\n");
}
//printf("Reading rowdata for row %i\n", r);
rowdata = buffered_read(rowbuf);
assert(rowdata);
j=0;
while (1) {
if (hps) {
if (j >= il_size(hps))
break;
hp = il_get(hps, j);
j++;
}
assert(hp < NHP);
assert(hp >= 0);
if (!outtables[hp]) {
char* outfn;
fitstable_t* out;
// MEMLEAK the output filename. You'll live.
asprintf_safe(&outfn, outfnpat, hp);
logmsg("Opening output file \"%s\"...\n", outfn);
out = fitstable_open_for_writing(outfn);
if (!out) {
ERROR("Failed to open output table \"%s\"", outfn);
exit(-1);
}
// Set the output table structure.
if (cols) {
fitstable_add_fits_columns_as_struct3(intable, out, cols, 0);
} else
fitstable_add_fits_columns_as_struct2(intable, out);
if (backref) {
tfits_type i16type;
tfits_type i32type;
// R = fitstable_row_size(intable);
int off = R;
i16type = fitscolumn_i16_type();
i32type = fitscolumn_i32_type();
fitstable_add_read_column_struct(out, i16type, 1, off,
i16type, "backref_file", TRUE);
off += sizeof(int16_t);
fitstable_add_read_column_struct(out, i32type, 1, off,
i32type, "backref_index", TRUE);
}
//printf("Output table:\n");
//fitstable_print_columns(out);
if (fitstable_write_primary_header(out) ||
fitstable_write_header(out)) {
ERROR("Failed to write output file headers for \"%s\"", outfn);
exit(-1);
}
outtables[hp] = out;
}
if (backref) {
int16_t brfile;
int32_t brind;
if (!padrowdata) {
padrowdata = malloc(R + sizeof(int16_t) + sizeof(int32_t));
assert(padrowdata);
}
// convert to FITS endian
brfile = htons(i);
brind = htonl(r);
// add backref data to rowdata
memcpy(padrowdata, rowdata, R);
memcpy(padrowdata + R, &brfile, sizeof(int16_t));
memcpy(padrowdata + R + sizeof(int16_t), &brind, sizeof(int32_t));
rdata = padrowdata;
} else {
rdata = rowdata;
}
if (cols) {
if (fitstable_write_struct_noflip(outtables[hp], rdata)) {
ERROR("Failed to copy a row of data from input table \"%s\" to output healpix %i", infn, hp);
}
} else {
if (fitstable_write_row_data(outtables[hp], rdata)) {
ERROR("Failed to copy a row of data from input table \"%s\" to output healpix %i", infn, hp);
}
}
if (!hps)
break;
}
if (hps)
il_remove_all(hps);
}
buffered_read_free(rowbuf);
// wack... buffered_read_free() just frees its internal buffer,
// not the "rowbuf" struct itself.
// who wrote this crazy code? Oh, me of 5 years ago. Jerk.
free(rowbuf);
fitstable_close(intable);
il_free(hps);
if (tempfn) {
logverb("Removing temp file %s\n", tempfn);
if (unlink(tempfn)) {
SYSERROR("Failed to unlink() temp file \"%s\"", tempfn);
}
tempfn = NULL;
}
// fix headers so that the files are valid at this point.
for (ii=0; ii<NHP; ii++) {
if (!outtables[ii])
continue;
off_t offset = ftello(outtables[ii]->fid);
if (fitstable_fix_header(outtables[ii])) {
ERROR("Failed to fix header for healpix %i after reading input file \"%s\"", ii, originfn);
exit(-1);
}
fseeko(outtables[ii]->fid, offset, SEEK_SET);
}
if (padrowdata) {
free(padrowdata);
padrowdata = NULL;
}
}
for (i=0; i<NHP; i++) {
if (!outtables[i])
continue;
if (fitstable_fix_header(outtables[i]) ||
fitstable_fix_primary_header(outtables[i]) ||
fitstable_close(outtables[i])) {
ERROR("Failed to close output table for healpix %i", i);
exit(-1);
}
}
free(outtables);
sl_free2(infns);
sl_free2(cols);
free(mincaps);
free(maxcaps);
return 0;
}
int main(int argc, char **argv) {
int argchar;
double ra=HUGE_VAL, dec=HUGE_VAL, radius=HUGE_VAL;
int loglvl = LOG_MSG;
char** myargs;
int nmyargs;
int i;
char* outfn = NULL;
fitstable_t* table = NULL;
while ((argchar = getopt (argc, argv, OPTIONS)) != -1)
switch (argchar) {
case 'o':
outfn = optarg;
break;
case 'r':
ra = atof(optarg);
break;
case 'd':
dec = atof(optarg);
break;
case 'R':
radius = atof(optarg);
break;
case 'v':
loglvl++;
break;
case '?':
fprintf(stderr, "Unknown option `-%c'.\n", optopt);
case 'h':
default:
printHelp(argv[0]);
return -1;
}
log_init(loglvl);
nmyargs = argc - optind;
myargs = argv + optind;
if (nmyargs < 1) {
printHelp(argv[0]);
exit(-1);
}
if (ra == HUGE_VAL || dec == HUGE_VAL || radius == HUGE_VAL) {
printHelp(argv[0]);
exit(-1);
}
if (outfn) {
table = fitstable_open_for_writing(outfn);
if (!table) {
ERROR("Failed to open output table");
exit(-1);
}
if (fitstable_write_primary_header(table)) {
ERROR("Failed to write primary header of output table");
exit(-1);
}
}
for (i=0; i<nmyargs; i++) {
char* indexfn = myargs[i];
index_t index;
sl* cols;
int* inds;
double* radecs;
int N;
int j;
fitstable_t* tagtable = NULL;
logmsg("Reading index \"%s\"...\n", indexfn);
if (!index_load(indexfn, 0, &index)) {
ERROR("Failed to read index \"%s\"", indexfn);
continue;
}
logmsg("Index %s: id %i, healpix %i (nside %i), %i stars, %i quads, dimquads=%i, scales %g to %g arcmin.\n",
index.indexname, index.indexid, index.healpix, index.hpnside,
index.nstars, index.nquads, index.dimquads,
arcsec2arcmin(index.index_scale_lower),
arcsec2arcmin(index.index_scale_upper));
cols = startree_get_tagalong_column_names(index.starkd, NULL);
{
char* colstr = sl_join(cols, ", ");
logmsg("Tag-along columns: %s\n", colstr);
free(colstr);
}
logmsg("Searching for stars around RA,Dec (%g, %g), radius %g deg.\n",
ra, dec, radius);
startree_search_for_radec(index.starkd, ra, dec, radius,
NULL, &radecs, &inds, &N);
logmsg("Found %i stars\n", N);
if (table) {
int tagsize;
int rowsize;
char* rowbuf = NULL;
if (i > 0) {
fitstable_next_extension(table);
fitstable_clear_table(table);
}
tagtable = startree_get_tagalong(index.starkd);
if (tagtable) {
fitstable_add_fits_columns_as_struct(tagtable);
logverb("Input tag-along table:\n");
if (log_get_level() >= LOG_VERB)
fitstable_print_columns(tagtable);
fitstable_copy_columns(tagtable, table);
}
tagsize = fitstable_get_struct_size(table);
debug("tagsize=%i\n", tagsize);
// Add RA,Dec at the end of the row...
fitstable_add_write_column_struct(table, fitscolumn_double_type(), 1, tagsize, fitscolumn_double_type(), "RA", "degrees");
fitstable_add_write_column_struct(table, fitscolumn_double_type(), 1, tagsize + sizeof(double), fitscolumn_double_type(), "DEC", "degrees");
rowsize = fitstable_get_struct_size(table);
assert(rowsize == tagsize + 2*sizeof(double));
debug("rowsize=%i\n", rowsize);
rowbuf = malloc(rowsize);
logverb("Output table:\n");
if (log_get_level() >= LOG_VERB)
fitstable_print_columns(table);
if (fitstable_write_header(table)) {
ERROR("Failed to write header of output table");
exit(-1);
}
for (j=0; j<N; j++) {
if (tagtable) {
if (fitstable_read_struct(tagtable, inds[j], rowbuf)) {
ERROR("Failed to read row %i of tag-along table", inds[j]);
exit(-1);
}
}
// Add RA,Dec to end of struct...
memcpy(rowbuf + tagsize, radecs+2*j+0, sizeof(double));
memcpy(rowbuf + tagsize + sizeof(double), radecs+2*j+1, sizeof(double));
if (fitstable_write_struct(table, rowbuf)) {
ERROR("Failed to write row %i of output", j);
exit(-1);
}
}
free(rowbuf);
if (fitstable_fix_header(table)) {
ERROR("Failed to fix header of output table");
exit(-1);
}
}
sl_free2(cols);
free(radecs);
free(inds);
index_close(&index);
}
if (table) {
if (fitstable_close(table)) {
ERROR("Failed to close output table");
exit(-1);
}
}
return 0;
}
static int plot_index_overlay(augment_xylist_t* axy, const char* me,
const char* indxylsfn, const char* redgreenfn,
double plotscale, const char* bgfn) {
sl* cmdline = sl_new(16);
char* cmd;
matchfile* mf;
MatchObj* mo;
int i;
anbool ctrlc;
char* imgfn;
assert(axy->matchfn);
mf = matchfile_open(axy->matchfn);
if (!mf) {
ERROR("Failed to read matchfile %s", axy->matchfn);
return -1;
}
// just read the first match...
mo = matchfile_read_match(mf);
if (!mo) {
ERROR("Failed to read a match from matchfile %s", axy->matchfn);
return -1;
}
// sources + index overlay
imgfn = axy->pnmfn;
if (bgfn) {
append_executable(cmdline, "jpegtopnm", me);
append_escape(cmdline, bgfn);
sl_append(cmdline, "|");
imgfn = "-";
} else {
if (axy->imagefn && plotscale != 1.0) {
append_executable(cmdline, "pnmscale", me);
sl_appendf(cmdline, "%f", plotscale);
append_escape(cmdline, axy->pnmfn);
sl_append(cmdline, "|");
imgfn = "-";
}
}
append_executable(cmdline, "plotxy", me);
if (imgfn) {
sl_append(cmdline, "-I");
append_escape(cmdline, imgfn);
} else {
sl_appendf(cmdline, "-W %i -H %i", (int)(plotscale * axy->W), (int)(plotscale * axy->H));
}
sl_append(cmdline, "-i");
append_escape(cmdline, axy->axyfn);
if (axy->xcol) {
sl_append(cmdline, "-X");
append_escape(cmdline, axy->xcol);
}
if (axy->ycol) {
sl_append(cmdline, "-Y");
append_escape(cmdline, axy->ycol);
}
if (plotscale != 1.0) {
sl_append(cmdline, "-S");
sl_appendf(cmdline, "%f", plotscale);
}
sl_append(cmdline, "-C red -w 2 -r 6 -N 200 -x 1 -y 1");
sl_append(cmdline, "-P");
sl_append(cmdline, "|");
append_executable(cmdline, "plotxy", me);
sl_append(cmdline, "-i");
append_escape(cmdline, indxylsfn);
sl_append(cmdline, "-I - -w 2 -r 4 -C green -x 1 -y 1");
if (plotscale != 1.0) {
sl_append(cmdline, "-S");
sl_appendf(cmdline, "%f", plotscale);
}
// if we solved by verifying an existing WCS, there is no quad.
if (mo->dimquads) {
sl_append(cmdline, " -P |");
append_executable(cmdline, "plotquad", me);
sl_append(cmdline, "-I -");
sl_append(cmdline, "-C green");
sl_append(cmdline, "-w 2");
sl_appendf(cmdline, "-d %i", mo->dimquads);
if (plotscale != 1.0) {
sl_append(cmdline, "-s");
sl_appendf(cmdline, "%f", plotscale);
}
for (i=0; i<(2 * mo->dimquads); i++)
sl_appendf(cmdline, " %g", mo->quadpix[i]);
}
matchfile_close(mf);
sl_append(cmdline, ">");
append_escape(cmdline, redgreenfn);
cmd = sl_implode(cmdline, " ");
sl_free2(cmdline);
logverb("Running:\n %s\n", cmd);
if (run_command(cmd, &ctrlc)) {
ERROR("Plotting commands %s; exiting.", (ctrlc ? "were cancelled" : "failed"));
return -1;
}
free(cmd);
return 0;
}
int main(int argc, char** args) {
int c;
anbool help = FALSE;
char* outdir = NULL;
char* cmd;
int i, j, f;
int inputnum;
int rtn;
sl* engineargs;
int nbeargs;
anbool fromstdin = FALSE;
anbool overwrite = FALSE;
anbool cont = FALSE;
anbool skip_solved = FALSE;
anbool makeplots = TRUE;
double plotscale = 1.0;
char* inbgfn = NULL;
char* bgfn = NULL;
char* me;
anbool verbose = FALSE;
int loglvl = LOG_MSG;
char* outbase = NULL;
anbool usecurl = TRUE;
bl* opts;
augment_xylist_t theallaxy;
augment_xylist_t* allaxy = &theallaxy;
int nmyopts;
char* removeopts = "ixo\x01";
char* newfits;
char* kmz = NULL;
char* scamp = NULL;
char* scampconfig = NULL;
char* index_xyls;
anbool just_augment = FALSE;
anbool engine_batch = FALSE;
bl* batchaxy = NULL;
bl* batchsf = NULL;
sl* outfiles;
sl* tempfiles;
// these are deleted after the outer loop over input files
sl* tempfiles2;
sl* tempdirs;
anbool timestamp = FALSE;
anbool tempaxy = FALSE;
errors_print_on_exit(stderr);
fits_use_error_system();
me = find_executable(args[0], NULL);
engineargs = sl_new(16);
append_executable(engineargs, "astrometry-engine", me);
// output filenames.
outfiles = sl_new(16);
tempfiles = sl_new(4);
tempfiles2 = sl_new(4);
tempdirs = sl_new(4);
rtn = 0;
nmyopts = sizeof(options)/sizeof(an_option_t);
opts = opts_from_array(options, nmyopts, NULL);
augment_xylist_add_options(opts);
// remove duplicate short options.
for (i=0; i<nmyopts; i++) {
an_option_t* opt1 = bl_access(opts, i);
for (j=nmyopts; j<bl_size(opts); j++) {
an_option_t* opt2 = bl_access(opts, j);
if (opt2->shortopt == opt1->shortopt)
bl_remove_index(opts, j);
}
}
// remove unwanted augment-xylist options.
for (i=0; i<strlen(removeopts); i++) {
for (j=nmyopts; j<bl_size(opts); j++) {
an_option_t* opt2 = bl_access(opts, j);
if (opt2->shortopt == removeopts[i])
bl_remove_index(opts, j);
}
}
// which options are left?
/*{
char options[256];
memset(options, 0, 256);
printf("options:\n");
for (i=0; i<bl_size(opts); i++) {
an_option_t* opt = bl_access(opts, i);
printf(" %c (%i) %s\n", opt->shortopt, (int)opt->shortopt, opt->name);
options[(int)((opt->shortopt + 256) % 256)] = 1;
}
printf("Remaining short opts:\n");
for (i=0; i<256; i++) {
if (!options[i])
printf(" %c (%i, 0x%x)\n", (char)i, i, i);
}
}*/
augment_xylist_init(allaxy);
// default output filename patterns.
allaxy->axyfn = "%s.axy";
allaxy->matchfn = "%s.match";
allaxy->rdlsfn = "%s.rdls";
allaxy->solvedfn = "%s.solved";
allaxy->wcsfn = "%s.wcs";
allaxy->corrfn = "%s.corr";
newfits = "%s.new";
index_xyls = "%s-indx.xyls";
while (1) {
int res;
c = opts_getopt(opts, argc, args);
//printf("option %c (%i)\n", c, (int)c);
if (c == -1)
break;
switch (c) {
case '\x91':
allaxy->axyfn = optarg;
break;
case '\x90':
tempaxy = TRUE;
break;
case '\x88':
timestamp = TRUE;
break;
case '\x84':
plotscale = atof(optarg);
break;
case '\x85':
inbgfn = optarg;
break;
case '\x87':
allaxy->assume_fits_image = TRUE;
break;
case '(':
engine_batch = TRUE;
break;
case '@':
just_augment = TRUE;
break;
case 'U':
index_xyls = optarg;
break;
case 'n':
scampconfig = optarg;
break;
case 'i':
scamp = optarg;
break;
case 'Z':
kmz = optarg;
break;
case 'N':
newfits = optarg;
break;
case 'h':
help = TRUE;
break;
case 'v':
sl_append(engineargs, "--verbose");
verbose = TRUE;
allaxy->verbosity++;
loglvl++;
break;
case 'D':
outdir = optarg;
break;
case 'o':
outbase = optarg;
break;
case 'b':
case '\x89':
sl_append(engineargs, "--config");
append_escape(engineargs, optarg);
break;
case 'f':
fromstdin = TRUE;
break;
case 'O':
overwrite = TRUE;
break;
case 'p':
makeplots = FALSE;
break;
case 'G':
usecurl = FALSE;
break;
case 'K':
cont = TRUE;
break;
case 'J':
skip_solved = TRUE;
break;
default:
res = augment_xylist_parse_option(c, optarg, allaxy);
if (res) {
rtn = -1;
goto dohelp;
}
}
}
if ((optind == argc) && !fromstdin) {
printf("ERROR: You didn't specify any files to process.\n");
help = TRUE;
}
if (help) {
dohelp:
print_help(args[0], opts);
exit(rtn);
}
bl_free(opts);
// --dont-augment: advertised as just write xy file,
// so quit after doing that.
if (allaxy->dont_augment) {
just_augment = TRUE;
}
log_init(loglvl);
if (timestamp)
log_set_timestamp(TRUE);
if (kmz && starts_with(kmz, "-"))
logmsg("Do you really want to save KMZ to the file named \"%s\" ??\n", kmz);
if (starts_with(newfits, "-")) {
logmsg("Do you really want to save the new FITS file to the file named \"%s\" ??\n", newfits);
}
if (engine_batch) {
batchaxy = bl_new(16, sizeof(augment_xylist_t));
batchsf = bl_new(16, sizeof(solve_field_args_t));
}
// Allow (some of the) default filenames to be disabled by setting them to "none".
allaxy->matchfn = none_is_null(allaxy->matchfn);
allaxy->rdlsfn = none_is_null(allaxy->rdlsfn);
allaxy->solvedfn = none_is_null(allaxy->solvedfn);
allaxy->solvedinfn = none_is_null(allaxy->solvedinfn);
allaxy->wcsfn = none_is_null(allaxy->wcsfn);
allaxy->corrfn = none_is_null(allaxy->corrfn);
newfits = none_is_null(newfits);
index_xyls = none_is_null(index_xyls);
if (outdir) {
if (mkdir_p(outdir)) {
ERROR("Failed to create output directory %s", outdir);
exit(-1);
}
}
// number of engine args not specific to a particular file
nbeargs = sl_size(engineargs);
f = optind;
inputnum = 0;
while (1) {
char* infile = NULL;
anbool isxyls;
char* reason;
int len;
char* base;
char* basedir;
char* basefile = NULL;
char *objsfn=NULL;
char *ppmfn=NULL;
char* downloadfn = NULL;
char* suffix = NULL;
sl* cmdline;
anbool ctrlc;
anbool isurl;
augment_xylist_t theaxy;
augment_xylist_t* axy = &theaxy;
int j;
solve_field_args_t thesf;
solve_field_args_t* sf = &thesf;
anbool want_pnm = FALSE;
// reset augment-xylist args.
memcpy(axy, allaxy, sizeof(augment_xylist_t));
memset(sf, 0, sizeof(solve_field_args_t));
if (fromstdin) {
char fnbuf[1024];
if (!fgets(fnbuf, sizeof(fnbuf), stdin)) {
if (ferror(stdin))
SYSERROR("Failed to read a filename from stdin");
break;
}
len = strlen(fnbuf);
if (fnbuf[len-1] == '\n')
fnbuf[len-1] = '\0';
infile = fnbuf;
logmsg("Reading input file \"%s\"...\n", infile);
} else {
if (f == argc)
break;
infile = args[f];
f++;
logmsg("Reading input file %i of %i: \"%s\"...\n",
f - optind, argc - optind, infile);
}
inputnum++;
cmdline = sl_new(16);
if (!engine_batch) {
// Remove arguments that might have been added in previous trips through this loop
sl_remove_from(engineargs, nbeargs);
}
// Choose the base path/filename for output files.
if (outbase)
asprintf_safe(&basefile, outbase, inputnum, infile);
else
basefile = basename_safe(infile);
//logverb("Base filename: %s\n", basefile);
isurl = (!file_exists(infile) &&
(starts_with(infile, "http://") ||
starts_with(infile, "ftp://")));
if (outdir)
basedir = strdup(outdir);
else {
if (isurl)
basedir = strdup(".");
else
basedir = dirname_safe(infile);
}
//logverb("Base directory: %s\n", basedir);
asprintf_safe(&base, "%s/%s", basedir, basefile);
//logverb("Base name for output files: %s\n", base);
// trim .gz, .bz2
// hmm, we drop the suffix in this case...
len = strlen(base);
if (ends_with(base, ".gz"))
base[len-3] = '\0';
else if (ends_with(base, ".bz2"))
base[len-4] = '\0';
len = strlen(base);
// trim .xx / .xxx / .xxxx
if (len >= 5) {
for (j=3; j<=5; j++) {
if (base[len - j] == '/')
break;
if (base[len - j] == '.') {
base[len - j] = '\0';
suffix = base + len - j + 1;
break;
}
}
}
logverb("Base: \"%s\", basefile \"%s\", basedir \"%s\", suffix \"%s\"\n", base, basefile, basedir, suffix);
if (tempaxy) {
axy->axyfn = create_temp_file("axy", axy->tempdir);
sl_append_nocopy(tempfiles2, axy->axyfn);
} else
axy->axyfn = sl_appendf(outfiles, axy->axyfn, base);
if (axy->matchfn)
axy->matchfn = sl_appendf(outfiles, axy->matchfn, base);
if (axy->rdlsfn)
axy->rdlsfn = sl_appendf(outfiles, axy->rdlsfn, base);
if (axy->solvedfn)
axy->solvedfn = sl_appendf(outfiles, axy->solvedfn, base);
if (axy->wcsfn)
axy->wcsfn = sl_appendf(outfiles, axy->wcsfn, base);
if (axy->corrfn)
axy->corrfn = sl_appendf(outfiles, axy->corrfn, base);
if (axy->cancelfn)
axy->cancelfn = sl_appendf(outfiles, axy->cancelfn, base);
if (axy->keepxylsfn)
axy->keepxylsfn = sl_appendf(outfiles, axy->keepxylsfn, base);
if (axy->pnmfn)
axy->pnmfn = sl_appendf(outfiles, axy->pnmfn, base);
if (newfits)
sf->newfitsfn = sl_appendf(outfiles, newfits, base);
if (kmz)
sf->kmzfn = sl_appendf(outfiles, kmz, base);
if (index_xyls)
sf->indxylsfn = sl_appendf(outfiles, index_xyls, base);
if (scamp)
sf->scampfn = sl_appendf(outfiles, scamp, base);
if (scampconfig)
sf->scampconfigfn = sl_appendf(outfiles, scampconfig, base);
if (makeplots) {
objsfn = sl_appendf(outfiles, "%s-objs.png", base);
sf->redgreenfn = sl_appendf(outfiles, "%s-indx.png", base);
sf->ngcfn = sl_appendf(outfiles, "%s-ngc.png", base);
}
if (isurl) {
if (suffix)
downloadfn = sl_appendf(outfiles, "%s.%s", base, suffix);
else
downloadfn = sl_appendf(outfiles, "%s", base);
}
if (axy->solvedinfn)
asprintf_safe(&axy->solvedinfn, axy->solvedinfn, base);
// Do %s replacement on --verify-wcs entries...
if (sl_size(axy->verifywcs)) {
sl* newlist = sl_new(4);
for (j=0; j<sl_size(axy->verifywcs); j++)
sl_appendf(newlist, sl_get(axy->verifywcs, j), base);
axy->verifywcs = newlist;
}
// ... and plot-bg
if (inbgfn)
asprintf_safe(&bgfn, inbgfn, base);
if (axy->solvedinfn && axy->solvedfn && streq(axy->solvedfn, axy->solvedinfn)) {
// solved input and output files are the same: don't delete the input!
sl_remove_string(outfiles, axy->solvedfn);
free(axy->solvedfn);
axy->solvedfn = axy->solvedinfn;
}
free(basedir);
free(basefile);
if (skip_solved) {
char* tocheck[] = { axy->solvedinfn, axy->solvedfn };
for (j=0; j<sizeof(tocheck)/sizeof(char*); j++) {
if (!tocheck[j])
continue;
logverb("Checking for solved file %s\n", tocheck[j]);
if (file_exists(tocheck[j])) {
logmsg("Solved file exists: %s; skipping this input file.\n", tocheck[j]);
goto nextfile;
} else {
logverb("File \"%s\" does not exist.\n", tocheck[j]);
}
}
}
// Check for overlap between input and output filenames
for (i = 0; i < sl_size(outfiles); i++) {
char* fn = sl_get(outfiles, i);
if (streq(fn, infile)) {
logmsg("Output filename \"%s\" is the same as your input file.\n"
"Refusing to continue.\n"
"You can either choose a different output filename, or\n"
"rename your input file to have a different extension.\n", fn);
goto nextfile;
}
}
// Check for (and possibly delete) existing output filenames.
for (i = 0; i < sl_size(outfiles); i++) {
char* fn = sl_get(outfiles, i);
if (!file_exists(fn))
continue;
if (cont) {
} else if (overwrite) {
if (unlink(fn)) {
SYSERROR("Failed to delete an already-existing output file \"%s\"", fn);
exit(-1);
}
} else {
logmsg("Output file already exists: \"%s\".\n"
"Use the --overwrite flag to overwrite existing files,\n"
" or the --continue flag to not overwrite existing files but still try solving.\n", fn);
logmsg("Continuing to next input file.\n");
goto nextfile;
}
}
// if we're making "redgreen" plot, we need:
if (sf->redgreenfn) {
// -- index xylist
if (!sf->indxylsfn) {
sf->indxylsfn = create_temp_file("indxyls", axy->tempdir);
sl_append_nocopy(tempfiles, sf->indxylsfn);
}
// -- match file.
if (!axy->matchfn) {
axy->matchfn = create_temp_file("match", axy->tempdir);
sl_append_nocopy(tempfiles, axy->matchfn);
}
}
// if index xyls file is needed, we need:
if (sf->indxylsfn) {
// -- wcs
if (!axy->wcsfn) {
axy->wcsfn = create_temp_file("wcs", axy->tempdir);
sl_append_nocopy(tempfiles, axy->wcsfn);
}
// -- rdls
if (!axy->rdlsfn) {
axy->rdlsfn = create_temp_file("rdls", axy->tempdir);
sl_append_nocopy(tempfiles, axy->rdlsfn);
}
}
// Download URL...
if (isurl) {
sl_append(cmdline, usecurl ? "curl" : "wget");
if (!verbose)
sl_append(cmdline, usecurl ? "--silent" : "--quiet");
sl_append(cmdline, usecurl ? "--output" : "-O");
append_escape(cmdline, downloadfn);
append_escape(cmdline, infile);
cmd = sl_implode(cmdline, " ");
logmsg("Downloading...\n");
if (run_command(cmd, &ctrlc)) {
ERROR("%s command %s", sl_get(cmdline, 0),
(ctrlc ? "was cancelled" : "failed"));
exit(-1);
}
sl_remove_all(cmdline);
free(cmd);
infile = downloadfn;
}
if (makeplots)
want_pnm = TRUE;
if (axy->assume_fits_image) {
axy->imagefn = infile;
if (axy->pnmfn)
want_pnm = TRUE;
} else {
logverb("Checking if file \"%s\" ext %i is xylist or image: ",
infile, axy->extension);
fflush(NULL);
reason = NULL;
isxyls = xylist_is_file_xylist(infile, axy->extension,
axy->xcol, axy->ycol, &reason);
logverb(isxyls ? "xyls\n" : "image\n");
if (!isxyls)
logverb(" (not xyls because: %s)\n", reason);
free(reason);
fflush(NULL);
if (isxyls)
axy->xylsfn = infile;
else {
axy->imagefn = infile;
want_pnm = TRUE;
}
}
if (want_pnm && !axy->pnmfn) {
ppmfn = create_temp_file("ppm", axy->tempdir);
sl_append_nocopy(tempfiles, ppmfn);
axy->pnmfn = ppmfn;
axy->force_ppm = TRUE;
}
axy->keep_fitsimg = (newfits || scamp);
if (augment_xylist(axy, me)) {
ERROR("augment-xylist failed");
exit(-1);
}
if (just_augment)
goto nextfile;
if (makeplots) {
// Check that the plotting executables were built...
char* exec = find_executable("plotxy", me);
free(exec);
if (!exec) {
logmsg("Couldn't find \"plotxy\" executable - maybe you didn't build the plotting programs?\n");
logmsg("Disabling plots.\n");
makeplots = FALSE;
}
}
if (makeplots) {
// source extraction overlay
if (plot_source_overlay(axy, me, objsfn, plotscale, bgfn))
makeplots = FALSE;
}
append_escape(engineargs, axy->axyfn);
if (file_readable(axy->wcsfn))
axy->wcs_last_mod = file_get_last_modified_time(axy->wcsfn);
else
axy->wcs_last_mod = 0;
if (!engine_batch) {
run_engine(engineargs);
after_solved(axy, sf, makeplots, me, verbose,
axy->tempdir, tempdirs, tempfiles, plotscale, bgfn);
} else {
bl_append(batchaxy, axy);
bl_append(batchsf, sf );
}
fflush(NULL);
// clean up and move on to the next file.
nextfile:
free(base);
sl_free2(cmdline);
if (!engine_batch) {
free(axy->fitsimgfn);
free(axy->solvedinfn);
free(bgfn);
// erm.
if (axy->verifywcs != allaxy->verifywcs)
sl_free2(axy->verifywcs);
sl_remove_all(outfiles);
if (!axy->no_delete_temp)
delete_temp_files(tempfiles, tempdirs);
}
errors_print_stack(stdout);
errors_clear_stack();
logmsg("\n");
}
if (engine_batch) {
run_engine(engineargs);
for (i=0; i<bl_size(batchaxy); i++) {
augment_xylist_t* axy = bl_access(batchaxy, i);
solve_field_args_t* sf = bl_access(batchsf, i);
after_solved(axy, sf, makeplots, me, verbose,
axy->tempdir, tempdirs, tempfiles, plotscale, bgfn);
errors_print_stack(stdout);
errors_clear_stack();
logmsg("\n");
free(axy->fitsimgfn);
free(axy->solvedinfn);
// erm.
if (axy->verifywcs != allaxy->verifywcs)
sl_free2(axy->verifywcs);
}
if (!allaxy->no_delete_temp)
delete_temp_files(tempfiles, tempdirs);
bl_free(batchaxy);
bl_free(batchsf);
}
if (!allaxy->no_delete_temp)
delete_temp_files(tempfiles2, NULL);
sl_free2(outfiles);
sl_free2(tempfiles);
sl_free2(tempfiles2);
sl_free2(tempdirs);
sl_free2(engineargs);
free(me);
augment_xylist_free_contents(allaxy);
return 0;
}
int wcs_pv2sip(const char* wcsinfn, int ext,
const char* wcsoutfn,
anbool scamp_head_file,
double* xy, int Nxy,
int imageW, int imageH,
anbool forcetan) {
qfits_header* hdr = NULL;
double* radec = NULL;
int rtn = -1;
tan_t tanwcs;
double x,y, px,py;
double xyz[3];
double* xorig = NULL;
double* yorig = NULL;
double* rddist = NULL;
int i, j;
// 1 x y r x2 xy y2 x3 x2y xy2 y3 r3 x4 x3y x2y2 xy3 y4
// x5 x4y x3y2 x2y3 xy4 y5 r5 x6 x5y x4y2, x3y3 x2y4 xy5 y6
// x7 x6y x5y2 x4y3 x3y4 x2y5 xy6 y7 r7
int xp[] = { 0, 1, 0, 0, 2, 1, 0, 3, 2, 1, 0, 0, 4, 3, 2, 1, 0,
5, 4, 3, 2, 1, 5, 0, 6, 5, 4, 3, 2, 1, 0,
7, 6, 5, 4, 3, 2, 1, 0, 0};
int yp[] = { 0, 0, 1, 0, 0, 1, 2, 0, 1, 2, 3, 0, 0, 1, 2, 3, 4,
0, 1, 2, 3, 4, 0, 0, 0, 1, 2, 3, 4, 5, 6,
0, 1, 2, 3, 4, 5, 6, 7, 0};
int rp[] = { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 7};
double xpows[8];
double ypows[8];
double rpows[8];
double pv1[40];
double pv2[40];
double r;
if (scamp_head_file) {
size_t sz = 0;
char* txt;
char* prefix;
int np;
int nt;
unsigned char* txthdr;
sl* lines;
int i;
txt = file_get_contents(wcsinfn, &sz, TRUE);
if (!txt) {
ERROR("Failed to read file %s", wcsinfn);
goto bailout;
}
lines = sl_split(NULL, txt, "\n");
prefix =
"SIMPLE = T / Standard FITS file "
"BITPIX = 8 / ASCII or bytes array "
"NAXIS = 0 / Minimal header "
"EXTEND = T / There may be FITS ext "
"WCSAXES = 2 / ";
np = strlen(prefix);
nt = np + FITS_LINESZ * sl_size(lines);
txthdr = malloc(nt);
memset(txthdr, ' ', np + FITS_LINESZ * sl_size(lines));
memcpy(txthdr, prefix, np);
for (i=0; i<sl_size(lines); i++)
memcpy(txthdr + np + i*FITS_LINESZ, sl_get(lines, i), strlen(sl_get(lines, i)));
sl_free2(lines);
hdr = qfits_header_read_hdr_string(txthdr, nt);
free(txthdr);
free(txt);
} else {
char* ct;
hdr = anqfits_get_header2(wcsinfn, ext);
ct = fits_get_dupstring(hdr, "CTYPE1");
if ((ct && streq(ct, "RA---TPV")) || forcetan) {
// http://iraf.noao.edu/projects/ccdmosaic/tpv.html
logmsg("Replacing CTYPE1 = %s header with RA---TAN\n", ct);
fits_update_value(hdr, "CTYPE1", "RA---TAN");
}
ct = fits_get_dupstring(hdr, "CTYPE2");
if ((ct && streq(ct, "DEC--TPV")) || forcetan) {
logmsg("Replacing CTYPE2 = %s header with DEC--TAN\n", ct);
fits_update_value(hdr, "CTYPE2", "DEC--TAN");
}
}
if (!hdr) {
ERROR("Failed to read header: file %s, ext %i\n", wcsinfn, ext);
goto bailout;
}
tan_read_header(hdr, &tanwcs);
for (i=0; i<sizeof(pv1)/sizeof(double); i++) {
char key[10];
sprintf(key, "PV1_%i", i);
pv1[i] = qfits_header_getdouble(hdr, key, 0.0);
sprintf(key, "PV2_%i", i);
pv2[i] = qfits_header_getdouble(hdr, key, 0.0);
}
xorig = malloc(Nxy * sizeof(double));
yorig = malloc(Nxy * sizeof(double));
rddist = malloc(2 * Nxy * sizeof(double));
for (j=0; j<Nxy; j++) {
xorig[j] = xy[2*j+0];
yorig[j] = xy[2*j+1];
tan_pixelxy2iwc(&tanwcs, xorig[j], yorig[j], &x, &y);
r = sqrt(x*x + y*y);
xpows[0] = ypows[0] = rpows[0] = 1.0;
for (i=1; i<sizeof(xpows)/sizeof(double); i++) {
xpows[i] = xpows[i-1]*x;
ypows[i] = ypows[i-1]*y;
rpows[i] = rpows[i-1]*r;
}
px = py = 0;
for (i=0; i<sizeof(xp)/sizeof(int); i++) {
px += pv1[i] * xpows[xp[i]] * ypows[yp[i]] * rpows[rp[i]];
py += pv2[i] * ypows[xp[i]] * xpows[yp[i]] * rpows[rp[i]];
}
tan_iwc2xyzarr(&tanwcs, px, py, xyz);
xyzarr2radecdeg(xyz, rddist+2*j, rddist+2*j+1);
}
//
{
starxy_t sxy;
tweak_t* t;
il* imgi;
il* refi;
int sip_order = 5;
int sip_inv_order = 5;
sxy.N = Nxy;
sxy.x = xorig;
sxy.y = yorig;
imgi = il_new(256);
refi = il_new(256);
for (i=0; i<Nxy; i++) {
il_append(imgi, i);
il_append(refi, i);
}
t = tweak_new();
t->sip->a_order = t->sip->b_order = sip_order;
t->sip->ap_order = t->sip->bp_order = sip_inv_order;
tweak_push_wcs_tan(t, &tanwcs);
tweak_push_ref_ad_array(t, rddist, Nxy);
tweak_push_image_xy(t, &sxy);
tweak_push_correspondence_indices(t, imgi, refi, NULL, NULL);
tweak_go_to(t, TWEAK_HAS_LINEAR_CD);
if (imageW)
t->sip->wcstan.imagew = imageW;
if (imageH)
t->sip->wcstan.imageh = imageH;
sip_write_to_file(t->sip, wcsoutfn);
tweak_free(t);
}
rtn = 0;
bailout:
free(xorig);
free(yorig);
free(rddist);
qfits_header_destroy(hdr);
free(radec);
return rtn;
}
static int plot_source_overlay(augment_xylist_t* axy, const char* me,
const char* objsfn, double plotscale, const char* bgfn) {
// plotxy -i harvard.axy -I /tmp/pnm -C red -P -w 2 -N 50 | plotxy -w 2 -r 3 -I - -i harvard.axy -C red -n 50 > harvard-objs.png
sl* cmdline = sl_new(16);
char* cmd;
anbool ctrlc;
char* imgfn;
if (bgfn) {
append_executable(cmdline, "jpegtopnm", me);
append_escape(cmdline, bgfn);
sl_append(cmdline, "|");
imgfn = "-";
} else {
imgfn = axy->pnmfn;
if (axy->imagefn && plotscale != 1.0) {
append_executable(cmdline, "pnmscale", me);
sl_appendf(cmdline, "%f", plotscale);
append_escape(cmdline, axy->pnmfn);
sl_append(cmdline, "|");
imgfn = "-";
}
}
append_executable(cmdline, "plotxy", me);
if (imgfn) {
sl_append(cmdline, "-I");
append_escape(cmdline, imgfn);
} else {
sl_appendf(cmdline, "-W %i -H %i", (int)(plotscale * axy->W), (int)(plotscale * axy->H));
}
sl_append(cmdline, "-i");
append_escape(cmdline, axy->axyfn);
if (axy->xcol) {
sl_append(cmdline, "-X");
append_escape(cmdline, axy->xcol);
}
if (axy->ycol) {
sl_append(cmdline, "-Y");
append_escape(cmdline, axy->ycol);
}
if (plotscale != 1.0) {
sl_append(cmdline, "-S");
sl_appendf(cmdline, "%f", plotscale);
}
sl_append(cmdline, "-C red -w 2 -N 50 -x 1 -y 1");
sl_append(cmdline, "-P");
sl_append(cmdline, "|");
append_executable(cmdline, "plotxy", me);
sl_append(cmdline, "-i");
append_escape(cmdline, axy->axyfn);
if (axy->xcol) {
sl_append(cmdline, "-X");
append_escape(cmdline, axy->xcol);
}
if (axy->ycol) {
sl_append(cmdline, "-Y");
append_escape(cmdline, axy->ycol);
}
sl_append(cmdline, "-I - -w 2 -r 3 -C red -n 50 -N 200 -x 1 -y 1");
if (plotscale != 1.0) {
sl_append(cmdline, "-S");
sl_appendf(cmdline, "%f", plotscale);
}
sl_append(cmdline, ">");
append_escape(cmdline, objsfn);
cmd = sl_implode(cmdline, " ");
sl_free2(cmdline);
if (run_command(cmd, &ctrlc)) {
ERROR("Plotting command %s", (ctrlc ? "was cancelled" : "failed"));
if (!ctrlc) {
errors_print_stack(stdout);
errors_clear_stack();
}
free(cmd);
return -1;
}
free(cmd);
return 0;
}
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;
}
/**
Evaluates the given TAN-TPV WCS header on a grid of points,
fitting a SIP distortion solution to it.
The grid can be specified by either:
double* xy, int Nxy
double stepsize=100, double xlo=0, double xhi=0, double ylo=0, double yhi=0
xlo and xhi, if both 0, default to 1. and the WCS width
ylo and yhi, if both 0, default to 1. and the WCS height
The number of steps is chosen to be the closest step size to split the range
xlo to xhi into an integer number of steps.
imageW and imageH, if non-zero, override the image width read from the WCS,
and ALSO the WCS width/height mentioned above.
*/
int wcs_pv2sip(const char* wcsinfn, int ext,
const char* wcsoutfn,
anbool scamp_head_file,
double* xy, int Nxy,
double stepsize,
double xlo, double xhi,
double ylo, double yhi,
int imageW, int imageH,
int order,
anbool forcetan,
int doshift) {
qfits_header* hdr = NULL;
sip_t* sip = NULL;
int rtn = -1;
if (scamp_head_file) {
size_t sz = 0;
char* txt;
char* prefix;
int np;
int nt;
unsigned char* txthdr;
sl* lines;
int i;
txt = file_get_contents(wcsinfn, &sz, TRUE);
if (!txt) {
ERROR("Failed to read file %s", wcsinfn);
goto bailout;
}
lines = sl_split(NULL, txt, "\n");
prefix =
"SIMPLE = T / Standard FITS file "
"BITPIX = 8 / ASCII or bytes array "
"NAXIS = 0 / Minimal header "
"EXTEND = T / There may be FITS ext "
"WCSAXES = 2 / ";
np = strlen(prefix);
nt = np + FITS_LINESZ * sl_size(lines);
txthdr = malloc(nt);
memset(txthdr, ' ', np + FITS_LINESZ * sl_size(lines));
memcpy(txthdr, prefix, np);
for (i=0; i<sl_size(lines); i++)
memcpy(txthdr + np + i*FITS_LINESZ, sl_get(lines, i), strlen(sl_get(lines, i)));
sl_free2(lines);
hdr = qfits_header_read_hdr_string(txthdr, nt);
free(txthdr);
free(txt);
} else {
hdr = anqfits_get_header2(wcsinfn, ext);
}
if (!hdr) {
ERROR("Failed to read header: file %s, ext %i\n", wcsinfn, ext);
goto bailout;
}
sip = wcs_pv2sip_header(hdr, xy, Nxy, stepsize, xlo, xhi, ylo, yhi,
imageW, imageH, order, forcetan, doshift);
if (!sip) {
goto bailout;
}
sip_write_to_file(sip, wcsoutfn);
rtn = 0;
bailout:
qfits_header_destroy(hdr);
return rtn;
}
int main(int argc, char** args) {
char* default_configfn = "astrometry.cfg";
char* default_config_path = "../etc";
int c;
char* configfn = NULL;
int i;
engine_t* engine;
char* mydir = NULL;
char* basedir = NULL;
char* me;
anbool help = FALSE;
sl* strings = sl_new(4);
char* cancelfn = NULL;
char* solvedfn = NULL;
int loglvl = LOG_MSG;
anbool tostderr = FALSE;
char* infn = NULL;
FILE* fin = NULL;
anbool fromstdin = FALSE;
bl* opts = opts_from_array(myopts, sizeof(myopts)/sizeof(an_option_t), NULL);
sl* inds = sl_new(4);
char* datalog = NULL;
engine = engine_new();
while (1) {
c = opts_getopt(opts, argc, args);
if (c == -1)
break;
switch (c) {
case 'D':
datalog = optarg;
break;
case 'p':
engine->inparallel = TRUE;
break;
case 'i':
sl_append(inds, optarg);
break;
case 'd':
basedir = optarg;
break;
case 'f':
infn = optarg;
fromstdin = streq(infn, "-");
break;
case 'E':
tostderr = TRUE;
break;
case 'h':
help = TRUE;
break;
case 'v':
loglvl++;
break;
case 's':
solvedfn = optarg;
case 'C':
cancelfn = optarg;
break;
case 'c':
configfn = strdup(optarg);
break;
case '?':
break;
default:
printf("Unknown flag %c\n", c);
exit( -1);
}
}
if (optind == argc && !infn) {
// Need extra args: filename
printf("You must specify at least one input file!\n\n");
help = TRUE;
}
if (help) {
print_help(args[0], opts);
exit(0);
}
bl_free(opts);
gslutils_use_error_system();
log_init(loglvl);
if (tostderr)
log_to(stderr);
if (datalog) {
datalogfid = fopen(datalog, "wb");
if (!datalogfid) {
SYSERROR("Failed to open data log file \"%s\" for writing", datalog);
return -1;
}
atexit(close_datalogfid);
data_log_init(100);
data_log_enable_all();
data_log_to(datalogfid);
data_log_start();
}
if (infn) {
logverb("Reading input filenames from %s\n", (fromstdin ? "stdin" : infn));
if (!fromstdin) {
fin = fopen(infn, "rb");
if (!fin) {
ERROR("Failed to open file %s for reading input filenames", infn);
exit(-1);
}
} else
fin = stdin;
}
// directory containing the 'engine' executable:
me = find_executable(args[0], NULL);
if (!me)
me = strdup(args[0]);
mydir = sl_append(strings, dirname(me));
free(me);
// Read config file
if (!configfn) {
int i;
sl* trycf = sl_new(4);
sl_appendf(trycf, "%s/%s/%s", mydir, default_config_path, default_configfn);
// if I'm in /usr/bin, look for config file in /etc
if (streq(mydir, "/usr/bin")) {
sl_appendf(trycf, "/etc/%s", default_configfn);
}
sl_appendf(trycf, "%s/%s", mydir, default_configfn);
sl_appendf(trycf, "./%s", default_configfn);
sl_appendf(trycf, "./%s/%s", default_config_path, default_configfn);
for (i=0; i<sl_size(trycf); i++) {
char* cf = sl_get(trycf, i);
if (file_exists(cf)) {
configfn = strdup(cf);
logverb("Using config file \"%s\"\n", cf);
break;
} else {
logverb("Config file \"%s\" doesn't exist.\n", cf);
}
}
if (!configfn) {
char* cflist = sl_join(trycf, "\n ");
logerr("Couldn't find config file: tried:\n %s\n", cflist);
free(cflist);
}
sl_free2(trycf);
}
if (!streq(configfn, "none")) {
if (engine_parse_config_file(engine, configfn)) {
logerr("Failed to parse (or encountered an error while interpreting) config file \"%s\"\n", configfn);
exit( -1);
}
}
if (sl_size(inds)) {
// Expand globs.
for (i=0; i<sl_size(inds); i++) {
char* s = sl_get(inds, i);
glob_t myglob;
int flags = GLOB_TILDE | GLOB_BRACE;
if (glob(s, flags, NULL, &myglob)) {
SYSERROR("Failed to expand wildcards in index-file path \"%s\"", s);
exit(-1);
}
for (c=0; c<myglob.gl_pathc; c++) {
if (engine_add_index(engine, myglob.gl_pathv[c])) {
ERROR("Failed to add index \"%s\"", myglob.gl_pathv[c]);
exit(-1);
}
}
globfree(&myglob);
}
}
if (!pl_size(engine->indexes)) {
logerr("\n\n"
"---------------------------------------------------------------------\n"
"You must list at least one index in the config file (%s)\n\n"
"See http://astrometry.net/use.html about how to get some index files.\n"
"---------------------------------------------------------------------\n"
"\n", configfn);
exit(-1);
}
if (engine->minwidth <= 0.0 || engine->maxwidth <= 0.0) {
logerr("\"minwidth\" and \"maxwidth\" in the config file %s must be positive!\n", configfn);
exit(-1);
}
free(configfn);
if (!il_size(engine->default_depths)) {
parse_depth_string(engine->default_depths,
"10 20 30 40 50 60 70 80 90 100 "
"110 120 130 140 150 160 170 180 190 200");
}
engine->cancelfn = cancelfn;
engine->solvedfn = solvedfn;
i = optind;
while (1) {
char* jobfn;
job_t* job;
struct timeval tv1, tv2;
if (infn) {
// Read name of next input file to be read.
logverb("\nWaiting for next input filename...\n");
jobfn = read_string_terminated(fin, "\n\r\0", 3, FALSE);
if (strlen(jobfn) == 0)
break;
} else {
if (i == argc)
break;
jobfn = args[i];
i++;
}
gettimeofday(&tv1, NULL);
logmsg("Reading file \"%s\"...\n", jobfn);
job = engine_read_job_file(engine, jobfn);
if (!job) {
ERROR("Failed to read job file \"%s\"", jobfn);
exit(-1);
}
if (basedir) {
logverb("Setting job's output base directory to %s\n", basedir);
job_set_output_base_dir(job, basedir);
}
if (engine_run_job(engine, job))
logerr("Failed to run_job()\n");
job_free(job);
gettimeofday(&tv2, NULL);
logverb("Spent %g seconds on this field.\n", millis_between(&tv1, &tv2)/1000.0);
}
engine_free(engine);
sl_free2(strings);
sl_free2(inds);
if (fin && !fromstdin)
fclose(fin);
return 0;
}
static int write_kmz(const augment_xylist_t* axy, const char* kmzfn,
const char* tempdir, sl* tempdirs, sl* tempfiles) {
char* pngfn = NULL;
char* kmlfn = NULL;
char* warpedpngfn = NULL;
char* basekmlfn = NULL;
char* basewarpedpngfn = NULL;
char* tmpdir;
char* cmd = NULL;
sl* cmdline = sl_new(16);
char* wcsbase = NULL;
tmpdir = create_temp_dir("kmz", tempdir);
if (!tmpdir) {
ERROR("Failed to create temp dir for KMZ output");
sl_free2(cmdline);
return -1;
}
sl_append_nocopy(tempdirs, tmpdir);
pngfn = create_temp_file("png", tempdir);
sl_append_nocopy(tempfiles, pngfn);
sl_append(cmdline, "pnmtopng");
append_escape(cmdline, axy->pnmfn);
sl_append(cmdline, ">");
append_escape(cmdline, pngfn);
// run it
cmd = sl_implode(cmdline, " ");
sl_remove_all(cmdline);
logverb("Running:\n %s\n", cmd);
if (run_command_get_outputs(cmd, NULL, NULL)) {
ERROR("pnmtopng failed");
free(cmd);
sl_free2(cmdline);
return -1;
}
free(cmd);
basekmlfn = "doc.kml";
basewarpedpngfn = "warped.png";
kmlfn = sl_appendf(tempfiles, "%s/%s", tmpdir, basekmlfn);
warpedpngfn = sl_appendf(tempfiles, "%s/%s", tmpdir, basewarpedpngfn);
// delete the wcs we create with "cp" below.
assert(axy->wcsfn);
wcsbase = basename_safe(axy->wcsfn);
sl_appendf(tempfiles, "%s/%s", tmpdir, wcsbase);
free(wcsbase);
logverb("Trying to run wcs2kml to generate KMZ output.\n");
sl_appendf(cmdline, "cp %s %s; cd %s; ", axy->wcsfn, tmpdir, tmpdir);
sl_append(cmdline, "wcs2kml");
// FIXME - if parity?
sl_append(cmdline, "--input_image_origin_is_upper_left");
appendf_escape(cmdline, "--fitsfile=%s", axy->wcsfn);
appendf_escape(cmdline, "--imagefile=%s", pngfn);
appendf_escape(cmdline, "--kmlfile=%s", basekmlfn);
appendf_escape(cmdline, "--outfile=%s", basewarpedpngfn);
// run it
cmd = sl_implode(cmdline, " ");
sl_remove_all(cmdline);
logverb("Running:\n %s\n", cmd);
if (run_command_get_outputs(cmd, NULL, NULL)) {
ERROR("wcs2kml failed");
free(cmd);
sl_free2(cmdline);
return -1;
}
free(cmd);
sl_append(cmdline, "zip");
sl_append(cmdline, "-j"); // no paths, just filenames
//if (!verbose)
//sl_append(cmdline, "-q");
// pipe to stdout, because zip likes to add ".zip" to the
// output filename, and provides no way to turn off this
// behaviour.
sl_append(cmdline, "-");
appendf_escape(cmdline, "%s", warpedpngfn);
appendf_escape(cmdline, "%s", kmlfn);
sl_append(cmdline, ">");
append_escape(cmdline, kmzfn);
// run it
cmd = sl_implode(cmdline, " ");
sl_remove_all(cmdline);
logverb("Running:\n %s\n", cmd);
if (run_command_get_outputs(cmd, NULL, NULL)) {
ERROR("zip failed");
free(cmd);
sl_free2(cmdline);
return -1;
}
free(cmd);
sl_free2(cmdline);
return 0;
}