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;
}
sl* fitstable_get_fits_column_names(const fitstable_t* t, sl* lst) {
int i;
if (!lst)
lst = sl_new(16);
for (i=0; i<t->table->nc; i++) {
qfits_col* qcol = t->table->col + i;
sl_append(lst, qcol->tlabel);
}
return lst;
}
sl* ngc_get_names(ngc_entry* entry, sl* lst) {
int i;
if (!lst)
lst = sl_new(4);
sl_appendf(lst, "%s %i", (entry->is_ngc ? "NGC" : "IC"), entry->id);
for (i=0; i<sizeof(ngc_names)/sizeof(ngc_name); i++) {
if ((entry->is_ngc == ngc_names[i].is_ngc) &&
(entry->id == ngc_names[i].id)) {
sl_append(lst, ngc_names[i].name);
}
}
return lst;
}
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);
}
static void
rte_src_init(void)
{
rte_src_slab = sl_new(rta_pool, sizeof(struct rte_src));
src_id_pos = 0;
src_id_size = SRC_ID_INIT_SIZE;
src_ids = mb_allocz(rta_pool, src_id_size * sizeof(u32));
/* ID 0 is reserved */
src_ids[0] = 1;
src_id_used = 1;
HASH_INIT(src_hash, rta_pool, RSH_INIT_ORDER);
}
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);
}
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);
}
sl* sl_split(sl* lst, const char* str, const char* sepstring) {
int seplen;
const char* s;
char* next_sep;
if (!lst)
lst = sl_new(4);
seplen = strlen(sepstring);
s = str;
while (s && *s) {
next_sep = strstr(s, sepstring);
if (!next_sep) {
sl_append(lst, s);
break;
}
//logverb("Appending: '%.*s'\n", (int)(next_sep - s), s);
sl_appendf(lst, "%.*s", (int)(next_sep - s), s);
s = next_sep + seplen;
}
return lst;
}
void
sl_init_request(sl_vm_t* vm)
{
SLVAL Request = sl_new(vm, vm->lib.Object, 0, NULL);
sl_vm_store_put(vm, &Request_, Request);
sl_define_singleton_method(vm, Request, "get", 0, request_get);
sl_define_singleton_method(vm, Request, "post", 0, request_post);
sl_define_singleton_method(vm, Request, "post_data", 0, request_post_data);
sl_define_singleton_method(vm, Request, "headers", 0, request_headers);
sl_define_singleton_method(vm, Request, "env", 0, request_env);
sl_define_singleton_method(vm, Request, "cookies", 0, request_cookies);
sl_define_singleton_method(vm, Request, "method", 0, request_method);
sl_define_singleton_method(vm, Request, "safe_method", 0, request_safe_method);
sl_define_singleton_method(vm, Request, "uri", 0, request_uri);
sl_define_singleton_method(vm, Request, "path_info", 0, request_path_info);
sl_define_singleton_method(vm, Request, "query_string", 0, request_query_string);
sl_define_singleton_method(vm, Request, "remote_addr", 0, request_remote_addr);
sl_define_singleton_method(vm, Request, "[]", 1, request_index);
sl_class_set_const(vm, vm->lib.Object, "Request", Request);
}
/**
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;
}
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;
}
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 main(int argc, char** args) {
int c;
FILE* fconst = NULL;
uint32_t nstars;
size_t mapsize;
void* map;
unsigned char* hip;
FILE* fhip = NULL;
int i;
pl* cstars;
il* alluniqstars;
sl* shortnames;
while ((c = getopt(argc, args, OPTIONS)) != -1) {
switch (c) {
case 'h':
print_help(args[0]);
exit(0);
}
}
if (optind != argc) {
print_help(args[0]);
exit(-1);
}
for (i=0; i<sizeof(const_dirs)/sizeof(char*); i++) {
char fn[256];
snprintf(fn, sizeof(fn), "%s/%s", const_dirs[i], constfn);
fprintf(stderr, "render_constellation: Trying file: %s\n", fn);
fconst = fopen(fn, "rb");
if (fconst)
break;
}
if (!fconst) {
fprintf(stderr, "render_constellation: couldn't open any constellation files.\n");
return -1;
}
for (i=0; i<sizeof(hip_dirs)/sizeof(char*); i++) {
char fn[256];
snprintf(fn, sizeof(fn), "%s/%s", hip_dirs[i], hipparcos_fn);
fprintf(stderr, "render_constellation: Trying hip file: %s\n", fn);
fhip = fopen(fn, "rb");
if (fhip)
break;
}
if (!fhip) {
fprintf(stderr, "render_constellation: unhip\n");
return -1;
}
// first 32-bit int:
if (fread(&nstars, 4, 1, fhip) != 1) {
fprintf(stderr, "render_constellation: failed to read nstars.\n");
return -1;
}
v32_letoh(&nstars);
fprintf(stderr, "render_constellation: Found %i Hipparcos stars\n", nstars);
mapsize = nstars * HIP_SIZE + HIP_OFFSET;
map = mmap(0, mapsize, PROT_READ, MAP_SHARED, fileno(fhip), 0);
hip = ((unsigned char*)map) + HIP_OFFSET;
// for each constellation, its il* of lines.
cstars = pl_new(16);
alluniqstars = il_new(16);
shortnames = sl_new(16);
for (c=0;; c++) {
char shortname[16];
int nlines;
int i;
il* stars;
if (feof(fconst))
break;
if (fscanf(fconst, "%s %d ", shortname, &nlines) != 2) {
fprintf(stderr, "failed to parse name+nlines (constellation %i)\n", c);
fprintf(stderr, "file offset: %i (%x)\n",
(int)ftello(fconst), (int)ftello(fconst));
return -1;
}
//fprintf(stderr, "Name: %s. Nlines %i.\n", shortname, nlines);
stars = il_new(16);
sl_append(shortnames, shortname);
pl_append(cstars, stars);
for (i=0; i<nlines; i++) {
int star1, star2;
if (fscanf(fconst, " %d %d", &star1, &star2) != 2) {
fprintf(stderr, "failed parse star1+star2\n");
return -1;
}
il_insert_unique_ascending(alluniqstars, star1);
il_insert_unique_ascending(alluniqstars, star2);
il_append(stars, star1);
il_append(stars, star2);
}
fscanf(fconst, "\n");
}
fprintf(stderr, "render_constellations: Read %i constellations.\n", c);
printf("static const int constellations_N = %i;\n", sl_size(shortnames));
/*
for (c=0; c<sl_size(shortnames); c++) {
printf("static const char* shortname_%i = \"%s\";\n", c, sl_get(shortnames, c));
}
printf("static const char* shortnames[] = {");
for (c=0; c<sl_size(shortnames); c++) {
printf("shortname_%i,", c);
}
printf("};\n");
*/
printf("static const char* shortnames[] = {");
for (c=0; c<sl_size(shortnames); c++) {
printf("\"%s\",", sl_get(shortnames, c));
}
printf("};\n");
printf("static const int constellation_nlines[] = {");
for (c=0; c<pl_size(cstars); c++) {
il* stars = pl_get(cstars, c);
printf("%i,", il_size(stars)/2);
}
printf("};\n");
for (c=0; c<pl_size(cstars); c++) {
il* stars = pl_get(cstars, c);
printf("static const int constellation_lines_%i[] = {", c);
for (i=0; i<il_size(stars); i++) {
int s = il_get(stars, i);
int ms = il_index_of(alluniqstars, s);
printf("%s%i", (i?",":""), ms);
}
printf("};\n");
}
printf("static const int* constellation_lines[] = {");
for (c=0; c<pl_size(cstars); c++) {
printf("constellation_lines_%i,", c);
}
printf("};\n");
printf("static const int stars_N = %i;\n", il_size(alluniqstars));
printf("static const double star_positions[] = {");
for (i=0; i<il_size(alluniqstars); i++) {
int s = il_get(alluniqstars, i);
double ra, dec;
hip_get_radec(hip, s, &ra, &dec);
printf("%g,%g,", ra, dec);
}
printf("};\n");
munmap(map, mapsize);
fclose(fconst);
fclose(fhip);
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;
}
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;
}
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;
}
void fits_guess_scale_hdr(const qfits_header* hdr,
sl** p_methods, dl** p_scales) {
sip_t sip;
double val;
anbool gotsip = FALSE;
char* errstr;
sl* methods = NULL;
dl* scales = NULL;
if (p_methods) {
if (!*p_methods)
*p_methods = sl_new(4);
methods = *p_methods;
}
if (p_scales) {
if (!*p_scales)
*p_scales = dl_new(4);
scales = *p_scales;
}
memset(&sip, 0, sizeof(sip_t));
errors_start_logging_to_string();
if (sip_read_header(hdr, &sip)) {
val = sip_pixel_scale(&sip);
if (val != 0.0) {
addscale(methods, scales, "sip", val);
gotsip = TRUE;
}
}
errstr = errors_stop_logging_to_string("\n ");
logverb("fits-guess-scale: failed to read SIP/TAN header:\n %s\n", errstr);
free(errstr);
if (!gotsip) {
// it might have a correct CD matrix but be missing other parts (eg CRVAL)
double cd11, cd12, cd21, cd22;
double errval = -HUGE_VAL;
cd11 = qfits_header_getdouble(hdr, "CD1_1", errval);
cd12 = qfits_header_getdouble(hdr, "CD1_2", errval);
cd21 = qfits_header_getdouble(hdr, "CD2_1", errval);
cd22 = qfits_header_getdouble(hdr, "CD2_2", errval);
if ((cd11 != errval) && (cd12 != errval) && (cd21 != errval) && (cd22 != errval)) {
val = cd11 * cd22 - cd12 * cd21;
if (val != 0.0)
addscale(methods, scales, "cd", sqrt(fabs(val)));
}
}
val = qfits_header_getdouble(hdr, "PIXSCALE", -1.0);
if (val != -1.0)
addscale(methods, scales, "pixscale", val);
/* Why all this?
val = qfits_header_getdouble(hdr, "PIXSCAL1", -1.0);
if (val != -1.0) {
if (val != 0.0) {
printf("scale pixscal1 %g\n", val);
} else {
val = atof(qfits_pretty_string(qfits_header_getstr(hdr, "PIXSCAL1")));
if (val != 0.0) {
printf("scale pixscal1 %g\n", val);
}
}
}
*/
val = qfits_header_getdouble(hdr, "PIXSCAL1", 0.0);
if (val != 0.0)
addscale(methods, scales, "pixscal1", val);
val = qfits_header_getdouble(hdr, "PIXSCAL2", 0.0);
if (val != 0.0)
addscale(methods, scales, "pixscal2", val);
val = qfits_header_getdouble(hdr, "PLATESC", 0.0);
if (val != 0.0)
addscale(methods, scales, "platesc", val);
val = qfits_header_getdouble(hdr, "CCDSCALE", 0.0);
if (val != 0.0)
addscale(methods, scales, "ccdscale", val);
val = qfits_header_getdouble(hdr, "CDELT1", 0.0);
if (val != 0.0)
addscale(methods, scales, "cdelt1", 3600.0 * fabs(val));
}
int main(int argc, char **argv) {
int argchar;
startree_t* starkd;
double ra=0.0, dec=0.0, radius=0.0;
sl* tag = sl_new(4);
anbool tagall = FALSE;
char* starfn = NULL;
int loglvl = LOG_MSG;
char** myargs;
int nmyargs;
anbool getinds = FALSE;
double* radec;
int* inds;
int N;
int i;
char* rdfn = NULL;
pl* tagdata = pl_new(16);
il* tagsizes = il_new(16);
fitstable_t* tagalong = NULL;
while ((argchar = getopt (argc, argv, OPTIONS)) != -1)
switch (argchar) {
case 'o':
rdfn = optarg;
break;
case 'I':
getinds = TRUE;
break;
case 'r':
ra = atof(optarg);
break;
case 'd':
dec = atof(optarg);
break;
case 'R':
radius = atof(optarg);
break;
case 't':
sl_append(tag, optarg);
break;
case 'T':
tagall = TRUE;
break;
case 'v':
loglvl++;
break;
case '?':
fprintf(stderr, "Unknown option `-%c'.\n", optopt);
case 'h':
printHelp(argv[0]);
break;
default:
return -1;
}
nmyargs = argc - optind;
myargs = argv + optind;
if (nmyargs != 1) {
ERROR("Got %i arguments; expected 1.\n", nmyargs);
printHelp(argv[0]);
exit(-1);
}
starfn = myargs[0];
log_init(loglvl);
starkd = startree_open(starfn);
if (!starkd) {
ERROR("Failed to open star kdtree");
exit(-1);
}
logmsg("Searching kdtree %s at RA,Dec = (%g,%g), radius %g deg.\n",
starfn, ra, dec, radius);
startree_search_for_radec(starkd, ra, dec, radius,
NULL, &radec, &inds, &N);
logmsg("Got %i results.\n", N);
if (!N)
goto done;
if (tagall) {
int j, M;
M = startree_get_tagalong_N_columns(starkd);
for (j=0; j<M; j++)
sl_append(tag, startree_get_tagalong_column_name(starkd, j));
}
if (sl_size(tag)) {
tagalong = startree_get_tagalong(starkd);
if (!tagalong) {
ERROR("Failed to find tag-along table in index");
exit(-1);
}
}
if (rdfn) {
rdlist_t* rd = rdlist_open_for_writing(rdfn);
il* colnums = il_new(16);
if (!rd) {
ERROR("Failed to open output file %s", rdfn);
exit(-1);
}
if (rdlist_write_primary_header(rd)) {
ERROR("Failed to write header to output file %s", rdfn);
exit(-1);
}
for (i=0; i<sl_size(tag); i++) {
const char* col = sl_get(tag, i);
char* units;
tfits_type type;
int arraysize;
void* data;
int colnum;
int itemsize;
if (fitstable_find_fits_column(tagalong, col, &units, &type, &arraysize)) {
ERROR("Failed to find column \"%s\" in index", col);
exit(-1);
}
itemsize = fits_get_atom_size(type) * arraysize;
data = fitstable_read_column_array_inds(tagalong, col, type, inds, N, NULL);
if (!data) {
ERROR("Failed to read data for column \"%s\" in index", col);
exit(-1);
}
colnum = rdlist_add_tagalong_column(rd, type, arraysize, type, col, NULL);
il_append(colnums, colnum);
il_append(tagsizes, itemsize);
pl_append(tagdata, data);
}
if (rdlist_write_header(rd)) {
ERROR("Failed to write header to output file %s", rdfn);
exit(-1);
}
for (i=0; i<N; i++) {
if (rdlist_write_one_radec(rd, radec[i*2+0], radec[i*2+1])) {
ERROR("Failed to write RA,Dec to output file %s", rdfn);
exit(-1);
}
}
for (i=0; i<sl_size(tag); i++) {
int col = il_get(colnums, i);
void* data = pl_get(tagdata, i);
int itemsize = il_get(tagsizes, i);
if (rdlist_write_tagalong_column(rd, col, 0, N, data, itemsize)) {
ERROR("Failed to write tag-along data column %s", sl_get(tag, i));
exit(-1);
}
}
if (rdlist_fix_header(rd) ||
rdlist_fix_primary_header(rd) ||
rdlist_close(rd)) {
ERROR("Failed to close output file %s", rdfn);
exit(-1);
}
il_free(colnums);
} else {
// Header
printf("# RA, Dec");
if (getinds)
printf(", index");
for (i=0; i<sl_size(tag); i++)
printf(", %s", sl_get(tag, i));
printf("\n");
for (i=0; i<sl_size(tag); i++) {
const char* col = sl_get(tag, i);
char* units;
tfits_type type;
int arraysize;
void* data;
int itemsize;
if (fitstable_find_fits_column(tagalong, col, &units, &type, &arraysize)) {
ERROR("Failed to find column \"%s\" in index", col);
exit(-1);
}
itemsize = fits_get_atom_size(type) * arraysize;
data = fitstable_read_column_array_inds(tagalong, col, type, inds, N, NULL);
if (!data) {
ERROR("Failed to read data for column \"%s\" in index", col);
exit(-1);
}
il_append(tagsizes, itemsize);
pl_append(tagdata, data);
}
for (i=0; i<N; i++) {
//int j;
printf("%g, %g", radec[i*2+0], radec[i*2+1]);
if (getinds)
printf(", %i", inds[i]);
//// FIXME -- print tag-along data of generic type.
/*
for (j=0; j<pl_size(tagdata); j++) {
double* data = pl_get(tagdata, j);
printf(", %g", data[i]);
}
*/
printf("\n");
}
}
done:
free(radec);
free(inds);
for (i=0; i<pl_size(tagdata); i++)
free(pl_get(tagdata, i));
pl_free(tagdata);
il_free(tagsizes);
return 0;
}
