void test_il_dupe(CuTest* tc) {
int i, N=63;
il* x = il_new(4), *y;
for (i=0;i<N;i++)
il_push(x,i);
y = il_dupe(x);
for (i=0;i<N;i++)
CuAssertIntEquals(tc, i, il_get(y, i));
for (i=0;i<N;i++)
il_pop(x);
CuAssertIntEquals(tc, N, il_size(y));
CuAssertIntEquals(tc, il_check_consistency(x), 0);
il_free(x);
il_free(y);
}
void test_il_insert_descending(CuTest* tc) {
int i;
il* x = il_new(4);
il_insert_descending(x,2);
il_insert_descending(x,4);
il_insert_descending(x,8);
il_insert_descending(x,5);
il_insert_descending(x,6);
il_insert_descending(x,7);
il_insert_descending(x,1);
il_insert_descending(x,3);
il_insert_descending(x,0);
CuAssertIntEquals(tc, il_check_consistency(x), 0);
CuAssertIntEquals(tc, il_check_sorted_descending(x, 0), 0);
for (i=0;i<il_size(x);i++)
CuAssertIntEquals(tc, il_size(x)-i-1, il_get(x, i));
il_free(x);
}
static int build_quads(hpquads_t* me, int Nhptotry, il* hptotry, int R) {
int nthispass = 0;
int lastgrass = 0;
int i;
for (i=0; i<Nhptotry; i++) {
anbool ok;
int hp;
if ((i * 80 / Nhptotry) != lastgrass) {
printf(".");
fflush(stdout);
lastgrass = i * 80 / Nhptotry;
}
if (hptotry)
hp = il_get(hptotry, i);
else
hp = i;
me->hp = hp;
me->quad_created = FALSE;
ok = find_stars(me, me->radius2, R);
if (ok)
create_quad(me, TRUE);
if (me->quad_created)
nthispass++;
else {
if (R && me->Nstars && me->retryhps)
// there were some stars, and we're counting how many times stars are used.
//il_insert_unique_ascending(me->retryhps, hp);
// we don't mind hps showing up multiple times because we want to make up for the lost
// passes during loosening...
il_append(me->retryhps, hp);
// FIXME -- could also track which hps are worth visiting in a future pass
}
}
printf("\n");
return nthispass;
}
static dimage_label_t relabel_image(il* on_pixels,
int maxlabel,
dimage_label_t* equivs,
int* object) {
int i;
dimage_label_t maxcontiguouslabel = 0;
dimage_label_t *number;
number = malloc(sizeof(dimage_label_t) * maxlabel);
assert(number);
for (i = 0; i < maxlabel; i++)
number[i] = LABEL_MAX;
for (i=0; i<il_size(on_pixels); i++) {
int onpix;
int minlabel;
onpix = il_get(on_pixels, i);
minlabel = collapsing_find_minlabel(object[onpix], equivs);
if (number[minlabel] == LABEL_MAX)
number[minlabel] = maxcontiguouslabel++;
object[onpix] = number[minlabel];
}
free(number);
return maxcontiguouslabel;
}
int main(int argc, char** args) {
char* filename = NULL;
int npoints;
int i, j;
int* healpixes;
int argchar;
char* progname = args[0];
il** lists;
anbool quiet = FALSE;
rdlist* rdls;
int Nside = 1;
int N;
while ((argchar = getopt (argc, args, OPTIONS)) != -1)
switch (argchar) {
case 'N':
Nside = atoi(optarg);
break;
case 'f':
filename = optarg;
break;
case 'h':
printHelp(progname);
exit(0);
case 'q':
quiet = TRUE;
break;
case '?':
fprintf(stderr, "Unknown option `-%c'.\n", optopt);
default:
exit(-1);
}
if (!filename) {
printHelp(progname);
exit(-1);
}
fprintf(stderr, "Opening RDLS file %s...\n", filename);
rdls = rdlist_open(filename);
if (!rdls) {
fprintf(stderr, "Failed to open RDLS file.\n");
exit(-1);
}
N = 12 * Nside * Nside;
healpixes = malloc(N * sizeof(int));
lists = calloc(N, sizeof(il*));
/*
for (i=0; i<N; i++) {
lists[i] = il_new(256);
}
*/
for (j=1; j<=rdls_n_fields(rdls); j++) {
rd* points;
points = rdlist_get_field(rdls, j);
if (!points) {
fprintf(stderr, "error reading field %i\n", j);
break;
}
memset(healpixes, 0, N * sizeof(int));
npoints = rd_size(points);
for (i=0; i<npoints; i++) {
double ra, dec;
int hp;
ra = deg2rad(rd_refra (points, i));
dec = deg2rad(rd_refdec(points, i));
if (Nside > 1)
hp = radectohealpix_nside(ra, dec, Nside);
else
hp = radectohealpix(ra, dec);
if ((hp < 0) || (hp >= N)) {
printf("hp=%i\n", hp);
continue;
}
healpixes[hp] = 1;
}
if (!quiet) {
printf("Field %i: healpixes ", j);
for (i=0; i<N; i++) {
if (healpixes[i])
printf("%i ", i);
}
printf("\n");
fflush(stdout);
}
for (i=0; i<N; i++)
if (healpixes[i]) {
if (!lists[i])
lists[i] = il_new(256);
il_append(lists[i], j);
}
free_rd(points);
}
for (i=0; i<N; i++) {
int N;
if (!lists[i])
continue;
printf("HP %i: ", i);
N = il_size(lists[i]);
for (j=0; j<N; j++)
printf("%i ", il_get(lists[i], j));
il_free(lists[i]);
printf("\n");
}
free(lists);
free(healpixes);
rdlist_close(rdls);
return 0;
}
int main(int argc, char *argv[]) {
int argchar;
char* progname = argv[0];
sl* infns = sl_new(16);
char* outfnpat = NULL;
char* racol = "RA";
char* deccol = "DEC";
char* tempdir = "/tmp";
anbool gzip = FALSE;
sl* cols = sl_new(16);
int loglvl = LOG_MSG;
int nside = 1;
double margin = 0.0;
int NHP;
double md;
char* backref = NULL;
fitstable_t* intable;
fitstable_t** outtables;
char** myargs;
int nmyargs;
int i;
while ((argchar = getopt (argc, argv, OPTIONS)) != -1)
switch (argchar) {
case 'b':
backref = optarg;
break;
case 't':
tempdir = optarg;
break;
case 'c':
sl_append(cols, optarg);
break;
case 'g':
gzip = TRUE;
break;
case 'o':
outfnpat = optarg;
break;
case 'r':
racol = optarg;
break;
case 'd':
deccol = optarg;
break;
case 'n':
nside = atoi(optarg);
break;
case 'm':
margin = atof(optarg);
break;
case 'v':
loglvl++;
break;
case '?':
fprintf(stderr, "Unknown option `-%c'.\n", optopt);
case 'h':
printHelp(progname);
return 0;
default:
return -1;
}
if (sl_size(cols) == 0) {
sl_free2(cols);
cols = NULL;
}
nmyargs = argc - optind;
myargs = argv + optind;
for (i=0; i<nmyargs; i++)
sl_append(infns, myargs[i]);
if (!sl_size(infns)) {
printHelp(progname);
printf("Need input filenames!\n");
exit(-1);
}
log_init(loglvl);
fits_use_error_system();
NHP = 12 * nside * nside;
logmsg("%i output healpixes\n", NHP);
outtables = calloc(NHP, sizeof(fitstable_t*));
assert(outtables);
md = deg2dist(margin);
/**
About the mincaps/maxcaps:
These have a center and radius-squared, describing the region
inside a small circle on the sphere.
The "mincaps" describe the regions that are definitely owned by a
single healpix -- ie, more than MARGIN distance from any edge.
That is, the mincap is the small circle centered at (0.5, 0.5) in
the healpix and with radius = the distance to the closest healpix
boundary, MINUS the margin distance.
Below, we first check whether a new star is within the "mincap"
of any healpix. If so, we stick it in that healpix and continue.
Otherwise, we check all the "maxcaps" -- these are the healpixes
it could *possibly* be in. We then refine with
healpix_within_range_of_xyz. The maxcap distance is the distance
to the furthest boundary point, PLUS the margin distance.
*/
cap_t* mincaps = malloc(NHP * sizeof(cap_t));
cap_t* maxcaps = malloc(NHP * sizeof(cap_t));
for (i=0; i<NHP; i++) {
// center
double r2;
double xyz[3];
double* cxyz;
double step = 1e-3;
double v;
double r2b, r2a;
cxyz = mincaps[i].xyz;
healpix_to_xyzarr(i, nside, 0.5, 0.5, mincaps[i].xyz);
memcpy(maxcaps[i].xyz, cxyz, 3 * sizeof(double));
logverb("Center of HP %i: (%.3f, %.3f, %.3f)\n", i, cxyz[0], cxyz[1], cxyz[2]);
// radius-squared:
// max is the easy one: max of the four corners (I assume)
r2 = 0.0;
healpix_to_xyzarr(i, nside, 0.0, 0.0, xyz);
logverb(" HP %i corner 1: (%.3f, %.3f, %.3f), distsq %.3f\n", i, xyz[0], xyz[1], xyz[2], distsq(xyz, cxyz, 3));
r2 = MAX(r2, distsq(xyz, cxyz, 3));
healpix_to_xyzarr(i, nside, 1.0, 0.0, xyz);
logverb(" HP %i corner 1: (%.3f, %.3f, %.3f), distsq %.3f\n", i, xyz[0], xyz[1], xyz[2], distsq(xyz, cxyz, 3));
r2 = MAX(r2, distsq(xyz, cxyz, 3));
healpix_to_xyzarr(i, nside, 0.0, 1.0, xyz);
logverb(" HP %i corner 1: (%.3f, %.3f, %.3f), distsq %.3f\n", i, xyz[0], xyz[1], xyz[2], distsq(xyz, cxyz, 3));
r2 = MAX(r2, distsq(xyz, cxyz, 3));
healpix_to_xyzarr(i, nside, 1.0, 1.0, xyz);
logverb(" HP %i corner 1: (%.3f, %.3f, %.3f), distsq %.3f\n", i, xyz[0], xyz[1], xyz[2], distsq(xyz, cxyz, 3));
r2 = MAX(r2, distsq(xyz, cxyz, 3));
logverb(" max distsq: %.3f\n", r2);
logverb(" margin dist: %.3f\n", md);
maxcaps[i].r2 = square(sqrt(r2) + md);
logverb(" max cap distsq: %.3f\n", maxcaps[i].r2);
r2a = r2;
r2 = 1.0;
r2b = 0.0;
for (v=0; v<=1.0; v+=step) {
healpix_to_xyzarr(i, nside, 0.0, v, xyz);
r2 = MIN(r2, distsq(xyz, cxyz, 3));
r2b = MAX(r2b, distsq(xyz, cxyz, 3));
healpix_to_xyzarr(i, nside, 1.0, v, xyz);
r2 = MIN(r2, distsq(xyz, cxyz, 3));
r2b = MAX(r2b, distsq(xyz, cxyz, 3));
healpix_to_xyzarr(i, nside, v, 0.0, xyz);
r2 = MIN(r2, distsq(xyz, cxyz, 3));
r2b = MAX(r2b, distsq(xyz, cxyz, 3));
healpix_to_xyzarr(i, nside, v, 1.0, xyz);
r2 = MIN(r2, distsq(xyz, cxyz, 3));
r2b = MAX(r2b, distsq(xyz, cxyz, 3));
}
mincaps[i].r2 = square(MAX(0, sqrt(r2) - md));
logverb("\nhealpix %i: min rad %g\n", i, sqrt(r2));
logverb("healpix %i: max rad %g\n", i, sqrt(r2a));
logverb("healpix %i: max rad(b) %g\n", i, sqrt(r2b));
assert(r2a >= r2b);
}
if (backref) {
fitstable_t* tab = fitstable_open_for_writing(backref);
int maxlen = 0;
char* buf;
for (i=0; i<sl_size(infns); i++) {
char* infn = sl_get(infns, i);
maxlen = MAX(maxlen, strlen(infn));
}
fitstable_add_write_column_array(tab, fitscolumn_char_type(), maxlen,
"filename", NULL);
fitstable_add_write_column(tab, fitscolumn_i16_type(), "index", NULL);
if (fitstable_write_primary_header(tab) ||
fitstable_write_header(tab)) {
ERROR("Failed to write header of backref table \"%s\"", backref);
exit(-1);
}
buf = malloc(maxlen+1);
assert(buf);
for (i=0; i<sl_size(infns); i++) {
char* infn = sl_get(infns, i);
int16_t ind;
memset(buf, 0, maxlen);
strcpy(buf, infn);
ind = i;
if (fitstable_write_row(tab, buf, &ind)) {
ERROR("Failed to write row %i of backref table: %s = %i",
i, buf, ind);
exit(-1);
}
}
if (fitstable_fix_header(tab) ||
fitstable_close(tab)) {
ERROR("Failed to fix header & close backref table");
exit(-1);
}
logmsg("Wrote backref table %s\n", backref);
free(buf);
}
for (i=0; i<sl_size(infns); i++) {
char* infn = sl_get(infns, i);
char* originfn = infn;
int r, NR;
tfits_type any, dubl;
il* hps = NULL;
bread_t* rowbuf;
int R;
char* tempfn = NULL;
char* padrowdata = NULL;
int ii;
logmsg("Reading input \"%s\"...\n", infn);
if (gzip) {
char* cmd;
int rtn;
tempfn = create_temp_file("hpsplit", tempdir);
asprintf_safe(&cmd, "gunzip -cd %s > %s", infn, tempfn);
logmsg("Running: \"%s\"\n", cmd);
rtn = run_command_get_outputs(cmd, NULL, NULL);
if (rtn) {
ERROR("Failed to run command: \"%s\"", cmd);
exit(-1);
}
free(cmd);
infn = tempfn;
}
intable = fitstable_open(infn);
if (!intable) {
ERROR("Couldn't read catalog %s", infn);
exit(-1);
}
NR = fitstable_nrows(intable);
logmsg("Got %i rows\n", NR);
any = fitscolumn_any_type();
dubl = fitscolumn_double_type();
fitstable_add_read_column_struct(intable, dubl, 1, 0, any, racol, TRUE);
fitstable_add_read_column_struct(intable, dubl, 1, sizeof(double), any, deccol, TRUE);
fitstable_use_buffered_reading(intable, 2*sizeof(double), 1000);
R = fitstable_row_size(intable);
rowbuf = buffered_read_new(R, 1000, NR, refill_rowbuffer, intable);
if (fitstable_read_extension(intable, 1)) {
ERROR("Failed to find RA and DEC columns (called \"%s\" and \"%s\" in the FITS file)", racol, deccol);
exit(-1);
}
for (r=0; r<NR; r++) {
int hp = -1;
double ra, dec;
int j;
double* rd;
void* rowdata;
void* rdata;
if (r && ((r % 100000) == 0)) {
logmsg("Reading row %i of %i\n", r, NR);
}
//printf("reading RA,Dec for row %i\n", r);
rd = fitstable_next_struct(intable);
ra = rd[0];
dec = rd[1];
logverb("row %i: ra,dec %g,%g\n", r, ra, dec);
if (margin == 0) {
hp = radecdegtohealpix(ra, dec, nside);
logverb(" --> healpix %i\n", hp);
} else {
double xyz[3];
anbool gotit = FALSE;
double d2;
if (!hps)
hps = il_new(4);
radecdeg2xyzarr(ra, dec, xyz);
for (j=0; j<NHP; j++) {
d2 = distsq(xyz, mincaps[j].xyz, 3);
if (d2 <= mincaps[j].r2) {
logverb(" -> in mincap %i (dist %g vs %g)\n", j, sqrt(d2), sqrt(mincaps[j].r2));
il_append(hps, j);
gotit = TRUE;
break;
}
}
if (!gotit) {
for (j=0; j<NHP; j++) {
d2 = distsq(xyz, maxcaps[j].xyz, 3);
if (d2 <= maxcaps[j].r2) {
logverb(" -> in maxcap %i (dist %g vs %g)\n", j, sqrt(d2), sqrt(maxcaps[j].r2));
if (healpix_within_range_of_xyz(j, nside, xyz, margin)) {
logverb(" -> and within range.\n");
il_append(hps, j);
}
}
}
}
//hps = healpix_rangesearch_radec(ra, dec, margin, nside, hps);
logverb(" --> healpixes: [");
for (j=0; j<il_size(hps); j++)
logverb(" %i", il_get(hps, j));
logverb(" ]\n");
}
//printf("Reading rowdata for row %i\n", r);
rowdata = buffered_read(rowbuf);
assert(rowdata);
j=0;
while (1) {
if (hps) {
if (j >= il_size(hps))
break;
hp = il_get(hps, j);
j++;
}
assert(hp < NHP);
assert(hp >= 0);
if (!outtables[hp]) {
char* outfn;
fitstable_t* out;
// MEMLEAK the output filename. You'll live.
asprintf_safe(&outfn, outfnpat, hp);
logmsg("Opening output file \"%s\"...\n", outfn);
out = fitstable_open_for_writing(outfn);
if (!out) {
ERROR("Failed to open output table \"%s\"", outfn);
exit(-1);
}
// Set the output table structure.
if (cols) {
fitstable_add_fits_columns_as_struct3(intable, out, cols, 0);
} else
fitstable_add_fits_columns_as_struct2(intable, out);
if (backref) {
tfits_type i16type;
tfits_type i32type;
// R = fitstable_row_size(intable);
int off = R;
i16type = fitscolumn_i16_type();
i32type = fitscolumn_i32_type();
fitstable_add_read_column_struct(out, i16type, 1, off,
i16type, "backref_file", TRUE);
off += sizeof(int16_t);
fitstable_add_read_column_struct(out, i32type, 1, off,
i32type, "backref_index", TRUE);
}
//printf("Output table:\n");
//fitstable_print_columns(out);
if (fitstable_write_primary_header(out) ||
fitstable_write_header(out)) {
ERROR("Failed to write output file headers for \"%s\"", outfn);
exit(-1);
}
outtables[hp] = out;
}
if (backref) {
int16_t brfile;
int32_t brind;
if (!padrowdata) {
padrowdata = malloc(R + sizeof(int16_t) + sizeof(int32_t));
assert(padrowdata);
}
// convert to FITS endian
brfile = htons(i);
brind = htonl(r);
// add backref data to rowdata
memcpy(padrowdata, rowdata, R);
memcpy(padrowdata + R, &brfile, sizeof(int16_t));
memcpy(padrowdata + R + sizeof(int16_t), &brind, sizeof(int32_t));
rdata = padrowdata;
} else {
rdata = rowdata;
}
if (cols) {
if (fitstable_write_struct_noflip(outtables[hp], rdata)) {
ERROR("Failed to copy a row of data from input table \"%s\" to output healpix %i", infn, hp);
}
} else {
if (fitstable_write_row_data(outtables[hp], rdata)) {
ERROR("Failed to copy a row of data from input table \"%s\" to output healpix %i", infn, hp);
}
}
if (!hps)
break;
}
if (hps)
il_remove_all(hps);
}
buffered_read_free(rowbuf);
// wack... buffered_read_free() just frees its internal buffer,
// not the "rowbuf" struct itself.
// who wrote this crazy code? Oh, me of 5 years ago. Jerk.
free(rowbuf);
fitstable_close(intable);
il_free(hps);
if (tempfn) {
logverb("Removing temp file %s\n", tempfn);
if (unlink(tempfn)) {
SYSERROR("Failed to unlink() temp file \"%s\"", tempfn);
}
tempfn = NULL;
}
// fix headers so that the files are valid at this point.
for (ii=0; ii<NHP; ii++) {
if (!outtables[ii])
continue;
off_t offset = ftello(outtables[ii]->fid);
if (fitstable_fix_header(outtables[ii])) {
ERROR("Failed to fix header for healpix %i after reading input file \"%s\"", ii, originfn);
exit(-1);
}
fseeko(outtables[ii]->fid, offset, SEEK_SET);
}
if (padrowdata) {
free(padrowdata);
padrowdata = NULL;
}
}
for (i=0; i<NHP; i++) {
if (!outtables[i])
continue;
if (fitstable_fix_header(outtables[i]) ||
fitstable_fix_primary_header(outtables[i]) ||
fitstable_close(outtables[i])) {
ERROR("Failed to close output table for healpix %i", i);
exit(-1);
}
}
free(outtables);
sl_free2(infns);
sl_free2(cols);
free(mincaps);
free(maxcaps);
return 0;
}
int handle_request(FILE* fid) {
char buf[256];
char fn[256];
int set;
int get;
int getall;
int filenum;
int fieldnum;
int lastfieldnum;
int maxfields;
char* nextword;
//printf("Fileno %i:\n", fileno(fid));
if (!fgets(buf, 256, fid)) {
fprintf(stderr, "Error: failed to read a line of input.\n");
fflush(stderr);
fclose(fid);
return -1;
}
//printf("Got request %s\n", buf);
get = set = getall = 0;
if (is_word(buf, "get ", &nextword)) {
get = 1;
} else if (is_word(buf, "set ", &nextword)) {
set = 1;
} else if (is_word(buf, "getall ", &nextword)) {
getall = 1;
}
if (!(get || set || getall)) {
fprintf(stderr, "Error: malformed command.\n");
fclose(fid);
return -1;
}
if (get || set) {
if (sscanf(nextword, "%i %i", &filenum, &fieldnum) != 2) {
fprintf(stderr, "Error: malformed request: %s\n", buf);
fflush(stderr);
fclose(fid);
return -1;
}
} else if (getall) {
if (sscanf(nextword, "%i %i %i %i", &filenum, &fieldnum, &lastfieldnum, &maxfields) != 4) {
fprintf(stderr, "Error: malformed request: %s\n", buf);
fflush(stderr);
fclose(fid);
return -1;
}
if (lastfieldnum < fieldnum) {
fprintf(stderr, "Error: invalid \"getall\" request: lastfieldnum must be >= firstfieldnum.\n");
fflush(stderr);
fclose(fid);
return -1;
}
}
sprintf(fn, solvedfnpattern, filenum);
if (get) {
int val;
printf("Get %s [%i].\n", fn, fieldnum);
fflush(stdout);
val = solvedfile_get(fn, fieldnum);
if (val == -1) {
fclose(fid);
return -1;
} else {
fprintf(fid, "%s %i %i\n", (val ? "solved" : "unsolved"),
filenum, fieldnum);
fflush(fid);
}
return 0;
} else if (set) {
printf("Set %s [%i].\n", fn, fieldnum);
fflush(stdout);
if (solvedfile_set(fn, fieldnum)) {
fclose(fid);
return -1;
}
fprintf(fid, "ok\n");
fflush(fid);
return 0;
} else if (getall) {
int i;
il* list;
printf("Getall %s [%i : %i], max %i.\n", fn, fieldnum, lastfieldnum, maxfields);
fflush(stdout);
fprintf(fid, "unsolved %i", filenum);
list = solvedfile_getall(fn, fieldnum, lastfieldnum, maxfields);
if (list) {
for (i=0; i<il_size(list); i++)
fprintf(fid, " %i", il_get(list, i));
il_free(list);
}
fprintf(fid, "\n");
fflush(fid);
return 0;
}
return -1;
}
static PyObject* spherematch_match(PyObject* self, PyObject* args) {
size_t i, N;
long p1, p2;
kdtree_t *kd1, *kd2;
double rad;
struct dualtree_results dtresults;
PyArrayObject* inds;
npy_intp dims[2];
PyArrayObject* dists;
anbool notself;
anbool permute;
PyObject* rtn;
// So that ParseTuple("b") with a C "anbool" works
assert(sizeof(anbool) == sizeof(unsigned char));
if (!PyArg_ParseTuple(args, "lldbb", &p1, &p2, &rad, ¬self, &permute)) {
PyErr_SetString(PyExc_ValueError, "spherematch_c.match: need five args: two kdtree identifiers (ints), search radius (float), notself (boolean), permuted (boolean)");
return NULL;
}
//printf("Notself = %i\n", (int)notself);
// Nasty!
kd1 = (kdtree_t*)p1;
kd2 = (kdtree_t*)p2;
dtresults.inds1 = il_new(256);
dtresults.inds2 = il_new(256);
dtresults.dists = dl_new(256);
dualtree_rangesearch(kd1, kd2, 0.0, rad, notself, NULL,
callback_dualtree, &dtresults,
NULL, NULL);
N = il_size(dtresults.inds1);
dims[0] = N;
dims[1] = 2;
inds = (PyArrayObject*)PyArray_SimpleNew(2, dims, PyArray_INT);
dims[1] = 1;
dists = (PyArrayObject*)PyArray_SimpleNew(2, dims, PyArray_DOUBLE);
for (i=0; i<N; i++) {
int index;
int* iptr;
double* dptr;
iptr = PyArray_GETPTR2(inds, i, 0);
index = il_get(dtresults.inds1, i);
if (permute)
index = kdtree_permute(kd1, index);
*iptr = index;
iptr = PyArray_GETPTR2(inds, i, 1);
index = il_get(dtresults.inds2, i);
if (permute)
index = kdtree_permute(kd2, index);
*iptr = index;
dptr = PyArray_GETPTR2(dists, i, 0);
*dptr = dl_get(dtresults.dists, i);
}
il_free(dtresults.inds1);
il_free(dtresults.inds2);
dl_free(dtresults.dists);
rtn = Py_BuildValue("(OO)", inds, dists);
Py_DECREF(inds);
Py_DECREF(dists);
return rtn;
}
int wcs_rd2xy(const char* wcsfn, int wcsext,
const char* rdlsfn, const char* xylsfn,
const char* racol, const char* deccol,
anbool forcetan, anbool forcewcslib,
il* fields) {
xylist_t* xyls = NULL;
rdlist_t* rdls = NULL;
anwcs_t* wcs = NULL;
int i;
anbool alloced_fields = FALSE;
int rtn = -1;
// read WCS.
if (forcewcslib) {
wcs = anwcs_open_wcslib(wcsfn, wcsext);
} else if (forcetan) {
wcs = anwcs_open_tan(wcsfn, wcsext);
} else {
wcs = anwcs_open(wcsfn, wcsext);
}
if (!wcs) {
ERROR("Failed to read WCS file \"%s\", extension %i", wcsfn, wcsext);
return -1;
}
// read RDLS.
rdls = rdlist_open(rdlsfn);
if (!rdls) {
ERROR("Failed to read an RA,Dec list from file %s", rdlsfn);
goto bailout;
}
if (racol)
rdlist_set_raname(rdls, racol);
if (deccol)
rdlist_set_decname(rdls, deccol);
// write XYLS.
xyls = xylist_open_for_writing(xylsfn);
if (!xyls) {
ERROR("Failed to open file %s to write XYLS", xylsfn);
goto bailout;
}
if (xylist_write_primary_header(xyls)) {
ERROR("Failed to write header to XYLS file %s", xylsfn);
goto bailout;
}
if (!fields) {
alloced_fields = TRUE;
fields = il_new(16);
}
if (!il_size(fields)) {
// add all fields.
int NF = rdlist_n_fields(rdls);
for (i=1; i<=NF; i++)
il_append(fields, i);
}
for (i=0; i<il_size(fields); i++) {
int fieldnum = il_get(fields, i);
int j;
starxy_t xy;
rd_t rd;
if (!rdlist_read_field_num(rdls, fieldnum, &rd)) {
ERROR("Failed to read rdls file \"%s\" field %i", rdlsfn, fieldnum);
goto bailout;
}
starxy_alloc_data(&xy, rd_n(&rd), FALSE, FALSE);
if (xylist_write_header(xyls)) {
ERROR("Failed to write xyls field header");
goto bailout;
}
for (j=0; j<rd_n(&rd); j++) {
double x, y, ra, dec;
ra = rd_getra (&rd, j);
dec = rd_getdec(&rd, j);
if (anwcs_radec2pixelxy(wcs, ra, dec, &x, &y)) {
ERROR("Point RA,Dec = (%g,%g) projects to the opposite side of the sphere", ra, dec);
starxy_set(&xy, j, NAN, NAN);
continue;
}
starxy_set(&xy, j, x, y);
}
if (xylist_write_field(xyls, &xy)) {
ERROR("Failed to write xyls field");
goto bailout;
}
if (xylist_fix_header(xyls)) {
ERROR("Failed to fix xyls field header");
goto bailout;
}
xylist_next_field(xyls);
starxy_free_data(&xy);
rd_free_data(&rd);
}
if (xylist_fix_primary_header(xyls) ||
xylist_close(xyls)) {
ERROR("Failed to fix header of XYLS file");
goto bailout;
}
xyls = NULL;
if (rdlist_close(rdls)) {
ERROR("Failed to close RDLS file");
goto bailout;
}
rdls = NULL;
rtn = 0;
bailout:
if (alloced_fields)
il_free(fields);
if (rdls)
rdlist_close(rdls);
if (xyls)
xylist_close(xyls);
if (wcs)
anwcs_free(wcs);
return rtn;
}
int wcs_xy2rd(const char* wcsfn, int ext,
const char* xylsfn, const char* rdlsfn,
const char* xcol, const char* ycol,
int forcetan,
int forcewcslib,
il* fields) {
rdlist_t* rdls = NULL;
xylist_t* xyls = NULL;
anwcs_t* wcs = NULL;
int i;
int rtn = -1;
anbool alloced_fields = FALSE;
// read WCS.
if (forcewcslib) {
wcs = anwcs_open_wcslib(wcsfn, ext);
} else if (forcetan) {
wcs = anwcs_open_tan(wcsfn, ext);
} else {
wcs = anwcs_open(wcsfn, ext);
}
if (!wcs) {
ERROR("Failed to read WCS file \"%s\", extension %i", wcsfn, ext);
return -1;
}
// read XYLS.
xyls = xylist_open(xylsfn);
if (!xyls) {
ERROR("Failed to read an xylist from file %s", xylsfn);
goto bailout;
}
xylist_set_include_flux(xyls, FALSE);
xylist_set_include_background(xyls, FALSE);
if (xcol)
xylist_set_xname(xyls, xcol);
if (ycol)
xylist_set_yname(xyls, ycol);
// write RDLS.
rdls = rdlist_open_for_writing(rdlsfn);
if (!rdls) {
ERROR("Failed to open file %s to write RDLS.\n", rdlsfn);
goto bailout;
}
if (rdlist_write_primary_header(rdls)) {
ERROR("Failed to write header to RDLS file %s.\n", rdlsfn);
goto bailout;
}
if (!fields) {
alloced_fields = TRUE;
fields = il_new(16);
}
if (!il_size(fields)) {
// add all fields.
int NF = xylist_n_fields(xyls);
for (i=1; i<=NF; i++)
il_append(fields, i);
}
logverb("Processing %zu extensions...\n", il_size(fields));
for (i=0; i<il_size(fields); i++) {
int fieldind = il_get(fields, i);
starxy_t xy;
rd_t rd;
int j;
if (!xylist_read_field_num(xyls, fieldind, &xy)) {
ERROR("Failed to read xyls file %s, field %i", xylsfn, fieldind);
goto bailout;
}
if (rdlist_write_header(rdls)) {
ERROR("Failed to write rdls field header to %s", rdlsfn);
goto bailout;
}
rd_alloc_data(&rd, starxy_n(&xy));
for (j=0; j<starxy_n(&xy); j++) {
double x, y, ra, dec;
x = starxy_getx(&xy, j);
y = starxy_gety(&xy, j);
anwcs_pixelxy2radec(wcs, x, y, &ra, &dec);
rd_setra (&rd, j, ra);
rd_setdec(&rd, j, dec);
}
if (rdlist_write_field(rdls, &rd)) {
ERROR("Failed to write rdls field to %s", rdlsfn);
goto bailout;
}
rd_free_data(&rd);
starxy_free_data(&xy);
if (rdlist_fix_header(rdls)) {
ERROR("Failed to fix rdls field header for %s", rdlsfn);
goto bailout;
}
rdlist_next_field(rdls);
}
if (rdlist_fix_primary_header(rdls) ||
rdlist_close(rdls)) {
ERROR("Failed to fix header of RDLS file %s", rdlsfn);
goto bailout;
}
rdls = NULL;
if (xylist_close(xyls)) {
ERROR("Failed to close XYLS file %s", xylsfn);
goto bailout;
}
xyls = NULL;
rtn = 0;
bailout:
if (alloced_fields)
il_free(fields);
if (rdls)
rdlist_close(rdls);
if (xyls)
xylist_close(xyls);
if (wcs)
anwcs_free(wcs);
return rtn;
}
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 test_big_list(CuTest* tc) {
// Test size_t sizes and indices of bl's.
// Test ptrdiff_t as -1 or index
CuAssertTrue(tc, -1 == BL_NOT_FOUND);
CuAssertTrue(tc, BL_NOT_FOUND < 0);
CuAssertTrue(tc, sizeof(size_t) == sizeof(ptrdiff_t));
// Create a fake list so we don't have to allocate 16 GB of list to test.
int blocksize = 1048576;
il* big = il_new(blocksize);
// that's 1<<20 ~ 1e6 elements per block
// now need 1<<12 ~ 4096 blocks to overflow a 32-bit int
int i;
int N = 4096;
bl_node* nodes = calloc(N, sizeof(bl_node));
for (i=1; i<N; i++) {
nodes[i-1].next = nodes+i;
nodes[i-1].N = blocksize;
}
nodes[N-1].N = blocksize;
big->head = nodes;
big->tail = nodes + (N-1);
big->N = (size_t)blocksize * (size_t)N;
bl_print_structure(big);
printf("N %zu\n", il_size(big));
printf("check: %s\n", (bl_check_consistency(big) ? "bad" : "ok"));
int* p = il_append(big, 42);
printf("appended: %i\n", *p);
CuAssertIntEquals(tc, 42, *p);
CuAssertTrue(tc, 4294967297L == il_size(big));
size_t index = 4294967296L;
int v = il_get(big, index);
CuAssertIntEquals(tc, 42, v);
big->last_access = NULL;
big->last_access_n = 0;
v = il_get(big, index);
CuAssertIntEquals(tc, 42, v);
for (i=0; i<blocksize*2; i++) {
il_push(big, i);
}
il* split = il_new(1024);
bl_split(big, split, (size_t)blocksize * (size_t)N);
printf("split: %zu, %zu\n", il_size(big), il_size(split));
CuAssertIntEquals(tc, 42, il_get(split, 0));
CuAssertIntEquals(tc, 3, il_get(split, 4));
il_append_list(big, split);
CuAssertTrue(tc, 4297064449L == il_size(big));
int* arr = calloc(1024, sizeof(int));
bl_copy(big, (size_t)blocksize * (size_t)N, 1024, arr);
CuAssertIntEquals(tc, 42, arr[0]);
CuAssertIntEquals(tc, 3, arr[4]);
}
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;
}
int main(int argc, char** args) {
int argchar;
char* progname = args[0];
char** inputfiles = NULL;
int ninputfiles = 0;
int i;
char* outfile = NULL;
int N;
anbool* solved;
int noerr = 0;
while ((argchar = getopt (argc, args, OPTIONS)) != -1) {
switch (argchar) {
case 'o':
outfile = optarg;
break;
case 'e':
noerr = 1;
break;
case 'h':
default:
printHelp(progname);
exit(-1);
}
}
if (optind < argc) {
ninputfiles = argc - optind;
inputfiles = args + optind;
} else {
printHelp(progname);
exit(-1);
}
N = 0;
for (i=0; i<ninputfiles; i++) {
int n = solvedfile_getsize(inputfiles[i]);
if (n == -1) {
if (!noerr) {
fprintf(stderr, "Failed to get size of input file %s.\n", inputfiles[i]);
exit(-1);
}
}
if (n > N) N = n;
}
solved = calloc(N, sizeof(anbool));
for (i=0; i<ninputfiles; i++) {
il* slist;
int j;
slist = solvedfile_getall_solved(inputfiles[i], 1, N, 0);
for (j=0; j<il_size(slist); j++)
solved[il_get(slist, j) - 1] = TRUE;
il_free(slist);
}
if (solvedfile_set_file(outfile, solved, N)) {
fprintf(stderr, "Failed to set values in output file.\n");
exit(-1);
}
free(solved);
return 0;
}
static void plot_constellations(cairo_t* cairo, plot_args_t* pargs, plotann_t* ann) {
int i, N;
double ra,dec,radius;
double xyzf[3];
// Find the field center and radius
anwcs_get_radec_center_and_radius(pargs->wcs, &ra, &dec, &radius);
logverb("Plotting constellations: field center %g,%g, radius %g\n",
ra, dec, radius);
radecdeg2xyzarr(ra, dec, xyzf);
radius = deg2dist(radius);
N = constellations_n();
for (i=0; i<N; i++) {
int j, k;
// Find the approximate center and radius of this constellation
// and see if it overlaps with the field.
il* stars = constellations_get_unique_stars(i);
double xyzj[3];
double xyzc[3];
double maxr2 = 0;
dl* rds;
xyzc[0] = xyzc[1] = xyzc[2] = 0.0;
xyzj[0] = xyzj[1] = xyzj[2] = 0.0;
for (j=0; j<il_size(stars); j++) {
constellations_get_star_radec(il_get(stars, j), &ra, &dec);
radecdeg2xyzarr(ra, dec, xyzj);
for (k=0; k<3; k++)
xyzc[k] += xyzj[k];
}
normalize_3(xyzc);
for (j=0; j<il_size(stars); j++) {
constellations_get_star_radec(il_get(stars, j), &ra, &dec);
maxr2 = MAX(maxr2, distsq(xyzc, xyzj, 3));
}
il_free(stars);
maxr2 = square(sqrt(maxr2) + radius);
if (distsq(xyzf, xyzc, 3) > maxr2) {
xyzarr2radecdeg(xyzc, &ra, &dec);
logverb("Constellation %s (center %g,%g, radius %g) out of bounds\n",
constellations_get_shortname(i), ra, dec,
dist2deg(sqrt(maxr2) - radius));
logverb(" dist from field center to constellation center is %g deg\n",
distsq2deg(distsq(xyzf, xyzc, 3)));
logverb(" max radius: %g\n", distsq2deg(maxr2));
continue;
}
if (ann->constellation_pastel) {
float r,g,b;
xyzarr2radecdeg(xyzc, &ra, &dec);
color_for_radec(ra, dec, &r,&g,&b);
plotstuff_set_rgba2(pargs, r,g,b, 0.8);
plotstuff_builtin_apply(cairo, pargs);
}
// Phew, plot it.
if (ann->constellation_lines) {
rds = constellations_get_lines_radec(i);
logverb("Constellation %s: plotting %zu lines\n",
constellations_get_shortname(i), dl_size(rds)/4);
for (j=0; j<dl_size(rds)/4; j++) {
double r1,d1,r2,d2;
double r3,d3,r4,d4;
double off = ann->constellation_lines_offset;
r1 = dl_get(rds, j*4+0);
d1 = dl_get(rds, j*4+1);
r2 = dl_get(rds, j*4+2);
d2 = dl_get(rds, j*4+3);
if (anwcs_find_discontinuity(pargs->wcs, r1, d1, r2, d2,
&r3, &d3, &r4, &d4)) {
logverb("Discontinuous: %g,%g -- %g,%g\n", r1, d1, r2, d2);
logverb(" %g,%g == %g,%g\n", r3,d3, r4,d4);
plot_offset_line_rd(NULL, pargs, r1,d1,r3,d3, off, 0.);
plot_offset_line_rd(NULL, pargs, r4,d4,r2,d2, 0., off);
} else {
plot_offset_line_rd(NULL, pargs, r1,d1,r2,d2, off, off);
}
plotstuff_stroke(pargs);
}
dl_free(rds);
}
if (ann->constellation_labels ||
ann->constellation_markers) {
// Put the label at the center of mass of the stars that
// are in-bounds
int Nin = 0;
stars = constellations_get_unique_stars(i);
xyzc[0] = xyzc[1] = xyzc[2] = 0.0;
logverb("Labeling %s: %zu stars\n", constellations_get_shortname(i),
il_size(stars));
for (j=0; j<il_size(stars); j++) {
constellations_get_star_radec(il_get(stars, j), &ra, &dec);
if (!anwcs_radec_is_inside_image(pargs->wcs, ra, dec))
continue;
if (ann->constellation_markers)
plotstuff_marker_radec(pargs, ra, dec);
radecdeg2xyzarr(ra, dec, xyzj);
for (k=0; k<3; k++)
xyzc[k] += xyzj[k];
Nin++;
}
logverb(" %i stars in-bounds\n", Nin);
if (ann->constellation_labels && Nin) {
const char* label;
normalize_3(xyzc);
xyzarr2radecdeg(xyzc, &ra, &dec);
if (ann->constellation_labels_long)
label = constellations_get_longname(i);
else
label = constellations_get_shortname(i);
plotstuff_text_radec(pargs, ra, dec, label);
}
il_free(stars);
}
}
}
static int write_to_file(startree_t* s, const char* fn, anbool flipped,
FILE* fid) {
bl* chunks;
il* wordsizes = NULL;
int i;
kdtree_fits_t* io = NULL;
// just haven't bothered...
assert(!(flipped && fid));
if (fn) {
io = kdtree_fits_open_for_writing(fn);
if (!io) {
ERROR("Failed to open file \"%s\" for writing kdtree", fn);
return -1;
}
}
if (flipped) {
if (kdtree_fits_write_tree_flipped(io, s->tree, s->header)) {
ERROR("Failed to write (flipped) kdtree to file \"%s\"", fn);
return -1;
}
} else {
if (fid) {
if (kdtree_fits_append_tree_to(s->tree, s->header, fid)) {
ERROR("Failed to write star kdtree");
return -1;
}
} else {
if (kdtree_fits_write_tree(io, s->tree, s->header)) {
ERROR("Failed to write kdtree to file \"%s\"", fn);
return -1;
}
}
}
if (flipped)
wordsizes = il_new(4);
chunks = get_chunks(s, wordsizes);
for (i=0; i<bl_size(chunks); i++) {
fitsbin_chunk_t* chunk = bl_access(chunks, i);
if (!chunk->data)
continue;
if (flipped)
kdtree_fits_write_chunk_flipped(io, chunk, il_get(wordsizes, i));
else {
if (fid) {
kdtree_fits_write_chunk_to(chunk, fid);
} else {
kdtree_fits_write_chunk(io, chunk);
}
}
fitsbin_chunk_clean(chunk);
}
bl_free(chunks);
if (flipped)
il_free(wordsizes);
if (io)
kdtree_fits_io_close(io);
return 0;
}
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;
}
int hpquads(startree_t* starkd,
codefile_t* codes,
quadfile_t* quads,
int Nside,
double scale_min_arcmin,
double scale_max_arcmin,
int dimquads,
int passes,
int Nreuses,
int Nloosen,
int id,
anbool scanoccupied,
void* sort_data,
int (*sort_func)(const void*, const void*),
int sort_size,
char** args, int argc) {
hpquads_t myhpquads;
hpquads_t* me = &myhpquads;
int i;
int pass;
anbool circle = TRUE;
double radius2;
il* hptotry;
int Nhptotry = 0;
int nquads;
double hprad;
double quadscale;
int skhp, sknside;
qfits_header* qhdr;
qfits_header* chdr;
int N;
int dimcodes;
int quadsize;
int NHP;
memset(me, 0, sizeof(hpquads_t));
if (Nside > HP_MAX_INT_NSIDE) {
ERROR("Error: maximum healpix Nside = %i", HP_MAX_INT_NSIDE);
return -1;
}
if (Nreuses > 255) {
ERROR("Error, reuse (-r) must be less than 256");
return -1;
}
me->Nside = Nside;
me->dimquads = dimquads;
NHP = 12 * Nside * Nside;
dimcodes = dimquad2dimcode(dimquads);
quadsize = sizeof(unsigned int) * dimquads;
logmsg("Nside=%i. Nside^2=%i. Number of healpixes=%i. Healpix side length ~ %g arcmin.\n",
me->Nside, me->Nside*me->Nside, NHP, healpix_side_length_arcmin(me->Nside));
me->sort_data = sort_data;
me->sort_func = sort_func;
me->sort_size = sort_size;
tic();
me->starkd = starkd;
N = startree_N(me->starkd);
logmsg("Star tree contains %i objects.\n", N);
// get the "HEALPIX" header from the skdt...
skhp = qfits_header_getint(startree_header(me->starkd), "HEALPIX", -1);
if (skhp == -1) {
if (!qfits_header_getboolean(startree_header(me->starkd), "ALLSKY", FALSE)) {
logmsg("Warning: skdt does not contain \"HEALPIX\" header. Code and quad files will not contain this header either.\n");
}
}
// likewise "HPNSIDE"
sknside = qfits_header_getint(startree_header(me->starkd), "HPNSIDE", 1);
if (sknside && Nside % sknside) {
logerr("Error: Nside (-n) must be a multiple of the star kdtree healpixelisation: %i\n", sknside);
return -1;
}
if (!scanoccupied && (N*(skhp == -1 ? 1 : sknside*sknside*12) < NHP)) {
logmsg("\n\n");
logmsg("NOTE, your star kdtree is sparse (has only a fraction of the stars expected)\n");
logmsg(" so you probably will get much faster results by setting the \"-E\" command-line\n");
logmsg(" flag.\n");
logmsg("\n\n");
}
quads->dimquads = me->dimquads;
codes->dimcodes = dimcodes;
quads->healpix = skhp;
codes->healpix = skhp;
quads->hpnside = sknside;
codes->hpnside = sknside;
if (id) {
quads->indexid = id;
codes->indexid = id;
}
qhdr = quadfile_get_header(quads);
chdr = codefile_get_header(codes);
add_headers(qhdr, args, argc, startree_header(me->starkd), circle, passes);
add_headers(chdr, args, argc, startree_header(me->starkd), circle, passes);
if (quadfile_write_header(quads)) {
ERROR("Couldn't write headers to quad file");
return -1;
}
if (codefile_write_header(codes)) {
ERROR("Couldn't write headers to code file");
return -1;
}
quads->numstars = codes->numstars = N;
me->quad_dist2_upper = arcmin2distsq(scale_max_arcmin);
me->quad_dist2_lower = arcmin2distsq(scale_min_arcmin);
codes->index_scale_upper = quads->index_scale_upper = distsq2rad(me->quad_dist2_upper);
codes->index_scale_lower = quads->index_scale_lower = distsq2rad(me->quad_dist2_lower);
me->nuses = calloc(N, sizeof(unsigned char));
// hprad = sqrt(2) * (healpix side length / 2.)
hprad = arcmin2dist(healpix_side_length_arcmin(Nside)) * M_SQRT1_2;
quadscale = 0.5 * sqrt(me->quad_dist2_upper);
// 1.01 for a bit of safety. we'll look at a few extra stars.
radius2 = square(1.01 * (hprad + quadscale));
me->radius2 = radius2;
logmsg("Healpix radius %g arcsec, quad scale %g arcsec, total %g arcsec\n",
distsq2arcsec(hprad*hprad),
distsq2arcsec(quadscale*quadscale),
distsq2arcsec(radius2));
hptotry = il_new(1024);
if (scanoccupied) {
logmsg("Scanning %i input stars...\n", N);
for (i=0; i<N; i++) {
double xyz[3];
int j;
if (startree_get(me->starkd, i, xyz)) {
ERROR("Failed to get star %i", i);
return -1;
}
j = xyzarrtohealpix(xyz, Nside);
il_insert_unique_ascending(hptotry, j);
if (log_get_level() > LOG_VERB) {
double ra,dec;
if (startree_get_radec(me->starkd, i, &ra, &dec)) {
ERROR("Failed to get RA,Dec for star %i\n", i);
return -1;
}
logdebug("star %i: RA,Dec %g,%g; xyz %g,%g,%g; hp %i\n",
i, ra, dec, xyz[0], xyz[1], xyz[2], j);
}
}
logmsg("Will check %zu healpixes.\n", il_size(hptotry));
if (log_get_level() > LOG_VERB) {
logdebug("Checking healpixes: [ ");
for (i=0; i<il_size(hptotry); i++)
logdebug("%i ", il_get(hptotry, i));
logdebug("]\n");
}
} else {
if (skhp == -1) {
// Try all healpixes.
il_free(hptotry);
hptotry = NULL;
Nhptotry = NHP;
} else {
// The star kdtree may itself be healpixed
int starhp, starx, stary;
// In that case, the healpixes we are interested in form a rectangle
// within a big healpix. These are the coords (in [0, Nside)) of
// that rectangle.
int x0, x1, y0, y1;
int x, y;
healpix_decompose_xy(skhp, &starhp, &starx, &stary, sknside);
x0 = starx * (Nside / sknside);
x1 = (starx+1) * (Nside / sknside);
y0 = stary * (Nside / sknside);
y1 = (stary+1) * (Nside / sknside);
for (y=y0; y<y1; y++) {
for (x=x0; x<x1; x++) {
int j = healpix_compose_xy(starhp, x, y, Nside);
il_append(hptotry, j);
}
}
assert(il_size(hptotry) == (Nside/sknside) * (Nside/sknside));
}
}
if (hptotry)
Nhptotry = il_size(hptotry);
me->quadlist = bl_new(65536, quadsize);
if (Nloosen)
me->retryhps = il_new(1024);
for (pass=0; pass<passes; pass++) {
char key[64];
int nthispass;
logmsg("Pass %i of %i.\n", pass+1, passes);
logmsg("Trying %i healpixes.\n", Nhptotry);
nthispass = build_quads(me, Nhptotry, hptotry, Nreuses);
logmsg("Made %i quads (out of %i healpixes) this pass.\n", nthispass, Nhptotry);
logmsg("Made %i quads so far.\n", (me->bigquadlist ? bt_size(me->bigquadlist) : 0) + (int)bl_size(me->quadlist));
sprintf(key, "PASS%i", pass+1);
fits_header_mod_int(chdr, key, nthispass, "quads created in this pass");
fits_header_mod_int(qhdr, key, nthispass, "quads created in this pass");
logmsg("Merging quads...\n");
if (!me->bigquadlist)
me->bigquadlist = bt_new(quadsize, 256);
for (i=0; i<bl_size(me->quadlist); i++) {
void* q = bl_access(me->quadlist, i);
bt_insert2(me->bigquadlist, q, FALSE, compare_quads, &me->dimquads);
}
bl_remove_all(me->quadlist);
}
il_free(hptotry);
hptotry = NULL;
if (Nloosen) {
int R;
for (R=Nreuses+1; R<=Nloosen; R++) {
il* trylist;
int nthispass;
logmsg("Loosening reuse maximum to %i...\n", R);
logmsg("Trying %zu healpixes.\n", il_size(me->retryhps));
if (!il_size(me->retryhps))
break;
trylist = me->retryhps;
me->retryhps = il_new(1024);
nthispass = build_quads(me, il_size(trylist), trylist, R);
logmsg("Made %i quads (out of %zu healpixes) this pass.\n", nthispass, il_size(trylist));
il_free(trylist);
for (i=0; i<bl_size(me->quadlist); i++) {
void* q = bl_access(me->quadlist, i);
bt_insert2(me->bigquadlist, q, FALSE, compare_quads, &me->dimquads);
}
bl_remove_all(me->quadlist);
}
}
if (me->retryhps)
il_free(me->retryhps);
kdtree_free_query(me->res);
me->res = NULL;
me->inds = NULL;
me->stars = NULL;
free(me->nuses);
me->nuses = NULL;
logmsg("Writing quads...\n");
// add the quads from the big-quadlist
nquads = bt_size(me->bigquadlist);
for (i=0; i<nquads; i++) {
unsigned int* q = bt_access(me->bigquadlist, i);
quad_write(codes, quads, q, me->starkd, me->dimquads, dimcodes);
}
// add the quads that were made during the final round.
for (i=0; i<bl_size(me->quadlist); i++) {
unsigned int* q = bl_access(me->quadlist, i);
quad_write(codes, quads, q, me->starkd, me->dimquads, dimcodes);
}
// fix output file headers.
if (quadfile_fix_header(quads)) {
ERROR("Failed to fix quadfile headers");
return -1;
}
if (codefile_fix_header(codes)) {
ERROR("Failed to fix codefile headers");
return -1;
}
bl_free(me->quadlist);
bt_free(me->bigquadlist);
toc();
logmsg("Done.\n");
return 0;
}
int plot_healpix_plot(const char* command,
cairo_t* cairo, plot_args_t* pargs, void* baton) {
plothealpix_t* args = (plothealpix_t*)baton;
double ra,dec,rad;
il* hps;
int i;
double hpstep;
int minx[12], maxx[12], miny[12], maxy[12];
plotstuff_builtin_apply(cairo, pargs);
if (plotstuff_get_radec_center_and_radius(pargs, &ra, &dec, &rad)) {
ERROR("Failed to get RA,Dec center and radius");
return -1;
}
hps = healpix_rangesearch_radec(ra, dec, rad, args->nside, NULL);
logmsg("Found %zu healpixes in range.\n", il_size(hps));
hpstep = args->nside * args->stepsize * plotstuff_pixel_scale(pargs) / 60.0 / healpix_side_length_arcmin(args->nside);
hpstep = MIN(1, hpstep);
logmsg("Taking steps of %g in healpix space\n", hpstep);
// For each of the 12 top-level healpixes, find the range of healpixes covered by this image.
for (i=0; i<12; i++) {
maxx[i] = maxy[i] = -1;
minx[i] = miny[i] = args->nside+1;
}
for (i=0; i<il_size(hps); i++) {
int hp = il_get(hps, i);
int hpx, hpy;
int bighp;
healpix_decompose_xy(hp, &bighp, &hpx, &hpy, args->nside);
logverb(" hp %i: bighp %i, x,y (%i,%i)\n", i, bighp, hpx, hpy);
minx[bighp] = MIN(minx[bighp], hpx);
maxx[bighp] = MAX(maxx[bighp], hpx);
miny[bighp] = MIN(miny[bighp], hpy);
maxy[bighp] = MAX(maxy[bighp], hpy);
}
il_free(hps);
for (i=0; i<12; i++) {
int hx,hy;
int hp;
double d, frac;
double x,y;
if (maxx[i] == -1)
continue;
logverb("Big healpix %i: x range [%i, %i], y range [%i, %i]\n",
i, minx[i], maxx[i], miny[i], maxy[i]);
for (hy = miny[i]; hy <= maxy[i]; hy++) {
logverb(" y=%i\n", hy);
for (d=minx[i]; d<=maxx[i]; d+=hpstep) {
hx = floor(d);
frac = d - hx;
hp = healpix_compose_xy(i, hx, hy, args->nside);
healpix_to_radecdeg(hp, args->nside, frac, 0.0, &ra, &dec);
if (!plotstuff_radec2xy(pargs, ra, dec, &x, &y))
continue;
if (d == minx[i])
cairo_move_to(pargs->cairo, x, y);
else
cairo_line_to(pargs->cairo, x, y);
}
cairo_stroke(pargs->cairo);
}
for (hx = minx[i]; hx <= maxx[i]; hx++) {
for (d=miny[i]; d<=maxy[i]; d+=hpstep) {
hy = floor(d);
frac = d - hy;
hp = healpix_compose_xy(i, hx, hy, args->nside);
healpix_to_radecdeg(hp, args->nside, 0.0, frac, &ra, &dec);
if (!plotstuff_radec2xy(pargs, ra, dec, &x, &y))
continue;
if (d == miny[i])
cairo_move_to(pargs->cairo, x, y);
else
cairo_line_to(pargs->cairo, x, y);
}
cairo_stroke(pargs->cairo);
}
}
return 0;
}
int main(int argc, char *argv[]) {
int argchar;
char* infn = NULL;
char* outfn = NULL;
anbool tostdout = FALSE;
FILE* fin = NULL;
FILE* fout = NULL;
il* exts;
int i;
char* progname = argv[0];
anbool inblocks = FALSE;
anbool inmegs = FALSE;
int allexts = 0;
int Next = -1;
anbool dataonly = FALSE;
anbool headeronly = FALSE;
anqfits_t* anq = NULL;
int loglvl = LOG_MSG;
exts = il_new(16);
while ((argchar = getopt (argc, argv, OPTIONS)) != -1)
switch (argchar) {
case 'v':
loglvl++;
break;
case 'D':
dataonly = TRUE;
break;
case 'H':
headeronly = TRUE;
break;
case 'a':
allexts = 1;
break;
case 'b':
inblocks = TRUE;
break;
case 'M':
inmegs = TRUE;
break;
case 'e':
il_append(exts, atoi(optarg));
break;
case 'i':
infn = optarg;
break;
case 'o':
outfn = optarg;
break;
case '?':
case 'h':
printHelp(progname);
return 0;
default:
return -1;
}
if (headeronly && dataonly) {
fprintf(stderr, "Can't write data blocks only AND header blocks only!\n");
exit(-1);
}
if (inblocks && inmegs) {
fprintf(stderr, "Can't write sizes in FITS blocks and megabytes.\n");
exit(-1);
}
fits_use_error_system();
log_init(loglvl);
log_to(stderr);
errors_log_to(stderr);
if (infn) {
anq = anqfits_open(infn);
if (!anq) {
ERROR("Failed to open input file \"%s\"", infn);
exit(-1);
}
Next = anqfits_n_ext(anq);
fprintf(stderr, "File %s contains %i FITS extensions.\n", infn, Next);
}
if (infn && !outfn) {
for (i=0; i<Next; i++) {
off_t hdrstart, hdrlen, datastart, datalen;
hdrstart = anqfits_header_start(anq, i);
hdrlen = anqfits_header_size(anq, i);
datastart = anqfits_data_start(anq, i);
datalen = anqfits_data_size(anq, i);
if (inblocks) {
off_t block = (off_t)FITS_BLOCK_SIZE;
fprintf(stderr, "Extension %i : header start %zu , length %zu ; data start %zu , length %zu blocks.\n",
i, (size_t)(hdrstart / block), (size_t)(hdrlen / block), (size_t)(datastart / block), (size_t)(datalen / block));
} else if (inmegs) {
off_t meg = 1024*1024;
fprintf(stderr, "Extension %i : header start %zu , length %zu ; data start %zu , length %zu megabytes.\n",
i, (size_t)(hdrstart/meg), (size_t)(hdrlen/meg), (size_t)(datastart/meg), (size_t)(datalen/meg));
} else {
fprintf(stderr, "Extension %i : header start %zu , length %zu ; data start %zu , length %zu .\n",
i, (size_t)hdrstart, (size_t)hdrlen, (size_t)datastart, (size_t)datalen);
}
}
anqfits_close(anq);
exit(0);
}
if (!infn || !outfn || !(il_size(exts) || allexts)) {
printHelp(progname);
exit(-1);
}
if (!strcmp(outfn, "-")) {
tostdout = TRUE;
if (allexts) {
fprintf(stderr, "Specify all extensions (-a) and outputting to stdout (-o -) doesn't make much sense...\n");
exit(-1);
}
}
if (infn) {
fin = fopen(infn, "rb");
if (!fin) {
fprintf(stderr, "Failed to open input file %s: %s\n", infn, strerror(errno));
exit(-1);
}
}
if (tostdout)
fout = stdout;
else {
if (allexts)
for (i=0; i<Next; i++)
il_append(exts, i);
else {
// open the (single) output file.
fout = fopen(outfn, "wb");
if (!fout) {
fprintf(stderr, "Failed to open output file %s: %s\n", outfn, strerror(errno));
exit(-1);
}
}
}
for (i=0; i<il_size(exts); i++) {
off_t hdrstart, hdrlen, datastart, datalen;
int ext = il_get(exts, i);
if (allexts) {
char fn[256];
snprintf(fn, sizeof(fn), outfn, ext);
fout = fopen(fn, "wb");
if (!fout) {
fprintf(stderr, "Failed to open output file %s: %s\n", fn, strerror(errno));
exit(-1);
}
}
hdrstart = anqfits_header_start(anq, ext);
hdrlen = anqfits_header_size(anq, ext);
datastart = anqfits_data_start(anq, ext);
datalen = anqfits_data_size(anq, ext);
if (inblocks) {
off_t block = (off_t)FITS_BLOCK_SIZE;
fprintf(stderr, "Writing extension %i : header start %zu , length %zu ; data start %zu , length %zu blocks.\n",
ext, (size_t)(hdrstart / block), (size_t)(hdrlen / block), (size_t)(datastart / block), (size_t)(datalen / block));
} else if (inmegs) {
off_t meg = 1024*1024;
fprintf(stderr, "Writing extension %i : header start %zu , length %zu ; data start %zu , length %zu megabytes.\n",
ext, (size_t)(hdrstart/meg), (size_t)(hdrlen/meg), (size_t)(datastart/meg), (size_t)(datalen/meg));
} else {
fprintf(stderr, "Writing extension %i : header start %zu , length %zu ; data start %zu , length %zu .\n",
ext, (size_t)hdrstart, (size_t)hdrlen, (size_t)datastart, (size_t)datalen);
}
if (hdrlen && !dataonly) {
if (pipe_file_offset(fin, hdrstart, hdrlen, fout)) {
fprintf(stderr, "Failed to write header for extension %i: %s\n", ext, strerror(errno));
exit(-1);
}
}
if (datalen && !headeronly) {
if (pipe_file_offset(fin, datastart, datalen, fout)) {
fprintf(stderr, "Failed to write data for extension %i: %s\n", ext, strerror(errno));
exit(-1);
}
}
if (allexts)
if (fclose(fout)) {
fprintf(stderr, "Failed to close output file: %s\n", strerror(errno));
exit(-1);
}
}
fclose(fin);
if (!allexts && !tostdout)
fclose(fout);
il_free(exts);
anqfits_close(anq);
return 0;
}
static void dualtree_rs_recurse(kdtree_t* xtree, kdtree_t* ytree,
il* xnodes, il* xleaves,
bl* xnodebbs, bl* xleafbbs,
int ynode,
ttype* ybb,
double maxd2,
rangesearch_callback cb, void* baton) {
int leafmarker;
il* childnodes;
int i, N;
ttype oldbbval;
ttype splitval;
uint8_t splitdim;
// if the query node is a leaf...
if (KD_IS_LEAF(ytree, ynode)) {
// ... then run the result function on each x node
/*
if (callbacks->start_results)
callbacks->start_results(callbacks->start_extra, ytree, ynode);
*/
if (cb) {
// non-leaf nodes
N = il_size(xnodes);
for (i=0; i<N; i++)
dtrs_nodes(xtree, ytree, il_get(xnodes, i), ynode, maxd2, cb, baton);
// leaf nodes
N = il_size(xleaves);
for (i=0; i<N; i++)
dtrs_nodes(xtree, ytree, il_get(xleaves, i), ynode, maxd2, cb, baton);
}
/*
if (callbacks->end_results)
callbacks->end_results(callbacks->end_extra, ytree, ynode);
*/
return;
}
// if there are search leaves but no search nodes, run the result
// function on each leaf. (Note that the query node is not a leaf!)
if (!il_size(xnodes)) {
/*
result_function result = callbacks->result;
void* result_extra = callbacks->result_extra;
if (callbacks->start_results)
callbacks->start_results(callbacks->start_extra, ytree, ynode);
*/
// leaf nodes
if (result) {
N = il_size(xleaves);
for (i=0; i<N; i++)
dtrs_nodes(xtree, ytree, il_get(xleaves, i), ynode, maxd2, cb, baton);
//result(result_extra, xtree, il_get(leaves, i), ytree, ynode);
}
/*
if (callbacks->end_results)
callbacks->end_results(callbacks->end_extra, ytree, ynode);
*/
return;
}
leafmarker = il_size(leaves);
childnodes = il_new(256);
#define BBLO(bb, d) ((bb)[2*(d)])
#define BBHI(bb, d) ((bb)[(2*(d))+1])
N = il_size(xnodes);
for (i=0; i<N; i++) {
int child1, child2;
int xnode = il_get(xnodes, i);
ttype* xbb = bl_access(xnodebbs, i);
ttype* leftbb;
ttype* rightbb;
/*
node-node range...
if (!decision(decision_extra, xtree, xnode, ytree, ynode))
continue;
*/
split_dim_and_value(xtree, xnode, &splitdim, &splitval);
child1 = KD_CHILD_LEFT(xnode);
if (KD_IS_LEAF(xtree, child1)) {
il_append(xleaves, child1);
il_append(xleaves, child2);
leftbb = bl_append(xleafbbs, xbb);
rightbb = bl_append(xleafbbs, xbb);
} else {
il_append(childnodes, child1);
il_append(childnodes, child2);
leftbb = bl_append(xnodebbs, xbb);
rightbb = bl_append(xnodebbs, xbb);
}
BBHI(leftbb, splitdim) = splitval;
BBLO(rightbb, splitdim) = splitval;
}
printf("dualtree: start left child of y node %i: %i\n", ynode, KD_CHILD_LEFT(ynode));
// recurse on the Y children!
split_dim_and_value(ytree, ynode, &splitdim, &splitval);
// update y bb for the left child: max(splitdim) = splitval
oldbbval = BBHI(ybb, splitdim);
BBHI(ybb, splitdim) = splitval;
dualtree_recurse(xtree, ytree, childnodes, leaves,
KD_CHILD_LEFT(ynode), callbacks);
BBHI(ybb, splitdim) = oldbbval;
printf("dualtree: done left child of y node %i: %i\n", ynode, KD_CHILD_LEFT(ynode));
printf("dualtree: start right child of y node %i: %i\n", ynode, KD_CHILD_RIGHT(ynode));
// update y bb for the right child: min(splitdim) = splitval
oldbbval = BBLO(ybb, splitdim);
BBLO(ybb, splitdim) = splitval;
dualtree_recurse(xtree, ytree, childnodes, leaves,
KD_CHILD_RIGHT(ynode), callbacks);
BBLO(ybb, splitdim) = oldbbval;
printf("dualtree: done right child of y node %i: %i\n", ynode, KD_CHILD_LEFT(ynode));
// put the "leaves" list back the way it was...
il_remove_index_range(leaves, leafmarker, il_size(leaves)-leafmarker);
il_free(childnodes);
}
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;
}
int plot_index_plot(const char* command,
cairo_t* cairo, plot_args_t* pargs, void* baton) {
plotindex_t* args = (plotindex_t*)baton;
int i;
double ra, dec, radius;
double xyz[3];
double r2;
pad_qidxes(args);
plotstuff_builtin_apply(cairo, pargs);
if (plotstuff_get_radec_center_and_radius(pargs, &ra, &dec, &radius)) {
ERROR("Failed to get RA,Dec center and radius");
return -1;
}
radecdeg2xyzarr(ra, dec, xyz);
r2 = deg2distsq(radius);
logmsg("Field RA,Dec,radius = (%g,%g), %g deg\n", ra, dec, radius);
logmsg("distsq: %g\n", r2);
for (i=0; i<pl_size(args->indexes); i++) {
index_t* index = pl_get(args->indexes, i);
int j, N;
int DQ;
double px,py;
if (args->stars) {
// plot stars
double* radecs = NULL;
startree_search_for(index->starkd, xyz, r2, NULL, &radecs, NULL, &N);
if (N) {
assert(radecs);
}
logmsg("Found %i stars in range in index %s\n", N, index->indexname);
for (j=0; j<N; j++) {
logverb(" RA,Dec (%g,%g) -> x,y (%g,%g)\n", radecs[2*j], radecs[2*j+1], px, py);
if (!plotstuff_radec2xy(pargs, radecs[j*2], radecs[j*2+1], &px, &py)) {
ERROR("Failed to convert RA,Dec %g,%g to pixels\n", radecs[j*2], radecs[j*2+1]);
continue;
}
cairoutils_draw_marker(cairo, pargs->marker, px, py, pargs->markersize);
cairo_stroke(cairo);
}
free(radecs);
}
if (args->quads) {
DQ = index_get_quad_dim(index);
qidxfile* qidx = pl_get(args->qidxes, i);
if (qidx) {
int* stars;
int Nstars;
il* quadlist = il_new(256);
// find stars in range.
startree_search_for(index->starkd, xyz, r2, NULL, NULL, &stars, &Nstars);
logmsg("Found %i stars in range of index %s\n", N, index->indexname);
logmsg("Using qidx file.\n");
// find quads that each star is a member of.
for (j=0; j<Nstars; j++) {
uint32_t* quads;
int Nquads;
int k;
if (qidxfile_get_quads(qidx, stars[j], &quads, &Nquads)) {
ERROR("Failed to get quads for star %i\n", stars[j]);
return -1;
}
for (k=0; k<Nquads; k++)
il_insert_unique_ascending(quadlist, quads[k]);
}
for (j=0; j<il_size(quadlist); j++) {
plotquad(cairo, pargs, args, index, il_get(quadlist, j), DQ);
}
} else {
// plot quads
N = index_nquads(index);
for (j=0; j<N; j++) {
plotquad(cairo, pargs, args, index, j, DQ);
}
}
}
}
return 0;
}
int main(int argc, char *argv[]) {
int argchar;
char* infn = NULL;
char* outfn = NULL;
anbool tostdout = FALSE;
FILE* fin = NULL;
FILE* fout = NULL;
il* exts;
il* sizes;
int i;
char* progname = argv[0];
int Next;
anqfits_t* anq;
exts = il_new(16);
sizes = il_new(16);
while ((argchar = getopt (argc, argv, OPTIONS)) != -1)
switch (argchar) {
case 'e':
il_append(exts, atoi(optarg));
break;
case 's':
il_append(sizes, atoi(optarg));
break;
case 'i':
infn = optarg;
break;
case 'o':
outfn = optarg;
break;
case '?':
case 'h':
printHelp(progname);
return 0;
default:
return -1;
}
log_init(LOG_MSG);
if (!infn || !outfn || !il_size(exts) || (il_size(exts) != il_size(sizes))) {
printHelp(progname);
exit(-1);
}
if (infn) {
fin = fopen(infn, "rb");
if (!fin) {
SYSERROR("Failed to open input file %s", infn);
exit(-1);
}
}
anq = anqfits_open(infn);
if (!anq) {
ERROR("Failed to open input file %s", infn);
exit(-1);
}
Next = anqfits_n_ext(anq);
if (Next == -1) {
ERROR("Couldn't determine how many extensions are in file %s", infn);
exit(-1);
} else {
logverb("File %s contains %i FITS extensions.\n", infn, Next);
}
for (i=0; i<il_size(exts); i++) {
int e = il_get(exts, i);
int s = il_get(sizes, i);
if (e < 0 || e >= Next) {
logerr("Extension %i is not valid: must be in [%i, %i]\n", e, 0, Next);
exit(-1);
}
if (s != 2 && s != 4 && s != 8) {
logerr("Invalid byte size %i: must be 2, 4, or 8.\n", s);
exit(-1);
}
}
if (!strcmp(outfn, "-"))
tostdout = TRUE;
if (tostdout)
fout = stdout;
else {
fout = fopen(outfn, "wb");
if (!fout) {
SYSERROR("Failed to open output file %s", outfn);
exit(-1);
}
}
for (i=0; i<Next; i++) {
int hdrstart, hdrlen, datastart, datalen;
int ind;
int size;
ind = il_index_of(exts, i);
if (ind == -1) {
size = 0;
} else {
size = il_get(sizes, ind);
}
hdrstart = anqfits_header_start(anq, i);
hdrlen = anqfits_header_size (anq, i);
datastart = anqfits_data_start(anq, i);
datalen = anqfits_data_size (anq, i);
if (hdrlen) {
if (pipe_file_offset(fin, hdrstart, hdrlen, fout)) {
ERROR("Failed to write header for extension %i", i);
exit(-1);
}
}
if (!datalen)
continue;
if (size) {
int Nitems = datalen / size;
int j;
char buf[size];
logmsg("Extension %i: flipping words of length %i bytes.\n", i, size);
for (j=0; j<Nitems; j++) {
if (fread(buf, size, 1, fin) != 1) {
SYSERROR("Failed to read data element %i from extension %i", j, i);
exit(-1);
}
endian_swap(buf, size);
if (fwrite(buf, size, 1, fout) != 1) {
SYSERROR("Failed to write data element %i to extension %i", j, i);
exit(-1);
}
}
} else {
logmsg("Extension %i: copying verbatim.\n", i);
// passthrough
if (pipe_file_offset(fin, datastart, datalen, fout)) {
ERROR("Failed to write data for extension %i", i);
exit(-1);
}
}
}
fclose(fin);
anqfits_close(anq);
if (!tostdout)
fclose(fout);
il_free(exts);
il_free(sizes);
return 0;
}
