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; }