int main(int argc, char **argv) {
int argchar;
double ra=HUGE_VAL, dec=HUGE_VAL, radius=HUGE_VAL;
int loglvl = LOG_MSG;
char** myargs;
int nmyargs;
int i;
char* outfn = NULL;
fitstable_t* table = NULL;
while ((argchar = getopt (argc, argv, OPTIONS)) != -1)
switch (argchar) {
case 'o':
outfn = optarg;
break;
case 'r':
ra = atof(optarg);
break;
case 'd':
dec = atof(optarg);
break;
case 'R':
radius = atof(optarg);
break;
case 'v':
loglvl++;
break;
case '?':
fprintf(stderr, "Unknown option `-%c'.\n", optopt);
case 'h':
default:
printHelp(argv[0]);
return -1;
}
log_init(loglvl);
nmyargs = argc - optind;
myargs = argv + optind;
if (nmyargs < 1) {
printHelp(argv[0]);
exit(-1);
}
if (ra == HUGE_VAL || dec == HUGE_VAL || radius == HUGE_VAL) {
printHelp(argv[0]);
exit(-1);
}
if (outfn) {
table = fitstable_open_for_writing(outfn);
if (!table) {
ERROR("Failed to open output table");
exit(-1);
}
if (fitstable_write_primary_header(table)) {
ERROR("Failed to write primary header of output table");
exit(-1);
}
}
for (i=0; i<nmyargs; i++) {
char* indexfn = myargs[i];
index_t index;
sl* cols;
int* inds;
double* radecs;
int N;
int j;
fitstable_t* tagtable = NULL;
logmsg("Reading index \"%s\"...\n", indexfn);
if (!index_load(indexfn, 0, &index)) {
ERROR("Failed to read index \"%s\"", indexfn);
continue;
}
logmsg("Index %s: id %i, healpix %i (nside %i), %i stars, %i quads, dimquads=%i, scales %g to %g arcmin.\n",
index.indexname, index.indexid, index.healpix, index.hpnside,
index.nstars, index.nquads, index.dimquads,
arcsec2arcmin(index.index_scale_lower),
arcsec2arcmin(index.index_scale_upper));
cols = startree_get_tagalong_column_names(index.starkd, NULL);
{
char* colstr = sl_join(cols, ", ");
logmsg("Tag-along columns: %s\n", colstr);
free(colstr);
}
logmsg("Searching for stars around RA,Dec (%g, %g), radius %g deg.\n",
ra, dec, radius);
startree_search_for_radec(index.starkd, ra, dec, radius,
NULL, &radecs, &inds, &N);
logmsg("Found %i stars\n", N);
if (table) {
int tagsize;
int rowsize;
char* rowbuf = NULL;
if (i > 0) {
fitstable_next_extension(table);
fitstable_clear_table(table);
}
tagtable = startree_get_tagalong(index.starkd);
if (tagtable) {
fitstable_add_fits_columns_as_struct(tagtable);
logverb("Input tag-along table:\n");
if (log_get_level() >= LOG_VERB)
fitstable_print_columns(tagtable);
fitstable_copy_columns(tagtable, table);
}
tagsize = fitstable_get_struct_size(table);
debug("tagsize=%i\n", tagsize);
// Add RA,Dec at the end of the row...
fitstable_add_write_column_struct(table, fitscolumn_double_type(), 1, tagsize, fitscolumn_double_type(), "RA", "degrees");
fitstable_add_write_column_struct(table, fitscolumn_double_type(), 1, tagsize + sizeof(double), fitscolumn_double_type(), "DEC", "degrees");
rowsize = fitstable_get_struct_size(table);
assert(rowsize == tagsize + 2*sizeof(double));
debug("rowsize=%i\n", rowsize);
rowbuf = malloc(rowsize);
logverb("Output table:\n");
if (log_get_level() >= LOG_VERB)
fitstable_print_columns(table);
if (fitstable_write_header(table)) {
ERROR("Failed to write header of output table");
exit(-1);
}
for (j=0; j<N; j++) {
if (tagtable) {
if (fitstable_read_struct(tagtable, inds[j], rowbuf)) {
ERROR("Failed to read row %i of tag-along table", inds[j]);
exit(-1);
}
}
// Add RA,Dec to end of struct...
memcpy(rowbuf + tagsize, radecs+2*j+0, sizeof(double));
memcpy(rowbuf + tagsize + sizeof(double), radecs+2*j+1, sizeof(double));
if (fitstable_write_struct(table, rowbuf)) {
ERROR("Failed to write row %i of output", j);
exit(-1);
}
}
free(rowbuf);
if (fitstable_fix_header(table)) {
ERROR("Failed to fix header of output table");
exit(-1);
}
}
sl_free2(cols);
free(radecs);
free(inds);
index_close(&index);
}
if (table) {
if (fitstable_close(table)) {
ERROR("Failed to close output table");
exit(-1);
}
}
return 0;
}
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;
}
