/*
* Relinquish the array back to the memory pool. Note that there is no method
* provided to free *all* arrays.
*/
void
ar_free(int list_handle)
{
if (invalid_handle(list_handle))
return;
bl_free(bl_cs_array[list_handle]->data_handle);
bl_free(list_handle);
}
int fitstable_close(fitstable_t* tab) {
int i;
int rtn = 0;
if (!tab) return 0;
if (is_writing(tab)) {
if (fclose(tab->fid)) {
SYSERROR("Failed to close output file %s", tab->fn);
rtn = -1;
}
}
if (tab->anq) {
anqfits_close(tab->anq);
}
if (tab->readfid) {
fclose(tab->readfid);
}
if (tab->primheader)
qfits_header_destroy(tab->primheader);
if (tab->header)
qfits_header_destroy(tab->header);
if (tab->table)
qfits_table_close(tab->table);
free(tab->fn);
for (i=0; i<ncols(tab); i++) {
fitscol_t* col = getcol(tab, i);
free(col->colname);
free(col->units);
}
bl_free(tab->cols);
if (tab->br) {
buffered_read_free(tab->br);
free(tab->br);
}
if (tab->rows) {
bl_free(tab->rows);
}
if (tab->extensions) {
for (i=0; i<bl_size(tab->extensions); i++) {
fitsext_t* ext = bl_access(tab->extensions, i);
if (ext->rows != tab->rows)
bl_free(ext->rows);
if (ext->header != tab->header)
qfits_header_destroy(ext->header);
if (ext->table != tab->table)
qfits_table_close(ext->table);
}
bl_free(tab->extensions);
}
free(tab);
return rtn;
}
void sl_free2(sl* list) {
int i;
if (!list) return;
for (i=0; i<sl_size(list); i++)
free(sl_get(list, i));
bl_free(list);
}
void testit(int* wanted, int Nwanted, int dimquads, int (*compar)(const void *, const void *),
anbool cxdx) {
int i;
solver_t* solver;
index_t index;
starxy_t* starxy;
starxy = field1();
quadlist = bl_new(16, dimquads*sizeof(int));
ninv = 0;
solver = solver_new();
memset(&index, 0, sizeof(index_t));
index.index_scale_lower = 1;
index.index_scale_upper = 10;
index.dimquads = dimquads;
index.cx_less_than_dx = index.meanx_less_than_half = cxdx;
solver->funits_lower = 0.1;
solver->funits_upper = 10;
solver_add_index(solver, &index);
solver_set_field(solver, starxy);
solver_preprocess_field(solver);
printf("Found:\n");
solver_run(solver);
printf("\n");
fflush(NULL);
solver_free_field(solver);
solver_free(solver);
//
bl_sort(quadlist, compar);
qsort(wanted, Nwanted, dimquads*sizeof(int), compar);
printf("\n\n");
printf("Wanted:\n");
for (i=0; i<Nwanted; i++) {
int j;
printf("{");
for (j=0; j<dimquads; j++)
printf("%s%i", (j?",":""), wanted[i*dimquads+j]);
printf("}, ");
}
printf("\n");
printf("N found: %i; N wanted: %i\n", bl_size(quadlist), Nwanted);
printf("N obeying invariants: %i\n", ninv);
assert(bl_size(quadlist) == Nwanted);
for (i=0; i<bl_size(quadlist); i++) {
//int* i1 = bl_access(quadlist, i);
//int* i2 = wanted[i];
//printf("[%i, %i, %i] vs [%i, %i, %i]\n", i1[0],i1[1],i1[2], i2[0],i2[1],i2[2]);
assert(compar(bl_access(quadlist, i), wanted+i*dimquads) == 0);
}
bl_free(quadlist);
}
void test_bl_extend(CuTest *tc) {
bl* list = bl_new(10, sizeof(int));
CuAssertIntEquals(tc, bl_size(list), 0);
int *new1 = bl_extend(list);
CuAssertPtrNotNull(tc, new1);
CuAssertIntEquals(tc, bl_size(list), 1);
*new1 = 10;
int *new2 = bl_access(list, 0);
CuAssertPtrEquals(tc, new2, new1);
bl_free(list);
}
void glEnd() {
block_t *block = state.block.active;
if (! block) {
ERROR(GL_INVALID_OPERATION);
}
state.block.active = NULL;
bl_end(block);
// render if we're not in a display list
if (! state.list.active) {
bl_draw(block);
bl_free(block);
}
}
blob_t *
blob_new(void)
{
blob_t *b;
if ((b = bl_malloc(sizeof(*b))) != NULL) {
b->off = b->end = 0;
b->size = bl_size;
if ((b->base = bl_malloc(b->size)) == NULL) {
bl_free(b);
b = NULL;
}
}
return (b);
}
static void plot_hd(cairo_t* cairo, plot_args_t* pargs, plotann_t* ann) {
int i, N;
hd_catalog_t* hdcat = NULL;
double ra,dec,rad;
bl* hdlist = NULL;
if (!ann->hd_catalog)
return;
hdcat = henry_draper_open(ann->hd_catalog);
if (!hdcat) {
ERROR("Failed to open Henry Draper catalog file \"%s\"", ann->hd_catalog);
return;
}
if (plotstuff_get_radec_center_and_radius(pargs, &ra, &dec, &rad)) {
ERROR("Failed to get RA,Dec,radius from plotstuff");
return;
}
hdlist = henry_draper_get(hdcat, ra, dec, deg2arcsec(rad));
logverb("Got %zu Henry Draper stars\n", bl_size(hdlist));
N = bl_size(hdlist);
for (i=0; i<N; i++) {
hd_entry_t* entry = bl_access(hdlist, i);
double px, py;
char label[16];
if (!plotstuff_radec2xy(pargs, entry->ra, entry->dec, &px, &py))
continue;
px -= 1;
py -= 1;
if (px < 1 || py < 1 || px > pargs->W || py > pargs->H)
continue;
logverb("HD %i at RA,Dec (%g,%g) -> xy (%g, %g)\n", entry->hd, entry->ra, entry->dec, px, py);
plotstuff_stack_marker(pargs, px, py);
if (ann->HD_labels) {
sprintf(label, "HD %i", entry->hd);
plotstuff_stack_text(pargs, cairo, label, px, py);
}
}
bl_free(hdlist);
henry_draper_close(hdcat);
}
void glDrawArrays(GLenum mode, GLint first, GLsizei count) {
if (mode == GL_QUAD_STRIP)
mode = GL_TRIANGLE_STRIP;
displaylist_t *active = state.list.active;
if (active) {
block_t *block = block_from_arrays(mode, first, count);
bl_end(block);
dl_append_block(active, block);
return;
}
if (should_intercept_render(mode)) {
block_t *block = block_from_arrays(mode, first, count);
bl_end(block);
bl_draw(block);
bl_free(block);
} else {
LOAD_GLES(glDrawArrays);
gles_glDrawArrays(mode, first, count);
}
}
void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *uindices) {
// TODO: split for count > 65535?
GLushort *indices = gl_copy_array(uindices, type, 1, 0, GL_UNSIGNED_SHORT, 1, 0, count, false);
// TODO: do this in a more direct fashion.
if (should_intercept_render(mode)) {
glBegin(mode);
state.block.active->artificial = true;
for (int i = 0; i < count; i++) {
glArrayElement(indices[i]);
}
glEnd();
free(indices);
return;
}
displaylist_t *list = state.list.active;
if (list) {
GLsizei min, max;
normalize_indices(indices, &max, &min, count);
block_t *block = block_from_arrays(mode, min, max + 1);
block->indices = indices;
block->count = count;
bl_end(block);
if (list) {
dl_append_block(list, block);
} else {
bl_draw(block);
bl_free(block);
}
} else {
LOAD_GLES(glDrawElements);
gles_glDrawElements(mode, count, type, indices);
free(indices);
}
}
void
quit(int retcode)
{
/* disable interrupts */
(void) signal(SIGINT, SIG_IGN);
(void) signal(SIGHUP, SIG_IGN);
/* process return code if not quit(99) */
if (retcode != 99) {
if ((retcode % 10) == 0) {
if (failflag) {
retcode += 1;
} else if (warnflag) {
retcode += 2;
}
}
if (ireboot) {
retcode = (retcode % 10) + 20;
}
if (dreboot) {
retcode = (retcode % 10) + 10;
}
}
/* if set remove dstream temporary directory */
if (dstreamTempDir != (char *)NULL) {
echoDebug(DBG_REMOVING_DSTREAM_TMPDIR, dstreamTempDir);
(void) rrmdir(dstreamTempDir);
dstreamTempDir = (char *)NULL;
}
/* If we're in dryrun mode, write out the dryrun file(s). */
if (in_dryrun_mode()) {
char exit_msg[200];
set_dr_info(EXITCODE, retcode);
if (failflag || warnflag) {
set_dr_exitmsg(msgtext);
} else {
/* LINTED variable format specified */
(void) snprintf(exit_msg, sizeof (exit_msg),
qreason(1, retcode, installStarted,
includeZonename),
(pkginst ? pkginst : "unknown"),
zoneName);
set_dr_exitmsg(exit_msg);
}
write_dryrun_file(extlist);
ptext(stderr, MSG_DRYRUN_DONE);
ptext(stderr, MSG_NOCHANGE);
if (tmpdir[0] != NULL)
(void) rrmdir(tmpdir);
} else {
/* fix bug #1082589 that deletes root file */
if (tmpdir[0] != NULL) {
(void) rrmdir(tmpdir);
}
/* send mail to appropriate user list */
mailmsg(retcode);
/* display message about this installation */
quitmsg(retcode);
}
/*
* In the event that this quit() was called prior to completion of
* the task, do an unlockinst() just in case.
*/
unlockinst();
/* Unmount anything that's our responsibility. */
(void) unmount_client();
/*
* No need to umount device since calling process
* was responsible for original mount
*/
if (!updatingExistingPackage) {
if (!installStarted && pkgloc[0]) {
/*
* install not yet started; if package install
* location is defined, remove the package.
*/
echoDebug(DBG_QUIT_REMOVING_PKGDIR, pkgloc);
(void) chdir("/");
if (pkgloc[0]) {
(void) rrmdir(pkgloc);
}
}
} else {
if (!installStarted) {
/*
* If we haven't started, but have already done
* the <PKGINST>/install directory rename, then
* remove the new <PKGINST>/install directory
* and rename <PKGINST>/install.save back to
* <PKGINST>/install.
*/
if (pkgloc_sav[0] && !access(pkgloc_sav, F_OK)) {
if (pkgloc[0] && !access(pkgloc, F_OK))
(void) rrmdir(pkgloc);
if (rename(pkgloc_sav, pkgloc) == -1) {
progerr(ERR_PACKAGEBINREN,
pkgloc_sav, pkgloc);
}
}
} else {
if (pkgloc_sav[0] && !access(pkgloc_sav, F_OK)) {
echoDebug(DBG_QUIT_REMOVING_PKGSAV, pkgloc_sav);
(void) rrmdir(pkgloc_sav);
}
}
}
/*
* pkginst can be null if an administration setting doesn't all
* the package to be installed. Make sure pkginst exeists before
* updating the DB
*/
if (dparts > 0)
ds_skiptoend(pkgdev.cdevice);
(void) ds_close(1);
/* Free the filesystem table. */
fs_tab_free();
/* Free the package information lists. */
pinfo_free();
/* Free all stragglers. */
bl_free(BL_ALL);
(void) pathdup(NULL);
/* Free regfiles. */
regfiles_free();
/* final exit debugging message */
echoDebug(DBG_EXIT_WITH_CODE, retcode);
exit(retcode);
/*NOTREACHED*/
}
static startree_t* my_open(const char* fn, anqfits_t* fits) {
struct timeval tv1, tv2;
startree_t* s;
bl* chunks;
int i;
kdtree_fits_t* io;
char* treename = STARTREE_NAME;
const char* thefn = fn;
assert(fn || fits);
if (!thefn)
thefn = fits->filename;
s = startree_alloc();
if (!s)
return NULL;
gettimeofday(&tv1, NULL);
if (fn)
io = kdtree_fits_open(fn);
else
io = kdtree_fits_open_fits(fits);
gettimeofday(&tv2, NULL);
debug("kdtree_fits_open() took %g ms\n", millis_between(&tv1, &tv2));
if (!io) {
ERROR("Failed to open FITS file \"%s\"", thefn);
goto bailout;
}
gettimeofday(&tv1, NULL);
if (!kdtree_fits_contains_tree(io, treename))
treename = NULL;
gettimeofday(&tv2, NULL);
debug("kdtree_fits_contains_tree() took %g ms\n", millis_between(&tv1, &tv2));
gettimeofday(&tv1, NULL);
s->tree = kdtree_fits_read_tree(io, treename, &s->header);
gettimeofday(&tv2, NULL);
debug("kdtree_fits_read_tree() took %g ms\n", millis_between(&tv1, &tv2));
if (!s->tree) {
ERROR("Failed to read kdtree from file \"%s\"", thefn);
goto bailout;
}
// Check the tree dimensionality.
// (because code trees can be confused...)
if (s->tree->ndim != 3) {
logverb("File %s contains a kd-tree with dim %i (not 3), named %s\n",
thefn, s->tree->ndim, treename);
s->tree->io = NULL;
goto bailout;
}
gettimeofday(&tv1, NULL);
chunks = get_chunks(s, NULL);
for (i=0; i<bl_size(chunks); i++) {
fitsbin_chunk_t* chunk = bl_access(chunks, i);
void** dest = chunk->userdata;
kdtree_fits_read_chunk(io, chunk);
*dest = chunk->data;
}
bl_free(chunks);
gettimeofday(&tv2, NULL);
debug("reading chunks took %g ms\n", millis_between(&tv1, &tv2));
// kdtree_fits_t is a typedef of fitsbin_t
fitsbin_close_fd(io);
return s;
bailout:
kdtree_fits_io_close(io);
startree_close(s);
return NULL;
}
void sl_free_nonrecursive(sl* list) {
bl_free(list);
}
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 argchar;
char* infn = NULL;
char* outfn = NULL;
unsigned int row;
int bits;
FILE* fid = stdin;
FILE* fout = stdout;
int loglvl = LOG_MSG;
char* progname = args[0];
int bzero = 0;
int outformat;
qfits_header* hdr;
unsigned int plane;
off_t datastart;
anbool onepass = FALSE;
bl* pixcache = NULL;
#if HAVE_NETPBM
struct pam img;
tuple * tuplerow;
#else
void* rowbuf;
#endif
int W, H, depth, maxval;
while ((argchar = getopt (argc, args, OPTIONS)) != -1)
switch (argchar) {
case '?':
case 'h':
printHelp(progname);
exit(0);
case 'v':
loglvl++;
break;
case 'q':
loglvl--;
break;
case 'o':
outfn = optarg;
break;
}
log_init(loglvl);
log_to(stderr);
fits_use_error_system();
if (optind == argc) {
// ok, stdin to stdout.
} else if (optind == argc-1) {
infn = args[optind];
} else if (optind == argc-2) {
infn = args[optind];
outfn = args[optind+1];
} else {
printHelp(progname);
exit(-1);
}
if (infn && !streq(infn, "-")) {
fid = fopen(infn, "rb");
if (!fid) {
SYSERROR("Failed to open input file %s", infn);
exit(-1);
}
}
if (outfn) {
fout = fopen(outfn, "wb");
if (!fid) {
SYSERROR("Failed to open output file %s", outfn);
exit(-1);
}
} else
outfn = "stdout";
#if HAVE_NETPBM
pm_init(args[0], 0);
pnm_readpaminit(fid, &img,
// PAM_STRUCT_SIZE isn't defined until Netpbm 10.23 (July 2004)
#if defined(PAM_STRUCT_SIZE)
PAM_STRUCT_SIZE(tuple_type)
#else
sizeof(struct pam)
#endif
);
W = img.width;
H = img.height;
depth = img.depth;
maxval = img.maxval;
tuplerow = pnm_allocpamrow(&img);
bits = pm_maxvaltobits(img.maxval);
bits = (bits <= 8) ? 8 : 16;
#else // No NETPBM
if (parse_pnm_header(fid, &W, &H, &depth, &maxval)) {
ERROR("Failed to parse PNM header from file: %s\n", infn ? infn : "<stdin>");
exit(-1);
}
bits = 8 * maxval_to_bytes(maxval);
rowbuf = malloc(W * depth * (bits/8));
#endif
logmsg("Read file %s: %i x %i pixels x %i color(s); maxval %i\n",
infn ? infn : "stdin", W, H, depth, maxval);
if (bits == 8)
outformat = BPP_8_UNSIGNED;
else {
outformat = BPP_16_SIGNED;
if (maxval >= INT16_MAX)
bzero = 0x8000;
}
logmsg("Using %i-bit output\n", bits);
hdr = fits_get_header_for_image3(W, H, outformat, depth, NULL);
if (bzero)
fits_header_add_int(hdr, "BZERO", bzero, "Number that has been subtracted from pixel values");
if (qfits_header_dump(hdr, fout)) {
ERROR("Failed to write FITS header to file %s", outfn);
exit(-1);
}
qfits_header_destroy(hdr);
datastart = ftello(fid);
// Figure out if we can seek backward in this input file...
if ((fid == stdin) ||
(fseeko(fid, 0, SEEK_SET) ||
fseeko(fid, datastart, SEEK_SET)))
// Nope!
onepass = TRUE;
if (onepass && depth > 1) {
logmsg("Reading in one pass\n");
pixcache = bl_new(16384, bits/8);
}
for (plane=0; plane<depth; plane++) {
if (plane > 0) {
if (fseeko(fid, datastart, SEEK_SET)) {
SYSERROR("Failed to seek back to start of image data");
exit(-1);
}
}
for (row = 0; row<H; row++) {
unsigned int column;
#if HAVE_NETPBM
pnm_readpamrow(&img, tuplerow);
#else
read_pnm_row(fid, W, depth, maxval, rowbuf);
#endif
for (column = 0; column<W; column++) {
int rtn;
int pixval;
#if HAVE_NETPBM
pixval = tuplerow[column][plane];
#else
pixval = (bits == 8 ?
((uint8_t *)rowbuf)[column*depth + plane] :
((uint16_t*)rowbuf)[column*depth + plane]);
#endif
if (outformat == BPP_8_UNSIGNED)
rtn = fits_write_data_B(fout, pixval);
else
rtn = fits_write_data_I(fout, pixval-bzero, TRUE);
if (rtn) {
ERROR("Failed to write FITS pixel");
exit(-1);
}
}
if (onepass && depth > 1) {
for (column = 0; column<W; column++) {
for (plane=1; plane<depth; plane++) {
int pixval;
#if HAVE_NETPBM
pixval = tuplerow[column][plane];
#else
pixval = (bits == 8 ?
((uint8_t *)rowbuf)[column*depth + plane] :
((uint16_t*)rowbuf)[column*depth + plane]);
#endif
if (outformat == BPP_8_UNSIGNED) {
uint8_t pix = pixval;
bl_append(pixcache, &pix);
} else {
int16_t pix = pixval - bzero;
bl_append(pixcache, &pix);
}
}
}
}
}
}
#if HAVE_NETPBM
pnm_freepamrow(tuplerow);
#else
free(rowbuf);
#endif
if (pixcache) {
int i, j;
int step = (depth - 1);
logverb("Writing %zu queued pixels\n", bl_size(pixcache));
for (plane=1; plane<depth; plane++) {
j = (plane - 1);
for (i=0; i<(W * H); i++) {
int rtn;
if (outformat == BPP_8_UNSIGNED) {
uint8_t* pix = bl_access(pixcache, j);
rtn = fits_write_data_B(fout, *pix);
} else {
int16_t* pix = bl_access(pixcache, j);
rtn = fits_write_data_I(fout, *pix, TRUE);
}
if (rtn) {
ERROR("Failed to write FITS pixel");
exit(-1);
}
j += step;
}
}
bl_free(pixcache);
}
if (fid != stdin)
fclose(fid);
if (fits_pad_file(fout)) {
ERROR("Failed to pad output file \"%s\"", outfn);
return -1;
}
if (fout != stdout)
if (fclose(fout)) {
SYSERROR("Failed to close output file %s", outfn);
exit(-1);
}
return 0;
}
void test_hd_1(CuTest* tc) {
hd_catalog_t* hdcat;
int* invperm;
int* present;
int ind, i, N;
double xyz[3];
double ra, dec;
int strangehds[] = { 40142, 40441, 40672, 40746, 40763, 40764,
104176, 104193, 163635, 224698, 224699,
129371 };
if (!file_readable("hd.fits")) {
printf("File \"hd.fits\" does not exist; test skipped.\n");
return;
}
hdcat = henry_draper_open("hd.fits");
CuAssertPtrNotNull(tc, hdcat);
N = hdcat->kd->ndata;
invperm = calloc(N, sizeof(int));
CuAssertPtrNotNull(tc, invperm);
CuAssertIntEquals(tc, 0, kdtree_check(hdcat->kd));
kdtree_inverse_permutation(hdcat->kd, invperm);
present = calloc(N, sizeof(int));
for (i=0; i<N; i++) {
CuAssert(tc, "invperm in range", invperm[i] < N);
present[invperm[i]]++;
}
for (i=0; i<N; i++) {
CuAssertIntEquals(tc, 1, present[i]);
}
free(present);
// Where is "HD n" ?
for (i=0; i<10; i++) {
bl* res;
int j;
ind = invperm[i];
kdtree_copy_data_double(hdcat->kd, ind, 1, xyz);
xyzarr2radecdeg(xyz, &ra, &dec);
printf("HD %i: RA,Dec %g, %g\n", i+1, ra, dec);
res = henry_draper_get(hdcat, ra, dec, 10.0);
CuAssertPtrNotNull(tc, res);
for (j=0; j<bl_size(res); j++) {
hd_entry_t* hd = bl_access(res, j);
printf("res %i: HD %i, RA, Dec %g, %g\n", j, hd->hd, hd->ra, hd->dec);
}
bl_free(res);
}
for (i=0; i<sizeof(strangehds)/sizeof(int); i++) {
ind = invperm[strangehds[i]-1];
kdtree_copy_data_double(hdcat->kd, ind, 1, xyz);
xyzarr2radecdeg(xyz, &ra, &dec);
printf("HD %i: RA,Dec %g, %g\n", strangehds[i], ra, dec);
}
free(invperm);
henry_draper_close(hdcat);
}
int main(int argc, char *argv[]) {
int argchar;
char* progname = argv[0];
char** inputfiles = NULL;
int ninputfiles = 0;
int i;
int firstfield=0, lastfield=INT_MAX-1;
int firstfieldfile=1, lastfieldfile=INT_MAX-1;
matchfile** mfs;
MatchObj** mos;
anbool* eofs;
anbool* eofieldfile;
int nread = 0;
int f;
int fieldfile;
int totalsolved, totalunsolved;
int mode = MODE_BEST;
double logodds_tosolve = -HUGE_VAL;
anbool agree = FALSE;
MatchObj* bestmo;
bl* keepers;
bl* leftovers = NULL;
while ((argchar = getopt (argc, argv, OPTIONS)) != -1) {
switch (argchar) {
case 'S':
solvedfile = optarg;
break;
case 's':
solvedserver = optarg;
break;
case 'F':
mode = MODE_FIRST;
break;
case 'a':
mode = MODE_ALL;
break;
case 'r':
ratio_tosolve = atof(optarg);
logodds_tosolve = log(ratio_tosolve);
break;
case 'f':
ninfield_tosolve = atoi(optarg);
break;
case 'M':
agreefname = optarg;
break;
case 'L':
leftoverfname = optarg;
break;
case 'I':
firstfieldfile = atoi(optarg);
break;
case 'J':
lastfieldfile = atoi(optarg);
break;
case 'A':
firstfield = atoi(optarg);
break;
case 'B':
lastfield = atoi(optarg);
break;
case 'h':
default:
printHelp(progname);
exit(-1);
}
}
if (optind < argc) {
ninputfiles = argc - optind;
inputfiles = argv + optind;
} else {
printHelp(progname);
exit(-1);
}
if (lastfield < firstfield) {
fprintf(stderr, "Last field (-B) must be at least as big as first field (-A)\n");
exit(-1);
}
if (solvedserver)
if (solvedclient_set_server(solvedserver)) {
fprintf(stderr, "Failed to set solved server.\n");
exit(-1);
}
if (leftoverfname) {
leftovermf = matchfile_open_for_writing(leftoverfname);
if (!leftovermf) {
fprintf(stderr, "Failed to open file %s to write leftover matches.\n", leftoverfname);
exit(-1);
}
BOILERPLATE_ADD_FITS_HEADERS(leftovermf->header);
qfits_header_add(leftovermf->header, "HISTORY", "This file was created by the program \"agreeable\".", NULL, NULL);
if (matchfile_write_headers(leftovermf)) {
fprintf(stderr, "Failed to write leftovers matchfile header.\n");
exit(-1);
}
leftovers = bl_new(256, sizeof(MatchObj));
}
if (agreefname) {
agreemf = matchfile_open_for_writing(agreefname);
if (!agreemf) {
fprintf(stderr, "Failed to open file %s to write agreeing matches.\n", agreefname);
exit(-1);
}
BOILERPLATE_ADD_FITS_HEADERS(agreemf->header);
qfits_header_add(agreemf->header, "HISTORY", "This file was created by the program \"agreeable\".", NULL, NULL);
if (matchfile_write_headers(agreemf)) {
fprintf(stderr, "Failed to write agreeing matchfile header.\n");
exit(-1);
}
agree = TRUE;
}
solved = il_new(256);
unsolved = il_new(256);
keepers = bl_new(256, sizeof(MatchObj));
totalsolved = totalunsolved = 0;
mos = calloc(ninputfiles, sizeof(MatchObj*));
eofs = calloc(ninputfiles, sizeof(anbool));
eofieldfile = malloc(ninputfiles * sizeof(anbool));
mfs = malloc(ninputfiles * sizeof(matchfile*));
for (i=0; i<ninputfiles; i++) {
fprintf(stderr, "Opening file %s...\n", inputfiles[i]);
mfs[i] = matchfile_open(inputfiles[i]);
if (!mfs[i]) {
fprintf(stderr, "Failed to open matchfile %s.\n", inputfiles[i]);
exit(-1);
}
}
// we assume the matchfiles are sorted by field id and number.
for (fieldfile=firstfieldfile; fieldfile<=lastfieldfile; fieldfile++) {
anbool alldone = TRUE;
memset(eofieldfile, 0, ninputfiles * sizeof(anbool));
for (f=firstfield; f<=lastfield; f++) {
int fieldnum = f;
anbool donefieldfile;
anbool solved_it;
bl* writematches = NULL;
// quit if we've reached the end of all the input files.
alldone = TRUE;
for (i=0; i<ninputfiles; i++)
if (!eofs[i]) {
alldone = FALSE;
break;
}
if (alldone)
break;
// move on to the next fieldfile if all the input files have been
// exhausted.
donefieldfile = TRUE;
for (i=0; i<ninputfiles; i++)
if (!eofieldfile[i] && !eofs[i]) {
donefieldfile = FALSE;
break;
}
if (donefieldfile)
break;
// start a new field.
fprintf(stderr, "File %i, Field %i.\n", fieldfile, f);
solved_it = FALSE;
bestmo = NULL;
for (i=0; i<ninputfiles; i++) {
int nr = 0;
int ns = 0;
while (1) {
if (eofs[i])
break;
if (!mos[i])
mos[i] = matchfile_read_match(mfs[i]);
if (unlikely(!mos[i])) {
eofs[i] = TRUE;
break;
}
// skip past entries that are out of range...
if ((mos[i]->fieldfile < firstfieldfile) ||
(mos[i]->fieldfile > lastfieldfile) ||
(mos[i]->fieldnum < firstfield) ||
(mos[i]->fieldnum > lastfield)) {
mos[i] = NULL;
ns++;
continue;
}
if (mos[i]->fieldfile > fieldfile)
eofieldfile[i] = TRUE;
if (mos[i]->fieldfile != fieldfile)
break;
assert(mos[i]->fieldnum >= fieldnum);
if (mos[i]->fieldnum != fieldnum)
break;
nread++;
if (nread % 10000 == 9999) {
fprintf(stderr, ".");
fflush(stderr);
}
// if we've already found a solution, skip past the
// remaining matches in this file...
if (solved_it && (mode == MODE_FIRST)) {
ns++;
mos[i] = NULL;
continue;
}
nr++;
if ((mos[i]->logodds >= logodds_tosolve) &&
(mos[i]->nindex >= ninfield_tosolve)) {
solved_it = TRUE;
// (note, we get a pointer to its position in the list)
mos[i] = bl_append(keepers, mos[i]);
if (!bestmo || mos[i]->logodds > bestmo->logodds)
bestmo = mos[i];
} else if (leftovers) {
bl_append(leftovers, mos[i]);
}
mos[i] = NULL;
}
if (nr || ns)
fprintf(stderr, "File %s: read %i matches, skipped %i matches.\n", inputfiles[i], nr, ns);
}
// which matches do we want to write out?
if (agree) {
writematches = bl_new(256, sizeof(MatchObj));
switch (mode) {
case MODE_BEST:
case MODE_FIRST:
if (bestmo)
bl_append(writematches, bestmo);
break;
case MODE_ALL:
bl_append_list(writematches, keepers);
break;
}
}
write_field(writematches, leftovers, fieldfile, fieldnum);
if (agree)
bl_free(writematches);
if (leftovers)
bl_remove_all(leftovers);
if (keepers)
bl_remove_all(keepers);
fprintf(stderr, "This file: %i fields solved, %i unsolved.\n", il_size(solved), il_size(unsolved));
fprintf(stderr, "Grand total: %i solved, %i unsolved.\n", totalsolved + il_size(solved), totalunsolved + il_size(unsolved));
}
totalsolved += il_size(solved);
totalunsolved += il_size(unsolved);
il_remove_all(solved);
il_remove_all(unsolved);
if (alldone)
break;
}
for (i=0; i<ninputfiles; i++)
matchfile_close(mfs[i]);
free(mfs);
free(mos);
free(eofs);
fprintf(stderr, "\nRead %i matches.\n", nread);
fflush(stderr);
if (keepers)
bl_free(keepers);
if (leftovers)
bl_free(leftovers);
il_free(solved);
il_free(unsolved);
if (leftovermf) {
matchfile_fix_headers(leftovermf);
matchfile_close(leftovermf);
}
if (agreemf) {
matchfile_fix_headers(agreemf);
matchfile_close(agreemf);
}
return 0;
}
void test2() {
int i;
solver_t* solver;
index_t index;
starxy_t* starxy;
int wanted[][3] = { { 0, 1, 3 },
{ 0, 1, 4 },
{ 0, 1, 5 },
{ 0, 2, 3 },
{ 0, 2, 4 },
{ 0, 3, 4 },
{ 0, 5, 4 },
{ 0, 6, 4 },
{ 0, 6, 5 },
{ 1, 2, 3 },
{ 1, 2, 4 },
{ 1, 3, 4 },
{ 1, 5, 4 },
{ 1, 6, 4 },
{ 1, 6, 5 },
{ 2, 4, 3 },
{ 2, 5, 0 },
{ 2, 5, 1 },
{ 2, 5, 3 },
{ 2, 5, 4 },
{ 2, 6, 0 },
{ 2, 6, 1 },
{ 2, 6, 3 },
{ 2, 6, 4 },
{ 2, 6, 5 },
{ 3, 5, 4 },
{ 3, 6, 0 },
{ 3, 6, 1 },
{ 3, 6, 4 },
{ 3, 6, 5 },
{ 4, 6, 5 },
};
starxy = field1();
quadlist = bl_new(16, 3*sizeof(uint));
solver = solver_new();
memset(&index, 0, sizeof(index_t));
index.index_scale_lower = 1;
index.index_scale_upper = 10;
index.dimquads = 3;
solver->funits_lower = 0.1;
solver->funits_upper = 10;
solver_add_index(solver, &index);
solver_set_field(solver, starxy);
solver_preprocess_field(solver);
solver_run(solver);
solver_free_field(solver);
solver_free(solver);
//
assert(bl_size(quadlist) == (sizeof(wanted) / (3*sizeof(uint))));
bl_sort(quadlist, compare_tri);
for (i=0; i<bl_size(quadlist); i++) {
assert(compare_tri(bl_access(quadlist, i), wanted[i]) == 0);
}
bl_free(quadlist);
}
int main(int argc, char** args) {
int c;
int rtn;
int help_flag = 0;
bl* opts;
char* me;
augment_xylist_t theargs;
augment_xylist_t* axy = &theargs;
me = find_executable(args[0], NULL);
opts = bl_new(4, sizeof(an_option_t));
augment_xylist_add_options(opts);
augment_xylist_init(axy);
while (1) {
c = opts_getopt(opts, argc, args);
if (c == -1)
break;
switch (c) {
case 0:
fprintf(stderr, "Unknown option '-%c'\n", optopt);
exit(-1);
case '?':
break;
case 'h':
help_flag = 1;
break;
default:
if (augment_xylist_parse_option(c, optarg, axy)) {
exit(-1);
}
break;
}
}
rtn = 0;
if (optind != argc) {
int i;
printf("Unknown arguments:\n ");
for (i=optind; i<argc; i++) {
printf("%s ", args[i]);
}
printf("\n");
help_flag = 1;
rtn = -1;
}
if (!axy->axyfn) {
printf("Output filename (-o / --out) is required.\n");
help_flag = 1;
rtn = -1;
}
if (!(axy->imagefn || axy->xylsfn)) {
printf("Require either an image (-i / --image) or an XYlist (-x / --xylist) input file.\n");
help_flag = 1;
rtn = -1;
}
if (help_flag) {
print_help(args[0], opts);
exit(rtn);
}
bl_free(opts);
rtn = augment_xylist(axy, me);
augment_xylist_free_contents(axy);
return rtn;
}
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;
}
static void plot_builtin_free(plot_args_t* pargs, void* baton) {
anwcs_free(pargs->wcs);
bl_free(pargs->cairocmds);
}
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;
}
/* Free all allocated package info structures. */
void
pinfo_free(void)
{
bl_free(pinfo_handle);
}
int main(int argc, char** args) {
char* default_configfn = "astrometry.cfg";
char* default_config_path = "../etc";
int c;
char* configfn = NULL;
int i;
engine_t* engine;
char* mydir = NULL;
char* basedir = NULL;
char* me;
anbool help = FALSE;
sl* strings = sl_new(4);
char* cancelfn = NULL;
char* solvedfn = NULL;
int loglvl = LOG_MSG;
anbool tostderr = FALSE;
char* infn = NULL;
FILE* fin = NULL;
anbool fromstdin = FALSE;
bl* opts = opts_from_array(myopts, sizeof(myopts)/sizeof(an_option_t), NULL);
sl* inds = sl_new(4);
char* datalog = NULL;
engine = engine_new();
while (1) {
c = opts_getopt(opts, argc, args);
if (c == -1)
break;
switch (c) {
case 'D':
datalog = optarg;
break;
case 'p':
engine->inparallel = TRUE;
break;
case 'i':
sl_append(inds, optarg);
break;
case 'd':
basedir = optarg;
break;
case 'f':
infn = optarg;
fromstdin = streq(infn, "-");
break;
case 'E':
tostderr = TRUE;
break;
case 'h':
help = TRUE;
break;
case 'v':
loglvl++;
break;
case 's':
solvedfn = optarg;
case 'C':
cancelfn = optarg;
break;
case 'c':
configfn = strdup(optarg);
break;
case '?':
break;
default:
printf("Unknown flag %c\n", c);
exit( -1);
}
}
if (optind == argc && !infn) {
// Need extra args: filename
printf("You must specify at least one input file!\n\n");
help = TRUE;
}
if (help) {
print_help(args[0], opts);
exit(0);
}
bl_free(opts);
gslutils_use_error_system();
log_init(loglvl);
if (tostderr)
log_to(stderr);
if (datalog) {
datalogfid = fopen(datalog, "wb");
if (!datalogfid) {
SYSERROR("Failed to open data log file \"%s\" for writing", datalog);
return -1;
}
atexit(close_datalogfid);
data_log_init(100);
data_log_enable_all();
data_log_to(datalogfid);
data_log_start();
}
if (infn) {
logverb("Reading input filenames from %s\n", (fromstdin ? "stdin" : infn));
if (!fromstdin) {
fin = fopen(infn, "rb");
if (!fin) {
ERROR("Failed to open file %s for reading input filenames", infn);
exit(-1);
}
} else
fin = stdin;
}
// directory containing the 'engine' executable:
me = find_executable(args[0], NULL);
if (!me)
me = strdup(args[0]);
mydir = sl_append(strings, dirname(me));
free(me);
// Read config file
if (!configfn) {
int i;
sl* trycf = sl_new(4);
sl_appendf(trycf, "%s/%s/%s", mydir, default_config_path, default_configfn);
// if I'm in /usr/bin, look for config file in /etc
if (streq(mydir, "/usr/bin")) {
sl_appendf(trycf, "/etc/%s", default_configfn);
}
sl_appendf(trycf, "%s/%s", mydir, default_configfn);
sl_appendf(trycf, "./%s", default_configfn);
sl_appendf(trycf, "./%s/%s", default_config_path, default_configfn);
for (i=0; i<sl_size(trycf); i++) {
char* cf = sl_get(trycf, i);
if (file_exists(cf)) {
configfn = strdup(cf);
logverb("Using config file \"%s\"\n", cf);
break;
} else {
logverb("Config file \"%s\" doesn't exist.\n", cf);
}
}
if (!configfn) {
char* cflist = sl_join(trycf, "\n ");
logerr("Couldn't find config file: tried:\n %s\n", cflist);
free(cflist);
}
sl_free2(trycf);
}
if (!streq(configfn, "none")) {
if (engine_parse_config_file(engine, configfn)) {
logerr("Failed to parse (or encountered an error while interpreting) config file \"%s\"\n", configfn);
exit( -1);
}
}
if (sl_size(inds)) {
// Expand globs.
for (i=0; i<sl_size(inds); i++) {
char* s = sl_get(inds, i);
glob_t myglob;
int flags = GLOB_TILDE | GLOB_BRACE;
if (glob(s, flags, NULL, &myglob)) {
SYSERROR("Failed to expand wildcards in index-file path \"%s\"", s);
exit(-1);
}
for (c=0; c<myglob.gl_pathc; c++) {
if (engine_add_index(engine, myglob.gl_pathv[c])) {
ERROR("Failed to add index \"%s\"", myglob.gl_pathv[c]);
exit(-1);
}
}
globfree(&myglob);
}
}
if (!pl_size(engine->indexes)) {
logerr("\n\n"
"---------------------------------------------------------------------\n"
"You must list at least one index in the config file (%s)\n\n"
"See http://astrometry.net/use.html about how to get some index files.\n"
"---------------------------------------------------------------------\n"
"\n", configfn);
exit(-1);
}
if (engine->minwidth <= 0.0 || engine->maxwidth <= 0.0) {
logerr("\"minwidth\" and \"maxwidth\" in the config file %s must be positive!\n", configfn);
exit(-1);
}
free(configfn);
if (!il_size(engine->default_depths)) {
parse_depth_string(engine->default_depths,
"10 20 30 40 50 60 70 80 90 100 "
"110 120 130 140 150 160 170 180 190 200");
}
engine->cancelfn = cancelfn;
engine->solvedfn = solvedfn;
i = optind;
while (1) {
char* jobfn;
job_t* job;
struct timeval tv1, tv2;
if (infn) {
// Read name of next input file to be read.
logverb("\nWaiting for next input filename...\n");
jobfn = read_string_terminated(fin, "\n\r\0", 3, FALSE);
if (strlen(jobfn) == 0)
break;
} else {
if (i == argc)
break;
jobfn = args[i];
i++;
}
gettimeofday(&tv1, NULL);
logmsg("Reading file \"%s\"...\n", jobfn);
job = engine_read_job_file(engine, jobfn);
if (!job) {
ERROR("Failed to read job file \"%s\"", jobfn);
exit(-1);
}
if (basedir) {
logverb("Setting job's output base directory to %s\n", basedir);
job_set_output_base_dir(job, basedir);
}
if (engine_run_job(engine, job))
logerr("Failed to run_job()\n");
job_free(job);
gettimeofday(&tv2, NULL);
logverb("Spent %g seconds on this field.\n", millis_between(&tv1, &tv2)/1000.0);
}
engine_free(engine);
sl_free2(strings);
sl_free2(inds);
if (fin && !fromstdin)
fclose(fin);
return 0;
}
int main(int argc, char** args) {
int c;
anbool help = FALSE;
char* outdir = NULL;
char* cmd;
int i, j, f;
int inputnum;
int rtn;
sl* engineargs;
int nbeargs;
anbool fromstdin = FALSE;
anbool overwrite = FALSE;
anbool cont = FALSE;
anbool skip_solved = FALSE;
anbool makeplots = TRUE;
double plotscale = 1.0;
char* inbgfn = NULL;
char* bgfn = NULL;
char* me;
anbool verbose = FALSE;
int loglvl = LOG_MSG;
char* outbase = NULL;
anbool usecurl = TRUE;
bl* opts;
augment_xylist_t theallaxy;
augment_xylist_t* allaxy = &theallaxy;
int nmyopts;
char* removeopts = "ixo\x01";
char* newfits;
char* kmz = NULL;
char* scamp = NULL;
char* scampconfig = NULL;
char* index_xyls;
anbool just_augment = FALSE;
anbool engine_batch = FALSE;
bl* batchaxy = NULL;
bl* batchsf = NULL;
sl* outfiles;
sl* tempfiles;
// these are deleted after the outer loop over input files
sl* tempfiles2;
sl* tempdirs;
anbool timestamp = FALSE;
anbool tempaxy = FALSE;
errors_print_on_exit(stderr);
fits_use_error_system();
me = find_executable(args[0], NULL);
engineargs = sl_new(16);
append_executable(engineargs, "astrometry-engine", me);
// output filenames.
outfiles = sl_new(16);
tempfiles = sl_new(4);
tempfiles2 = sl_new(4);
tempdirs = sl_new(4);
rtn = 0;
nmyopts = sizeof(options)/sizeof(an_option_t);
opts = opts_from_array(options, nmyopts, NULL);
augment_xylist_add_options(opts);
// remove duplicate short options.
for (i=0; i<nmyopts; i++) {
an_option_t* opt1 = bl_access(opts, i);
for (j=nmyopts; j<bl_size(opts); j++) {
an_option_t* opt2 = bl_access(opts, j);
if (opt2->shortopt == opt1->shortopt)
bl_remove_index(opts, j);
}
}
// remove unwanted augment-xylist options.
for (i=0; i<strlen(removeopts); i++) {
for (j=nmyopts; j<bl_size(opts); j++) {
an_option_t* opt2 = bl_access(opts, j);
if (opt2->shortopt == removeopts[i])
bl_remove_index(opts, j);
}
}
// which options are left?
/*{
char options[256];
memset(options, 0, 256);
printf("options:\n");
for (i=0; i<bl_size(opts); i++) {
an_option_t* opt = bl_access(opts, i);
printf(" %c (%i) %s\n", opt->shortopt, (int)opt->shortopt, opt->name);
options[(int)((opt->shortopt + 256) % 256)] = 1;
}
printf("Remaining short opts:\n");
for (i=0; i<256; i++) {
if (!options[i])
printf(" %c (%i, 0x%x)\n", (char)i, i, i);
}
}*/
augment_xylist_init(allaxy);
// default output filename patterns.
allaxy->axyfn = "%s.axy";
allaxy->matchfn = "%s.match";
allaxy->rdlsfn = "%s.rdls";
allaxy->solvedfn = "%s.solved";
allaxy->wcsfn = "%s.wcs";
allaxy->corrfn = "%s.corr";
newfits = "%s.new";
index_xyls = "%s-indx.xyls";
while (1) {
int res;
c = opts_getopt(opts, argc, args);
//printf("option %c (%i)\n", c, (int)c);
if (c == -1)
break;
switch (c) {
case '\x91':
allaxy->axyfn = optarg;
break;
case '\x90':
tempaxy = TRUE;
break;
case '\x88':
timestamp = TRUE;
break;
case '\x84':
plotscale = atof(optarg);
break;
case '\x85':
inbgfn = optarg;
break;
case '\x87':
allaxy->assume_fits_image = TRUE;
break;
case '(':
engine_batch = TRUE;
break;
case '@':
just_augment = TRUE;
break;
case 'U':
index_xyls = optarg;
break;
case 'n':
scampconfig = optarg;
break;
case 'i':
scamp = optarg;
break;
case 'Z':
kmz = optarg;
break;
case 'N':
newfits = optarg;
break;
case 'h':
help = TRUE;
break;
case 'v':
sl_append(engineargs, "--verbose");
verbose = TRUE;
allaxy->verbosity++;
loglvl++;
break;
case 'D':
outdir = optarg;
break;
case 'o':
outbase = optarg;
break;
case 'b':
case '\x89':
sl_append(engineargs, "--config");
append_escape(engineargs, optarg);
break;
case 'f':
fromstdin = TRUE;
break;
case 'O':
overwrite = TRUE;
break;
case 'p':
makeplots = FALSE;
break;
case 'G':
usecurl = FALSE;
break;
case 'K':
cont = TRUE;
break;
case 'J':
skip_solved = TRUE;
break;
default:
res = augment_xylist_parse_option(c, optarg, allaxy);
if (res) {
rtn = -1;
goto dohelp;
}
}
}
if ((optind == argc) && !fromstdin) {
printf("ERROR: You didn't specify any files to process.\n");
help = TRUE;
}
if (help) {
dohelp:
print_help(args[0], opts);
exit(rtn);
}
bl_free(opts);
// --dont-augment: advertised as just write xy file,
// so quit after doing that.
if (allaxy->dont_augment) {
just_augment = TRUE;
}
log_init(loglvl);
if (timestamp)
log_set_timestamp(TRUE);
if (kmz && starts_with(kmz, "-"))
logmsg("Do you really want to save KMZ to the file named \"%s\" ??\n", kmz);
if (starts_with(newfits, "-")) {
logmsg("Do you really want to save the new FITS file to the file named \"%s\" ??\n", newfits);
}
if (engine_batch) {
batchaxy = bl_new(16, sizeof(augment_xylist_t));
batchsf = bl_new(16, sizeof(solve_field_args_t));
}
// Allow (some of the) default filenames to be disabled by setting them to "none".
allaxy->matchfn = none_is_null(allaxy->matchfn);
allaxy->rdlsfn = none_is_null(allaxy->rdlsfn);
allaxy->solvedfn = none_is_null(allaxy->solvedfn);
allaxy->solvedinfn = none_is_null(allaxy->solvedinfn);
allaxy->wcsfn = none_is_null(allaxy->wcsfn);
allaxy->corrfn = none_is_null(allaxy->corrfn);
newfits = none_is_null(newfits);
index_xyls = none_is_null(index_xyls);
if (outdir) {
if (mkdir_p(outdir)) {
ERROR("Failed to create output directory %s", outdir);
exit(-1);
}
}
// number of engine args not specific to a particular file
nbeargs = sl_size(engineargs);
f = optind;
inputnum = 0;
while (1) {
char* infile = NULL;
anbool isxyls;
char* reason;
int len;
char* base;
char* basedir;
char* basefile = NULL;
char *objsfn=NULL;
char *ppmfn=NULL;
char* downloadfn = NULL;
char* suffix = NULL;
sl* cmdline;
anbool ctrlc;
anbool isurl;
augment_xylist_t theaxy;
augment_xylist_t* axy = &theaxy;
int j;
solve_field_args_t thesf;
solve_field_args_t* sf = &thesf;
anbool want_pnm = FALSE;
// reset augment-xylist args.
memcpy(axy, allaxy, sizeof(augment_xylist_t));
memset(sf, 0, sizeof(solve_field_args_t));
if (fromstdin) {
char fnbuf[1024];
if (!fgets(fnbuf, sizeof(fnbuf), stdin)) {
if (ferror(stdin))
SYSERROR("Failed to read a filename from stdin");
break;
}
len = strlen(fnbuf);
if (fnbuf[len-1] == '\n')
fnbuf[len-1] = '\0';
infile = fnbuf;
logmsg("Reading input file \"%s\"...\n", infile);
} else {
if (f == argc)
break;
infile = args[f];
f++;
logmsg("Reading input file %i of %i: \"%s\"...\n",
f - optind, argc - optind, infile);
}
inputnum++;
cmdline = sl_new(16);
if (!engine_batch) {
// Remove arguments that might have been added in previous trips through this loop
sl_remove_from(engineargs, nbeargs);
}
// Choose the base path/filename for output files.
if (outbase)
asprintf_safe(&basefile, outbase, inputnum, infile);
else
basefile = basename_safe(infile);
//logverb("Base filename: %s\n", basefile);
isurl = (!file_exists(infile) &&
(starts_with(infile, "http://") ||
starts_with(infile, "ftp://")));
if (outdir)
basedir = strdup(outdir);
else {
if (isurl)
basedir = strdup(".");
else
basedir = dirname_safe(infile);
}
//logverb("Base directory: %s\n", basedir);
asprintf_safe(&base, "%s/%s", basedir, basefile);
//logverb("Base name for output files: %s\n", base);
// trim .gz, .bz2
// hmm, we drop the suffix in this case...
len = strlen(base);
if (ends_with(base, ".gz"))
base[len-3] = '\0';
else if (ends_with(base, ".bz2"))
base[len-4] = '\0';
len = strlen(base);
// trim .xx / .xxx / .xxxx
if (len >= 5) {
for (j=3; j<=5; j++) {
if (base[len - j] == '/')
break;
if (base[len - j] == '.') {
base[len - j] = '\0';
suffix = base + len - j + 1;
break;
}
}
}
logverb("Base: \"%s\", basefile \"%s\", basedir \"%s\", suffix \"%s\"\n", base, basefile, basedir, suffix);
if (tempaxy) {
axy->axyfn = create_temp_file("axy", axy->tempdir);
sl_append_nocopy(tempfiles2, axy->axyfn);
} else
axy->axyfn = sl_appendf(outfiles, axy->axyfn, base);
if (axy->matchfn)
axy->matchfn = sl_appendf(outfiles, axy->matchfn, base);
if (axy->rdlsfn)
axy->rdlsfn = sl_appendf(outfiles, axy->rdlsfn, base);
if (axy->solvedfn)
axy->solvedfn = sl_appendf(outfiles, axy->solvedfn, base);
if (axy->wcsfn)
axy->wcsfn = sl_appendf(outfiles, axy->wcsfn, base);
if (axy->corrfn)
axy->corrfn = sl_appendf(outfiles, axy->corrfn, base);
if (axy->cancelfn)
axy->cancelfn = sl_appendf(outfiles, axy->cancelfn, base);
if (axy->keepxylsfn)
axy->keepxylsfn = sl_appendf(outfiles, axy->keepxylsfn, base);
if (axy->pnmfn)
axy->pnmfn = sl_appendf(outfiles, axy->pnmfn, base);
if (newfits)
sf->newfitsfn = sl_appendf(outfiles, newfits, base);
if (kmz)
sf->kmzfn = sl_appendf(outfiles, kmz, base);
if (index_xyls)
sf->indxylsfn = sl_appendf(outfiles, index_xyls, base);
if (scamp)
sf->scampfn = sl_appendf(outfiles, scamp, base);
if (scampconfig)
sf->scampconfigfn = sl_appendf(outfiles, scampconfig, base);
if (makeplots) {
objsfn = sl_appendf(outfiles, "%s-objs.png", base);
sf->redgreenfn = sl_appendf(outfiles, "%s-indx.png", base);
sf->ngcfn = sl_appendf(outfiles, "%s-ngc.png", base);
}
if (isurl) {
if (suffix)
downloadfn = sl_appendf(outfiles, "%s.%s", base, suffix);
else
downloadfn = sl_appendf(outfiles, "%s", base);
}
if (axy->solvedinfn)
asprintf_safe(&axy->solvedinfn, axy->solvedinfn, base);
// Do %s replacement on --verify-wcs entries...
if (sl_size(axy->verifywcs)) {
sl* newlist = sl_new(4);
for (j=0; j<sl_size(axy->verifywcs); j++)
sl_appendf(newlist, sl_get(axy->verifywcs, j), base);
axy->verifywcs = newlist;
}
// ... and plot-bg
if (inbgfn)
asprintf_safe(&bgfn, inbgfn, base);
if (axy->solvedinfn && axy->solvedfn && streq(axy->solvedfn, axy->solvedinfn)) {
// solved input and output files are the same: don't delete the input!
sl_remove_string(outfiles, axy->solvedfn);
free(axy->solvedfn);
axy->solvedfn = axy->solvedinfn;
}
free(basedir);
free(basefile);
if (skip_solved) {
char* tocheck[] = { axy->solvedinfn, axy->solvedfn };
for (j=0; j<sizeof(tocheck)/sizeof(char*); j++) {
if (!tocheck[j])
continue;
logverb("Checking for solved file %s\n", tocheck[j]);
if (file_exists(tocheck[j])) {
logmsg("Solved file exists: %s; skipping this input file.\n", tocheck[j]);
goto nextfile;
} else {
logverb("File \"%s\" does not exist.\n", tocheck[j]);
}
}
}
// Check for overlap between input and output filenames
for (i = 0; i < sl_size(outfiles); i++) {
char* fn = sl_get(outfiles, i);
if (streq(fn, infile)) {
logmsg("Output filename \"%s\" is the same as your input file.\n"
"Refusing to continue.\n"
"You can either choose a different output filename, or\n"
"rename your input file to have a different extension.\n", fn);
goto nextfile;
}
}
// Check for (and possibly delete) existing output filenames.
for (i = 0; i < sl_size(outfiles); i++) {
char* fn = sl_get(outfiles, i);
if (!file_exists(fn))
continue;
if (cont) {
} else if (overwrite) {
if (unlink(fn)) {
SYSERROR("Failed to delete an already-existing output file \"%s\"", fn);
exit(-1);
}
} else {
logmsg("Output file already exists: \"%s\".\n"
"Use the --overwrite flag to overwrite existing files,\n"
" or the --continue flag to not overwrite existing files but still try solving.\n", fn);
logmsg("Continuing to next input file.\n");
goto nextfile;
}
}
// if we're making "redgreen" plot, we need:
if (sf->redgreenfn) {
// -- index xylist
if (!sf->indxylsfn) {
sf->indxylsfn = create_temp_file("indxyls", axy->tempdir);
sl_append_nocopy(tempfiles, sf->indxylsfn);
}
// -- match file.
if (!axy->matchfn) {
axy->matchfn = create_temp_file("match", axy->tempdir);
sl_append_nocopy(tempfiles, axy->matchfn);
}
}
// if index xyls file is needed, we need:
if (sf->indxylsfn) {
// -- wcs
if (!axy->wcsfn) {
axy->wcsfn = create_temp_file("wcs", axy->tempdir);
sl_append_nocopy(tempfiles, axy->wcsfn);
}
// -- rdls
if (!axy->rdlsfn) {
axy->rdlsfn = create_temp_file("rdls", axy->tempdir);
sl_append_nocopy(tempfiles, axy->rdlsfn);
}
}
// Download URL...
if (isurl) {
sl_append(cmdline, usecurl ? "curl" : "wget");
if (!verbose)
sl_append(cmdline, usecurl ? "--silent" : "--quiet");
sl_append(cmdline, usecurl ? "--output" : "-O");
append_escape(cmdline, downloadfn);
append_escape(cmdline, infile);
cmd = sl_implode(cmdline, " ");
logmsg("Downloading...\n");
if (run_command(cmd, &ctrlc)) {
ERROR("%s command %s", sl_get(cmdline, 0),
(ctrlc ? "was cancelled" : "failed"));
exit(-1);
}
sl_remove_all(cmdline);
free(cmd);
infile = downloadfn;
}
if (makeplots)
want_pnm = TRUE;
if (axy->assume_fits_image) {
axy->imagefn = infile;
if (axy->pnmfn)
want_pnm = TRUE;
} else {
logverb("Checking if file \"%s\" ext %i is xylist or image: ",
infile, axy->extension);
fflush(NULL);
reason = NULL;
isxyls = xylist_is_file_xylist(infile, axy->extension,
axy->xcol, axy->ycol, &reason);
logverb(isxyls ? "xyls\n" : "image\n");
if (!isxyls)
logverb(" (not xyls because: %s)\n", reason);
free(reason);
fflush(NULL);
if (isxyls)
axy->xylsfn = infile;
else {
axy->imagefn = infile;
want_pnm = TRUE;
}
}
if (want_pnm && !axy->pnmfn) {
ppmfn = create_temp_file("ppm", axy->tempdir);
sl_append_nocopy(tempfiles, ppmfn);
axy->pnmfn = ppmfn;
axy->force_ppm = TRUE;
}
axy->keep_fitsimg = (newfits || scamp);
if (augment_xylist(axy, me)) {
ERROR("augment-xylist failed");
exit(-1);
}
if (just_augment)
goto nextfile;
if (makeplots) {
// Check that the plotting executables were built...
char* exec = find_executable("plotxy", me);
free(exec);
if (!exec) {
logmsg("Couldn't find \"plotxy\" executable - maybe you didn't build the plotting programs?\n");
logmsg("Disabling plots.\n");
makeplots = FALSE;
}
}
if (makeplots) {
// source extraction overlay
if (plot_source_overlay(axy, me, objsfn, plotscale, bgfn))
makeplots = FALSE;
}
append_escape(engineargs, axy->axyfn);
if (file_readable(axy->wcsfn))
axy->wcs_last_mod = file_get_last_modified_time(axy->wcsfn);
else
axy->wcs_last_mod = 0;
if (!engine_batch) {
run_engine(engineargs);
after_solved(axy, sf, makeplots, me, verbose,
axy->tempdir, tempdirs, tempfiles, plotscale, bgfn);
} else {
bl_append(batchaxy, axy);
bl_append(batchsf, sf );
}
fflush(NULL);
// clean up and move on to the next file.
nextfile:
free(base);
sl_free2(cmdline);
if (!engine_batch) {
free(axy->fitsimgfn);
free(axy->solvedinfn);
free(bgfn);
// erm.
if (axy->verifywcs != allaxy->verifywcs)
sl_free2(axy->verifywcs);
sl_remove_all(outfiles);
if (!axy->no_delete_temp)
delete_temp_files(tempfiles, tempdirs);
}
errors_print_stack(stdout);
errors_clear_stack();
logmsg("\n");
}
if (engine_batch) {
run_engine(engineargs);
for (i=0; i<bl_size(batchaxy); i++) {
augment_xylist_t* axy = bl_access(batchaxy, i);
solve_field_args_t* sf = bl_access(batchsf, i);
after_solved(axy, sf, makeplots, me, verbose,
axy->tempdir, tempdirs, tempfiles, plotscale, bgfn);
errors_print_stack(stdout);
errors_clear_stack();
logmsg("\n");
free(axy->fitsimgfn);
free(axy->solvedinfn);
// erm.
if (axy->verifywcs != allaxy->verifywcs)
sl_free2(axy->verifywcs);
}
if (!allaxy->no_delete_temp)
delete_temp_files(tempfiles, tempdirs);
bl_free(batchaxy);
bl_free(batchsf);
}
if (!allaxy->no_delete_temp)
delete_temp_files(tempfiles2, NULL);
sl_free2(outfiles);
sl_free2(tempfiles);
sl_free2(tempfiles2);
sl_free2(tempdirs);
sl_free2(engineargs);
free(me);
augment_xylist_free_contents(allaxy);
return 0;
}
