/* Report internal state on SIGUSR1. */
static void
report (void)
{
FILE *rfp, *old;
mode_t old_umask;
old_umask = umask (S_IRWXG | S_IRWXO);
rfp = monitor_fopen (report_file, "w");
umask (old_umask);
if (!rfp)
{
log_error ("fopen (\"%s\", \"w\") failed", report_file);
return;
}
/* Divert the log channel to the report file during the report. */
old = log_current ();
log_to (rfp);
ui_report ("r");
log_to (old);
fclose (rfp);
sigusr1ed = 0;
}
//---------------------------------------------------------------------------
void PortsOpenAll()
{
#ifndef ONEGAME
Str ErrorText,ErrorTitle;
log_to(LOGSECTION_INIT,"STARTUP: Opening MIDIPort");
MIDIPort.Create(ErrorText,ErrorTitle,true);
log_to(LOGSECTION_INIT,"STARTUP: Opening ParallelPort");
ParallelPort.Create(ErrorText,ErrorTitle,true);
log_to(LOGSECTION_INIT,"STARTUP: Opening SerialPort");
SerialPort.Create(ErrorText,ErrorTitle,true);
log_to(LOGSECTION_INIT,"STARTUP: SerialPort opened");
#ifdef UNIX
UNIX_ONLY( XGUIUpdatePortDisplay(); )
#endif
#endif
}
/* This function is where the privileged process waits(loops) indefinitely. */
void
monitor_loop(int debug)
{
int msgcode;
if (!debug)
log_to(0);
for (;;) {
must_read(&msgcode, sizeof msgcode);
switch (msgcode) {
case MONITOR_GET_FD:
m_priv_getfd();
break;
case MONITOR_PFKEY_OPEN:
LOG_DBG((LOG_MISC, 80,
"monitor_loop: MONITOR_PFKEY_OPEN"));
m_priv_pfkey_open();
break;
case MONITOR_SETSOCKOPT:
LOG_DBG((LOG_MISC, 80,
"monitor_loop: MONITOR_SETSOCKOPT"));
m_priv_setsockopt();
break;
case MONITOR_BIND:
LOG_DBG((LOG_MISC, 80,
"monitor_loop: MONITOR_BIND"));
m_priv_bind();
break;
case MONITOR_REQ_READDIR:
LOG_DBG((LOG_MISC, 80,
"monitor_loop: MONITOR_REQ_READDIR"));
m_priv_req_readdir();
break;
case MONITOR_INIT_DONE:
LOG_DBG((LOG_MISC, 80,
"monitor_loop: MONITOR_INIT_DONE"));
break;
case MONITOR_SHUTDOWN:
LOG_DBG((LOG_MISC, 80,
"monitor_loop: MONITOR_SHUTDOWN"));
break;
default:
log_print("monitor_loop: got unknown code %d",
msgcode);
}
}
exit(0);
}
void test_log_func(CuTest* tc) {
log_init(LOG_VERB);
teststruc_t ts;
ts.magic = 42;
log_use_function(logfunc, &ts);
log_to(NULL);
logmsg("Testing 1 2 3\n");
logdebug("Testing 1 2 3\n");
log_use_function(NULL, NULL);
log_to(stdout);
logmsg("Testing 1 2 3 4\n");
logdebug("Testing 1 2 3 4\n");
}
void* thread2(void* v) {
FILE* flog = v;
logmsg("I'm thread 2.\n");
log_set_level(LOG_VERB);
log_to(flog);
logmsg("%s\n", STRING2A);
logverb("%s\n", STRING2B);
return NULL;
}
void* thread1(void* v) {
FILE* flog = v;
logmsg("I'm thread 1.\n");
log_set_level(LOG_MSG);
log_to(flog);
logmsg("%s\n", STRING1A);
sleep(1);
logverb("%s\n", STRING1B);
return NULL;
}
int
main (int argc, char **argv, char **envp)
{
set_identity (argv[0]);
log_to (LOGTO_STDERR);
setlocale (LC_ALL, "");
bindtextdomain (PACKAGE, LOCALEDIR);
textdomain (PACKAGE);
parse_options (argc, argv, envp);
if (show_version)
{
printf (_("%s version %s (built %s %s, protocol version %d.%d)\n"), get_identity (),
VERSION, __DATE__, __TIME__, PROTOCOL_MAJOR, PROTOCOL_MINOR);
printf (_("Built with kernel interface %s/%s.\n"), IFTYPE, IFSUBTYPE);
printf (_
("Copyright (C) 2003-2008 Marc Lehmann <*****@*****.**> and others.\n"
"See the AUTHORS file for a complete list.\n\n"
"vpe comes with ABSOLUTELY NO WARRANTY. This is free software,\n"
"and you are welcome to redistribute it under certain conditions;\n"
"see the file COPYING for details.\n"));
return 0;
}
if (show_help)
usage (0);
{
configuration_parser (conf, false, 0, 0);
}
if (generate_keys)
{
RAND_load_file ("/dev/urandom", 1024);
exit (keygen (generate_keys));
}
if (kill_gvpe)
exit (kill_other (kill_gvpe));
if (show_config)
{
conf.print ();
exit (EXIT_SUCCESS);
}
usage (1);
}
void receive_run(const char* channel, const char* file)
{
int socket = os_listen(channel);
int log = os_flash_open(file, WRITE);
while (true) {
uint8_t buffer[10];
size_t len;
while(tc_receive(socket, buffer, sizeof(buffer), &len) != SUCCESS);
len -= len % sizeof(int32_t);
log_to(log, buffer, len);
}
}
void receive_run(const char* channel, const char* file)
{
void* receive_handle = receive_wire(channel);
void* logw_handle = logw_wire(file);
while (true) {
net_message_t msg;
void* payload;
uint8_t len;
error_t res = receive_receive(receive_handle, &msg, &payload, &len);
assert (res == SUCCESS);
log_to(logw_handle, payload, len);
}
}
void collect_run(const char* device, const char* file, unsigned dt)
{
int sensor = os_sensor_open(device);
int log = os_flash_open(file, WRITE);
uint32_t now = os_now();
while (true) {
tc_sleep(now + dt);
now += dt;
sensor_val_t val;
while (tc_sensor_read(sensor, &val) != SUCCESS);
log_to(log, (uint8_t*)&val, sizeof(sensor_val_t));
}
}
int main(int argc, const char ** argv)
{
std::cout << "starting desperion" << std::endl;
logger::create();
#ifndef DEBUG
statistics_center::create(LOGIN_VERSION_MAJOR, LOGIN_VERSION_MINOR, LOGIN_VERSION_RELEASE);
#endif
try {
while (application::create().run(argc, argv) == shutdown_type::REBOOT)
application::kill();
} catch (const std::exception & e) {
utils::color<utils::TRED>(std::cout) << "an error occured, please see log files"
<< utils::cendl;
log_to("error") << "unhandled exception: " << e.what() << "\n";
}
return 0;
}
/*---------------------------------------------------------------------------*/
void dma_sound_set_control(BYTE io_src_b)
{
if ((dma_sound_control & BIT_0) && (io_src_b & BIT_0)==0){ //Stopping
dma_sound_start=next_dma_sound_start;
dma_sound_end=next_dma_sound_end;
dma_sound_fetch_address=dma_sound_start;
}else if ((dma_sound_control & BIT_0)==0 && (io_src_b & BIT_0)){ //Start playing
dma_sound_start=next_dma_sound_start;
dma_sound_end=next_dma_sound_end;
dma_sound_fetch_address=dma_sound_start;
if (dma_sound_on_this_screen==0){
// Pad buffer with last byte from VBL to current position
bool Mono=bool(dma_sound_mode & BIT_7);
int freq_idx=0;
if (shifter_freq_at_start_of_vbl==60) freq_idx=1;
if (shifter_freq_at_start_of_vbl==MONO_HZ) freq_idx=2;
WORD w1,w2;
dma_sound_get_last_sample(&w1,&w2);
for (int y=-scanlines_above_screen[freq_idx];y<scan_y;y++){
if (Mono){ //play half as many words
dma_sound_samples_countdown+=dma_sound_freq*scanline_time_in_cpu_cycles_at_start_of_vbl/2;
}else{ //stereo, 1 word per sample
dma_sound_samples_countdown+=dma_sound_freq*scanline_time_in_cpu_cycles_at_start_of_vbl;
}
int loop=int(Mono ? 2:1);
while (dma_sound_samples_countdown>=0){
for (int i=0;i<loop;i++){
dma_sound_output_countdown+=sound_freq;
while (dma_sound_output_countdown>=0){
if (dma_sound_channel_buf_last_write_t>=DMA_SOUND_BUFFER_LENGTH) break;
dma_sound_channel_buf[dma_sound_channel_buf_last_write_t++]=w1;
dma_sound_channel_buf[dma_sound_channel_buf_last_write_t++]=w2;
dma_sound_output_countdown-=dma_sound_freq;
}
}
dma_sound_samples_countdown-=n_cpu_cycles_per_second;
}
}
dma_sound_on_this_screen=1;
}
}
log_to(LOGSECTION_SOUND,EasyStr("SOUND: ")+HEXSl(old_pc,6)+" - DMA sound control set to "+(io_src_b & 3)+" from "+(dma_sound_control & 3));
dma_sound_control=io_src_b;
if (tos_version>=0x106) mfp_gpip_set_bit(MFP_GPIP_MONO_BIT,bool(COLOUR_MONITOR)^bool(dma_sound_control & BIT_0));
}
void collect_run(const char* sensor, const char* file, unsigned dt)
{
void* sensor_handle = sensor_wire(sensor);
void* logw_handle = logw_wire(file);
void* timer_handle = timer_wire();
uint32_t now = timer_getNow(timer_handle);
while (true) {
timer_sleep(timer_handle, now + dt);
now += dt;
sensor_val_t val;
error_t res = sensor_read(sensor_handle, &val);
assert (res == SUCCESS);
log_to(logw_handle, &val, sizeof(sensor_val_t));
}
}
/**
* 2015-08-10
* see: http://www.gnu.org/software/libc/manual/html_node/Termination-in-Handler.html#Termination-in-Handler
*/
void sig_handler(int sig)
{
/* Since this handler is established for more than one kind of signal, it might still
* get invoked recursively by delivery of some other kind of signal. Use a static
* variable to keep track of that.
*/
if (fatal_error_in_progress != 0) {
(void)raise(sig);
}
fatal_error_in_progress = 1;
psignal(sig, "Auto shutdown invoked.");
log_bug("Critical signal received %d", sig);
log_to(LOG_SINK_LASTCMD, "%s", globalSystemState.last_command);
auto_shutdown();
/* Now reraise the signal. We reactivate the signal’s default handling, which is to
* terminate the process. We could just call exit or abort, but reraising the signal
* sets the return status from the process correctly, and, more importantly, gives us
* a core dump.
*/
(void)signal(sig, SIG_DFL);
(void)raise(sig);
}
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;
}
shutdown_type application::impl::run(int argc, const char ** argv)
{
std::list<std::string> targets;
if (_config.get_property("log_info", LOG_INFO_DEFAULT))
targets.emplace_back("info");
if (_config.get_property("log_debug", LOG_DEBUG_DEFAULT))
targets.emplace_back("debug");
if (_config.get_property("log_error", LOG_ERROR_DEFAULT))
targets.emplace_back("error");
logger::instance().set_targets(std::move(targets));
std::ostringstream version;
version << LOGIN_VERSION_MAJOR << "." << LOGIN_VERSION_MINOR
<< "." << LOGIN_VERSION_RELEASE;
_owner->set_title("desperion login server v" + version.str());
std::cout << "\n";
utils::color<utils::TBLUE>(std::cout)
<< ",------, ,-----. ,-----, ,------. ,-----. ,------. ,------. ,------, ,, ,,\n"
<< "| ,--, ` | .---' | ,--` | ,--, | | .---' | ,--, | `--||--' | ,--, | ||\\ ||\n"
<< "| | | | | |--. | `--, | | | | | |--. | | | | || | | | | || \\ ||\n"
<< "| | | | | |--' `---, | | `--` | | |--' | `--` , || | | | | || \\ ||\n"
<< "| '--' , | '---, ,---| | | ,----` | '---, | ,-\\ \\ .--||--, | '--' | || \\||\n"
<< "`------` `-----' `-----` `-` `-----' `-` '--' `------` `------` `` `'\n";
utils::color<utils::TGREEN>(std::cout)
<< "Dofus v" << protocol::DOFUS_VERSION_MAJOR << "." << protocol::DOFUS_VERSION_MINOR << "."
<< protocol::DOFUS_VERSION_RELEASE << "." << protocol::DOFUS_VERSION_REVISION << "."
<< protocol::DOFUS_VERSION_PATCH << "/" << protocol::DOFUS_VERSION_BUILD_TYPE << ", protocol "
<< protocol::PROTOCOL_BUILD << "/" << protocol::PROTOCOL_REQUIRED_BUILD << "\n"
<< "login server v" << version.str() << ", build date: " << __DATE__
<< " " << __TIME__ << "\n" << utils::cendl;
try {
start_database();
} catch (const sql_error & e) {
utils::color<utils::TRED>(std::cout) << "an sql error occured, please see log files"
<< utils::cendl;
log_to("error") << "sql error: " << e.what() << "\n";
return shutdown_type::NORMAL;
}
_world.init();
session::load_patch();
socket_listener listener;
auto port = _config.get_property("server_port", SERVER_PORT_DEFAULT);
listener.listen<session>(port);
port = _config.get_property("system_port", SERVER_PORT_DEFAULT);
listener.listen<game_session>(port);
std::cout << "\nuptime " << _owner->uptime() << " microseconds" << std::endl;
listener.spawn_threads(_config.get_property("pool_threads", POOL_THREADS_DEFAULT));
std::thread t { std::bind(&run_service, std::ref(_owner->_service)) };
std::mutex m;
std::unique_lock<std::mutex> lock { m };
while (_owner->get_shutdown() == shutdown_type::NOT_REQUESTED)
_owner->_condition.wait(lock);
listener.stop();
t.join();
return _owner->get_shutdown();
}
int main(int argc, char *args[]) {
int argchar;
char* progname = args[0];
plot_args_t pargs;
plotxy_t* xy;
plotimage_t* img;
int loglvl = LOG_MSG;
// log errors to stderr, not stdout.
errors_log_to(stderr);
plotstuff_init(&pargs);
pargs.fout = stdout;
pargs.outformat = PLOTSTUFF_FORMAT_PNG;
xy = plotstuff_get_config(&pargs, "xy");
img = plotstuff_get_config(&pargs, "image");
assert(xy);
assert(img);
plotstuff_set_color(&pargs, "white");
plotstuff_set_bgcolor(&pargs, "black");
img->format = PLOTSTUFF_FORMAT_PPM;
while ((argchar = getopt(argc, args, OPTIONS)) != -1)
switch (argchar) {
case 'v':
loglvl++;
break;
case 'C':
plotstuff_set_color(&pargs, optarg);
break;
case 'b':
plotstuff_set_bgcolor(&pargs, "optarg");
break;
case 'o':
pargs.outfn = optarg;
break;
case 'X':
plot_xy_set_xcol(xy, optarg);
break;
case 'Y':
plot_xy_set_ycol(xy, optarg);
break;
case 'P':
pargs.outformat = PLOTSTUFF_FORMAT_PPM;
break;
case 'J':
pargs.outformat = PLOTSTUFF_FORMAT_PDF;
break;
case 'p':
img->format = PLOTSTUFF_FORMAT_PNG;
break;
case 'I':
plot_image_set_filename(img, optarg);
break;
case 'S':
xy->scale = atof(optarg);
break;
case 'i':
plot_xy_set_filename(xy, optarg);
break;
case 'x':
xy->xoff = atof(optarg);
break;
case 'y':
xy->yoff = atof(optarg);
break;
case 'W':
pargs.W = atoi(optarg);
break;
case 'H':
pargs.H = atoi(optarg);
break;
case 'n':
xy->firstobj = atoi(optarg);
break;
case 'N':
xy->nobjs = atoi(optarg);
break;
case 'e':
xy->ext = atoi(optarg);
break;
case 'r':
pargs.markersize = atof(optarg);
break;
case 'w':
pargs.lw = atof(optarg);
break;
case 's':
plotstuff_set_marker(&pargs, optarg);
break;
case 'h':
printHelp(progname);
exit(0);
case '?':
default:
printHelp(progname);
exit(-1);
}
if (optind != argc) {
printHelp(progname);
exit(-1);
}
if (!xy->fn) {
printHelp(progname);
exit(-1);
}
log_init(loglvl);
log_to(stderr);
fits_use_error_system();
if (img->fn) {
if (plot_image_setsize(&pargs, img)) {
ERROR("Failed to set plot size from image");
exit(-1);
}
plotstuff_run_command(&pargs, "image");
} else {
if (pargs.W == 0 || pargs.H == 0) {
if (plot_xy_setsize(&pargs, xy)) {
ERROR("Failed to set plot size from xylist");
exit(-1);
}
}
}
plotstuff_run_command(&pargs, "xy");
plotstuff_output(&pargs);
plotstuff_free(&pargs);
return 0;
}
int
main(int argc, char *argv[])
{
printf("ISAKMP: main : <<<START>>> \n");
fd_set *rfds, *wfds;
int n, m;
size_t mask_size;
struct timeval tv, *timeout;
// closefrom(STDERR_FILENO + 1);
/*
* Make sure init() won't alloc fd 0, 1 or 2, as daemon() will close
* them.
*/
/*
for (n = 0; n <= 2; n++)
if (fcntl(n, F_GETFL, 0) == -1 && errno == EBADF)
(void) open("/dev/null", n ? O_WRONLY : O_RDONLY, 0);
*/
/* Log cmd line parsing and initialization errors to stderr. */
log_to(stderr);
parse_args(argc, argv);
log_init(debug);
/* Open protocols and services databases. */
setprotoent(1);
setservent(1);
/* Open command fifo */
ui_init();
set_slave_signals();
/* Daemonize before forking unpriv'ed child */
if (!debug)
if (daemon(0, 0))
log_fatal("main: daemon (0, 0) failed");
/* Set timezone before priv'separation */
tzset();
write_pid_file();
/*
if (monitor_init(debug)) {
// The parent, with privileges enters infinite monitor loop.
//monitor_loop(debug);
//exit(0); // Never reached.
}*/
/* Child process only from this point on, no privileges left. */
init();
/* If we wanted IKE packet capture to file, initialize it now. */
if (pcap_file != 0)
log_packet_init(pcap_file);
/* Allocate the file descriptor sets just big enough. */
// we change here
//n = getdtablesize();
n = 1000;
mask_size = howmany(n, NFDBITS) * sizeof(fd_mask);
rfds = (fd_set *) malloc(mask_size);
if (!rfds)
log_fatal("main: malloc (%lu) failed",
(unsigned long)mask_size);
wfds = (fd_set *) malloc(mask_size);
if (!wfds)
log_fatal("main: malloc (%lu) failed",
(unsigned long)mask_size);
//monitor_init_done();
while (1) {
/* If someone has sent SIGHUP to us, reconfigure. */
if (sighupped) {
sighupped = 0;
log_print("SIGHUP received");
reinit();
}
/* and if someone sent SIGUSR1, do a state report. */
if (sigusr1ed) {
sigusr1ed = 0;
log_print("SIGUSR1 received");
report();
}
/*
* and if someone set 'sigtermed' (SIGTERM, SIGINT or via the
* UI), this indicates we should start a controlled shutdown
* of the daemon.
*
* Note: Since _one_ message is sent per iteration of this
* enclosing while-loop, and we want to send a number of
* DELETE notifications, we must loop atleast this number of
* times. The daemon_shutdown() function starts by queueing
* the DELETEs, all other calls just increments the
* 'sigtermed' variable until it reaches a "safe" value, and
* the daemon exits.
*/
if (sigtermed)
daemon_shutdown();
/* Setup the descriptors to look for incoming messages at. */
bzero(rfds, mask_size);
n = transport_fd_set(rfds);
FD_SET(ui_socket, rfds);
if (ui_socket + 1 > n)
n = ui_socket + 1;
/*
* XXX Some day we might want to deal with an abstract
* application class instead, with many instantiations
* possible.
*/
if (!app_none && app_socket >= 0) {
FD_SET(app_socket, rfds);
if (app_socket + 1 > n)
n = app_socket + 1;
}
/* Setup the descriptors that have pending messages to send. */
bzero(wfds, mask_size);
m = transport_pending_wfd_set(wfds);
printf(" m = %d , n = %d \n", m,n);
if (m > n)
n = m;
/* Find out when the next timed event is. */
timeout = &tv;
timer_next_event(&timeout);
printf(" select (n n= %d )\n ",n );
n = select(n, rfds, wfds, 0, timeout);
if (n == -1) {
if (errno != EINTR) {
log_error("main: select");
/*
* In order to give the unexpected error
* condition time to resolve without letting
* this process eat up all available CPU
* we sleep for a short while.
*/
sleep(1);
}
} else if (n) {
transport_handle_messages(rfds);
transport_send_messages(wfds);
if (FD_ISSET(ui_socket, rfds))
ui_handler();
if (!app_none && app_socket >= 0 &&
FD_ISSET(app_socket, rfds))
app_handler();
}
timer_handle_expirations();
}
}
static int read_parameters(blind_t* bp) {
solver_t* sp = &(bp->solver);
for (;;) {
char buffer[10240];
char* nextword;
char* line;
if (!fgets(buffer, sizeof(buffer), stdin)) {
return -1;
}
line = buffer;
// strip off newline
if (line[strlen(line) - 1] == '\n')
line[strlen(line) - 1] = '\0';
// skip leading whitespace:
while (*line && isspace(*line))
line++;
logverb("Command: %s\n", line);
if (line[0] == '#') {
//logmsg("Skipping comment.\n");
continue;
}
// skip blank lines.
if (line[0] == '\0') {
continue;
}
if (is_word(line, "help", &nextword)) {
logmsg("No help soup for you!\n (use the source, Luke)\n");
} else if (is_word(line, "logtostderr", &nextword)) {
log_to(stderr);
} else if (is_word(line, "verbose", &nextword)) {
log_init(LOG_VERB);
} else if (is_word(line, "verify ", &nextword)) {
sl_append(bp->verify_wcsfiles, nextword);
} else if (is_word(line, "verify_wcs ", &nextword)) {
sip_t wcs;
int nread;
memset(&wcs, 0, sizeof(wcs));
if (sscanf(nextword, "%lg %lg %lg %lg %lg %lg %lg %lg%n",
&(wcs.wcstan.crval[0]), &(wcs.wcstan.crval[1]),
&(wcs.wcstan.crpix[0]), &(wcs.wcstan.crpix[1]),
&(wcs.wcstan.cd[0][0]), &(wcs.wcstan.cd[0][1]),
&(wcs.wcstan.cd[1][0]), &(wcs.wcstan.cd[1][1]),
&nread) < 8) {
logerr("Failed to parse verify_wcs entry.\n");
continue;
}
nextword += nread;
if (sscanf(nextword, " %i %i%n", &(wcs.a_order), &(wcs.ap_order), &nread) >= 2) {
int m, n;
wcs.b_order = wcs.a_order;
wcs.bp_order = wcs.ap_order;
nextword += nread;
for (m=0; m<=wcs.a_order; m++) {
for (n=0; (m+n)<=wcs.a_order; n++) {
if (sscanf(nextword, " %lg %lg%n", &(wcs.a[m][n]), &(wcs.b[m][n]), &nread) < 2) {
logerr("Failed to parse SIP terms: \"%s\"\n", nextword);
continue;
}
nextword += nread;
}
}
for (m=0; m<=wcs.ap_order; m++) {
for (n=0; (m+n)<=wcs.ap_order; n++) {
if (sscanf(nextword, " %lg %lg%n", &(wcs.ap[m][n]), &(wcs.bp[m][n]), &nread) < 2) {
logerr("Failed to parse SIP terms: \"%s\"\n", nextword);
continue;
}
nextword += nread;
}
}
}
blind_add_verify_wcs(bp, &wcs);
} else if (is_word(line, "cpulimit ", &nextword)) {
bp->cpulimit = atof(nextword);
} else if (is_word(line, "timelimit ", &nextword)) {
bp->timelimit = atoi(nextword);
} else if (is_word(line, "total_timelimit ", &nextword)) {
bp->total_timelimit = atof(nextword);
} else if (is_word(line, "total_cpulimit ", &nextword)) {
bp->total_cpulimit = atof(nextword);
} else if (is_word(line, "verify_pix ", &nextword)) {
sp->verify_pix = atof(nextword);
} else if (is_word(line, "nsolves ", &nextword)) {
bp->nsolves = atoi(nextword);
} else if (is_word(line, "ratio_tosolve ", &nextword)) {
bp->logratio_tosolve = log(atof(nextword));
} else if (is_word(line, "ratio_tokeep ", &nextword)) {
sp->logratio_tokeep = log(atof(nextword));
} else if (is_word(line, "ratio_toprint ", &nextword)) {
sp->logratio_toprint = log(atof(nextword));
} else if (is_word(line, "ratio_tobail ", &nextword)) {
sp->logratio_bail_threshold = log(atof(nextword));
} else if (is_word(line, "match ", &nextword)) {
blind_set_match_file(bp, nextword);
} else if (is_word(line, "indexrdls ", &nextword)) {
blind_set_rdls_file(bp, nextword);
} else if (is_word(line, "correspondences ", &nextword)) {
free(bp->corr_fname);
bp->corr_fname = strdup(nextword);
} else if (is_word(line, "best_only", &nextword)) {
bp->best_hit_only = TRUE;
} else if (is_word(line, "solved ", &nextword)) {
blind_set_solved_file(bp, nextword);
} else if (is_word(line, "solved_in ", &nextword)) {
blind_set_solvedin_file(bp, nextword);
} else if (is_word(line, "solved_out ", &nextword)) {
blind_set_solvedout_file(bp, nextword);
} else if (is_word(line, "cancel ", &nextword)) {
blind_set_cancel_file(bp, nextword);
} else if (is_word(line, "solvedserver ", &nextword)) {
free(bp->solvedserver);
bp->solvedserver = strdup(nextword);
} else if (is_word(line, "tweak_skipshift", &nextword)) {
// deprecated
} else if (is_word(line, "tweak_aborder ", &nextword)) {
sp->tweak_aborder = atoi(nextword);
} else if (is_word(line, "tweak_abporder ", &nextword)) {
sp->tweak_abporder = atoi(nextword);
} else if (is_word(line, "tweak", &nextword)) {
sp->do_tweak = TRUE;
} else if (is_word(line, "wcs ", &nextword)) {
blind_set_wcs_file(bp, nextword);
} else if (is_word(line, "fieldid_key ", &nextword)) {
free(bp->fieldid_key);
bp->fieldid_key = strdup(nextword);
} else if (is_word(line, "maxquads ", &nextword)) {
sp->maxquads = atoi(nextword);
} else if (is_word(line, "maxmatches ", &nextword)) {
sp->maxmatches = atoi(nextword);
} else if (is_word(line, "xcol ", &nextword)) {
blind_set_xcol(bp, nextword);
} else if (is_word(line, "ycol ", &nextword)) {
blind_set_ycol(bp, nextword);
} else if (is_word(line, "index ", &nextword)) {
blind_add_index(bp, nextword);
} else if (is_word(line, "indexes_inparallel", &nextword)) {
bp->indexes_inparallel = TRUE;
} else if (is_word(line, "field ", &nextword)) {
blind_set_field_file(bp, nextword);
} else if (is_word(line, "fieldw ", &nextword)) {
sp->field_maxx = atof(nextword);
} else if (is_word(line, "fieldh ", &nextword)) {
sp->field_maxy = atof(nextword);
} else if (is_word(line, "distractors ", &nextword)) {
sp->distractor_ratio = atof(nextword);
} else if (is_word(line, "fieldid ", &nextword)) {
bp->fieldid = atoi(nextword);
} else if (is_word(line, "sdepth ", &nextword)) {
sp->startobj = atoi(nextword);
} else if (is_word(line, "depth ", &nextword)) {
sp->endobj = atoi(nextword);
} else if (is_word(line, "tol ", &nextword)) {
sp->codetol = atof(nextword);
} else if (is_word(line, "parity ", &nextword)) {
sp->parity = atoi(nextword);
} else if (is_word(line, "quadsize_min ", &nextword)) {
sp->quadsize_min = atof(nextword);
} else if (is_word(line, "fieldunits_lower ", &nextword)) {
sp->funits_lower = atof(nextword);
} else if (is_word(line, "fieldunits_upper ", &nextword)) {
sp->funits_upper = atof(nextword);
} else if (is_word(line, "firstfield ", &nextword)) {
bp->firstfield = atoi(nextword);
} else if (is_word(line, "lastfield ", &nextword)) {
bp->lastfield = atoi(nextword);
} else if (is_word(line, "fields ", &nextword)) {
char* str = nextword;
while (str && *str) {
unsigned int lo, hi;
int nread;
if (sscanf(str, "%u%*1[-/]%u", &lo, &hi) == 2) {
sscanf(str, "%*u%*1[-/]%*u%n", &nread);
} else if (sscanf(str, "%u", &lo) == 1) {
sscanf(str, "%*u%n", &nread);
hi = lo;
} else {
fprintf(stderr, "Failed to parse fields fragment: \"%s\"\n", str);
return -1;
}
if (lo < 1) {
fprintf(stderr, "Field number %i is invalid: must be >= 1.\n", lo);
return -1;
}
if (lo > hi) {
fprintf(stderr, "Field range %i to %i is invalid: max must be >= min!\n", lo, hi);
return -1;
}
blind_add_field_range(bp, lo, hi);
str += nread;
while ((*str == ',') || isspace(*str))
str++;
}
} else if (is_word(line, "run", &nextword)) {
return 0;
} else if (is_word(line, "quit", &nextword)) {
return 1;
} else if (is_word(line, "nverify ", &nextword)) {
logmsg("DEPRECATED: \"nverify\" command.\n");
} else if (is_word(line, "nindex_tosolve ", &nextword)) {
logmsg("DEPRECATED: \"nindex_tosolve\" command.\n");
} else if (is_word(line, "nindex_tokeep ", &nextword)) {
logmsg("DEPRECATED: \"nindex_tokeep\" command.\n");
} else {
logmsg("I didn't understand this command:\n \"%s\"\n", line);
}
}
}
int main(int argc, char *argv[]) {
int argchar;
char* infn = NULL;
char* outfn = NULL;
FILE* fout;
anbool tostdout = FALSE;
anqfits_t* anq;
int W, H;
qfits_header* hdr;
const anqfits_image_t* animg;
float* img;
int loglvl = LOG_MSG;
int scale = 2;
int winw;
int winh;
int plane;
int out_bitpix = -32;
float* outimg;
int outw, outh;
int edge = EDGE_TRUNCATE;
int ext = 0;
int npixout = 0;
while ((argchar = getopt (argc, argv, OPTIONS)) != -1)
switch (argchar) {
case 'v':
loglvl++;
break;
case 's':
scale = atoi(optarg);
break;
case 'e':
ext = atoi(optarg);
break;
case '?':
case 'h':
printHelp(argv[0]);
return 0;
default:
return -1;
}
log_init(loglvl);
log_to(stderr);
errors_log_to(stderr);
fits_use_error_system();
if (argc - optind != 2) {
logerr("Need two arguments: input and output files.\n");
printHelp(argv[0]);
exit(-1);
}
infn = argv[optind];
outfn = argv[optind+1];
if (streq(outfn, "-")) {
tostdout = TRUE;
fout = stdout;
} else {
fout = fopen(outfn, "wb");
if (!fout) {
SYSERROR("Failed to open output file \"%s\"", outfn);
exit(-1);
}
}
anq = anqfits_open(infn);
if (!anq) {
ERROR("Failed to open input file \"%s\"", infn);
exit(-1);
}
animg = anqfits_get_image_const(anq, ext);
W = (int)animg->width;
H = (int)animg->height;
if (!animg) {
ERROR("Failde to read image from \"%s\"", infn);
exit(-1);
}
/*
if (tostdout)
dump.filename = "STDOUT";
else
dump.filename = outfn;
dump.ptype = PTYPE_FLOAT;
dump.out_ptype = out_bitpix;
*/
get_output_image_size(W % scale, H % scale,
scale, edge, &outw, &outh);
outw += (W / scale);
outh += (H / scale);
hdr = qfits_header_default();
fits_header_add_int(hdr, "BITPIX", out_bitpix, "bits per pixel");
if (animg->planes > 1)
fits_header_add_int(hdr, "NAXIS", 3, "number of axes");
else
fits_header_add_int(hdr, "NAXIS", 2, "number of axes");
fits_header_add_int(hdr, "NAXIS1", outw, "image width");
fits_header_add_int(hdr, "NAXIS2", outh, "image height");
if (animg->planes > 1)
fits_header_add_int(hdr, "NAXIS3", animg->planes, "number of planes");
if (qfits_header_dump(hdr, fout)) {
ERROR("Failed to write FITS header to \"%s\"", outfn);
exit(-1);
}
qfits_header_destroy(hdr);
winw = W;
winh = (int)ceil(ceil(1024*1024 / (float)winw) / (float)scale) * scale;
outimg = malloc((int)ceil(winw/scale)*(int)ceil(winh/scale) * sizeof(float));
logmsg("Image is %i x %i x %i\n", W, H, (int)animg->planes);
logmsg("Output will be %i x %i x %i\n", outw, outh, (int)animg->planes);
logverb("Reading in blocks of %i x %i\n", winw, winh);
for (plane=0; plane<animg->planes; plane++) {
int bx, by;
int nx, ny;
for (by=0; by<(int)ceil(H / (float)winh); by++) {
for (bx=0; bx<(int)ceil(W / (float)winw); bx++) {
int i;
int lox, loy, hix, hiy, outw, outh;
nx = MIN(winw, W - bx*winw);
ny = MIN(winh, H - by*winh);
lox = bx*winw;
loy = by*winh;
hix = lox + nx;
hiy = loy + ny;
logverb(" reading %i,%i + %i,%i\n", lox, loy, nx, ny);
img = anqfits_readpix(anq, ext, lox, hix, loy, hiy, plane,
PTYPE_FLOAT, NULL, &W, &H);
if (!img) {
ERROR("Failed to load pixel window: x=[%i, %i), y=[%i,%i), plane %i\n",
lox, hix, loy, hiy, plane);
exit(-1);
}
average_image_f(img, nx, ny, scale, edge,
&outw, &outh, outimg);
free(img);
logverb(" writing %i x %i\n", outw, outh);
if (outw * outh == 0)
continue;
for (i=0; i<outw*outh; i++) {
int nbytes = abs(out_bitpix)/8;
char buf[nbytes];
if (qfits_pixel_ctofits(PTYPE_FLOAT, out_bitpix,
outimg + i, buf)) {
ERROR("Failed to convert pixel to FITS type\n");
exit(-1);
}
if (fwrite(buf, nbytes, 1, fout) != 1) {
ERROR("Failed to write pixels\n");
exit(-1);
}
}
npixout += outw*outh;
}
}
}
free(outimg);
anqfits_close(anq);
if (tostdout) {
// pad.
int N;
char pad[2880];
N = (npixout * (abs(out_bitpix) / 8)) % 2880;
memset(pad, 0, 2880);
fwrite(pad, 1, N, fout);
} else {
if (fits_pad_file(fout)) {
ERROR("Failed to pad output file");
exit(-1);
}
if (fclose(fout)) {
SYSERROR("Failed to close output file");
exit(-1);
}
}
logverb("Done!\n");
return 0;
}
int
main (int argc, char *argv[])
{
fd_set *rfds, *wfds;
int n, m;
size_t mask_size;
struct timeval tv, *timeout;
/* Make sure init() won't alloc fd 0, 1 or 2, as daemon() will close them. */
for (n = 0; n <= 2; n++)
if (fcntl (n, F_GETFL, 0) == -1 && errno == EBADF)
(void)open ("/dev/null", n ? O_WRONLY : O_RDONLY, 0);
/* Log cmd line parsing and initialization errors to stderr. */
log_to (stderr);
parse_args (argc, argv);
log_init ();
/* Do a clean daemon shutdown on TERM reception. (Needed by monitor). */
signal (SIGTERM, daemon_shutdown_now);
if (debug) signal (SIGINT, daemon_shutdown_now);
#if defined (USE_PRIVSEP)
if (monitor_init ())
{
/* The parent, with privileges. */
if (!debug)
if (daemon (0, 0))
log_fatal ("main [priv]: daemon (0, 0) failed");
/* Enter infinite monitor loop. */
monitor_loop (debug);
exit (0); /* Never reached. */
}
/* Child process only from this point on, no privileges left. */
#endif
init ();
if (!debug)
{
if (daemon (0, 0))
log_fatal ("main: daemon (0, 0) failed");
/* Switch to syslog. */
log_to (0);
}
write_pid_file ();
/* Reinitialize on HUP reception. */
signal (SIGHUP, sighup);
/* Report state on USR1 reception. */
signal (SIGUSR1, sigusr1);
/* Rehash soft expiration timers on USR2 reception. */
signal (SIGUSR2, sigusr2);
#if defined (USE_DEBUG)
/* If we wanted IKE packet capture to file, initialize it now. */
if (pcap_file != 0)
log_packet_init (pcap_file);
#endif
/* Allocate the file descriptor sets just big enough. */
n = getdtablesize ();
mask_size = howmany (n, NFDBITS) * sizeof (fd_mask);
rfds = (fd_set *)malloc (mask_size);
if (!rfds)
log_fatal ("main: malloc (%lu) failed", (unsigned long)mask_size);
wfds = (fd_set *)malloc (mask_size);
if (!wfds)
log_fatal ("main: malloc (%lu) failed", (unsigned long)mask_size);
while (1)
{
/* If someone has sent SIGHUP to us, reconfigure. */
if (sighupped)
{
log_print ("SIGHUP received");
reinit ();
sighupped = 0;
}
/* and if someone sent SIGUSR1, do a state report. */
if (sigusr1ed)
{
log_print ("SIGUSR1 received");
report ();
}
/* and if someone sent SIGUSR2, do a timer rehash. */
if (sigusr2ed)
{
log_print ("SIGUSR2 received");
rehash_timers ();
}
/*
* and if someone set 'sigtermed' (SIGTERM or via the UI), this
* indicated we should start a shutdown of the daemon.
*
* Note: Since _one_ message is sent per iteration of this enclosing
* while-loop, and we want to send a number of DELETE notifications,
* we must loop atleast this number of times. The daemon_shutdown()
* function starts by queueing the DELETEs, all other calls just
* increments the 'sigtermed' variable until it reaches a "safe"
* value, and the daemon exits.
*/
if (sigtermed)
daemon_shutdown ();
/* Setup the descriptors to look for incoming messages at. */
memset (rfds, 0, mask_size);
n = transport_fd_set (rfds);
FD_SET (ui_socket, rfds);
if (ui_socket + 1 > n)
n = ui_socket + 1;
/*
* XXX Some day we might want to deal with an abstract application
* class instead, with many instantiations possible.
*/
if (!app_none && app_socket >= 0)
{
FD_SET (app_socket, rfds);
if (app_socket + 1 > n)
n = app_socket + 1;
}
/* Setup the descriptors that have pending messages to send. */
memset (wfds, 0, mask_size);
m = transport_pending_wfd_set (wfds);
if (m > n)
n = m;
/* Find out when the next timed event is. */
timeout = &tv;
timer_next_event (&timeout);
n = select (n, rfds, wfds, 0, timeout);
if (n == -1)
{
if (errno != EINTR)
{
log_error ("select");
/*
* In order to give the unexpected error condition time to
* resolve without letting this process eat up all available CPU
* we sleep for a short while.
*/
sleep (1);
}
}
else if (n)
{
transport_handle_messages (rfds);
transport_send_messages (wfds);
if (FD_ISSET (ui_socket, rfds))
ui_handler ();
if (!app_none && app_socket >= 0 && FD_ISSET (app_socket, rfds))
app_handler ();
}
timer_handle_expirations ();
}
}
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;
}
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;
}
int main(int argc, char** args) {
int c;
dl* xys = dl_new(16);
dl* radecs = dl_new(16);
dl* otherradecs = dl_new(16);
double* xy;
double* xyz;
int i, N;
tan_t tan, tan2, tan3;
int W=0, H=0;
double crpix[] = { HUGE_VAL, HUGE_VAL };
int loglvl = LOG_MSG;
FILE* logstream = stderr;
int order = 1;
while ((c = getopt(argc, args, OPTIONS)) != -1) {
switch (c) {
case 'v':
loglvl++;
break;
case 'h':
exit(0);
case 'o':
order = atoi(optarg);
break;
case 'W':
W = atoi(optarg);
break;
case 'H':
H = atoi(optarg);
break;
case 'X':
crpix[0] = atof(optarg);
break;
case 'Y':
crpix[1] = atof(optarg);
break;
}
}
if (optind != argc) {
exit(-1);
}
log_init(loglvl);
log_to(logstream);
errors_log_to(logstream);
if (W == 0 || H == 0) {
logerr("Need -W, -H\n");
exit(-1);
}
if (crpix[0] == HUGE_VAL)
crpix[0] = W/2.0;
if (crpix[1] == HUGE_VAL)
crpix[1] = H/2.0;
while (1) {
double x,y,ra,dec;
if (fscanf(stdin, "%lf %lf %lf %lf\n", &x, &y, &ra, &dec) < 4)
break;
if (x == -1 && y == -1) {
dl_append(otherradecs, ra);
dl_append(otherradecs, dec);
} else {
dl_append(xys, x);
dl_append(xys, y);
dl_append(radecs, ra);
dl_append(radecs, dec);
}
}
logmsg("Read %i x,y,ra,dec tuples\n", dl_size(xys)/2);
N = dl_size(xys)/2;
xy = dl_to_array(xys);
xyz = malloc(3 * N * sizeof(double));
for (i=0; i<N; i++)
radecdeg2xyzarr(dl_get(radecs, 2*i), dl_get(radecs, 2*i+1), xyz + i*3);
dl_free(xys);
dl_free(radecs);
fit_tan_wcs(xyz, xy, N, &tan, NULL);
tan.imagew = W;
tan.imageh = H;
logmsg("Computed TAN WCS:\n");
tan_print_to(&tan, logstream);
sip_t* sip;
{
tweak_t* t = tweak_new();
starxy_t* sxy = starxy_new(N, FALSE, FALSE);
il* imginds = il_new(256);
il* refinds = il_new(256);
for (i=0; i<N; i++) {
starxy_set_x(sxy, i, xy[2*i+0]);
starxy_set_y(sxy, i, xy[2*i+1]);
}
tweak_init(t);
tweak_push_ref_xyz(t, xyz, N);
tweak_push_image_xy(t, sxy);
for (i=0; i<N; i++) {
il_append(imginds, i);
il_append(refinds, i);
}
// unweighted; no dist2s
tweak_push_correspondence_indices(t, imginds, refinds, NULL, NULL);
tweak_push_wcs_tan(t, &tan);
t->sip->a_order = t->sip->b_order = t->sip->ap_order = t->sip->bp_order = order;
for (i=0; i<10; i++) {
// go to TWEAK_HAS_LINEAR_CD -> do_sip_tweak
// t->image has the indices of corresponding image stars
// t->ref has the indices of corresponding catalog stars
tweak_go_to(t, TWEAK_HAS_LINEAR_CD);
logmsg("\n");
sip_print(t->sip);
t->state &= ~TWEAK_HAS_LINEAR_CD;
}
tan_write_to_file(&t->sip->wcstan, "kt1.wcs");
sip = t->sip;
}
for (i=0; i<dl_size(otherradecs)/2; i++) {
double ra, dec, x,y;
ra = dl_get(otherradecs, 2*i);
dec = dl_get(otherradecs, 2*i+1);
if (!sip_radec2pixelxy(sip, ra, dec, &x, &y)) {
logerr("Not in tangent plane: %g,%g\n", ra, dec);
exit(-1);
//continue;
}
printf("%g %g\n", x, y);
}
/*
blind_wcs_move_tangent_point(xyz, xy, N, crpix, &tan, &tan2);
blind_wcs_move_tangent_point(xyz, xy, N, crpix, &tan2, &tan3);
logmsg("Moved tangent point to (%g,%g):\n", crpix[0], crpix[1]);
tan_print_to(&tan3, logstream);
tan_write_to_file(&tan, "kt1.wcs");
tan_write_to_file(&tan3, "kt2.wcs");
*/
dl_free(otherradecs);
free(xy);
free(xyz);
return 0;
}
int main(int argc, char** args) {
char* default_configfn = "astrometry.cfg";
char* default_config_path = "../etc";
int c;
char* configfn = NULL;
int i;
engine_t* engine;
char* mydir = NULL;
char* basedir = NULL;
char* me;
anbool help = FALSE;
sl* strings = sl_new(4);
char* cancelfn = NULL;
char* solvedfn = NULL;
int loglvl = LOG_MSG;
anbool tostderr = FALSE;
char* infn = NULL;
FILE* fin = NULL;
anbool fromstdin = FALSE;
bl* opts = opts_from_array(myopts, sizeof(myopts)/sizeof(an_option_t), NULL);
sl* inds = sl_new(4);
char* datalog = NULL;
engine = engine_new();
while (1) {
c = opts_getopt(opts, argc, args);
if (c == -1)
break;
switch (c) {
case 'D':
datalog = optarg;
break;
case 'p':
engine->inparallel = TRUE;
break;
case 'i':
sl_append(inds, optarg);
break;
case 'd':
basedir = optarg;
break;
case 'f':
infn = optarg;
fromstdin = streq(infn, "-");
break;
case 'E':
tostderr = TRUE;
break;
case 'h':
help = TRUE;
break;
case 'v':
loglvl++;
break;
case 's':
solvedfn = optarg;
case 'C':
cancelfn = optarg;
break;
case 'c':
configfn = strdup(optarg);
break;
case '?':
break;
default:
printf("Unknown flag %c\n", c);
exit( -1);
}
}
if (optind == argc && !infn) {
// Need extra args: filename
printf("You must specify at least one input file!\n\n");
help = TRUE;
}
if (help) {
print_help(args[0], opts);
exit(0);
}
bl_free(opts);
gslutils_use_error_system();
log_init(loglvl);
if (tostderr)
log_to(stderr);
if (datalog) {
datalogfid = fopen(datalog, "wb");
if (!datalogfid) {
SYSERROR("Failed to open data log file \"%s\" for writing", datalog);
return -1;
}
atexit(close_datalogfid);
data_log_init(100);
data_log_enable_all();
data_log_to(datalogfid);
data_log_start();
}
if (infn) {
logverb("Reading input filenames from %s\n", (fromstdin ? "stdin" : infn));
if (!fromstdin) {
fin = fopen(infn, "rb");
if (!fin) {
ERROR("Failed to open file %s for reading input filenames", infn);
exit(-1);
}
} else
fin = stdin;
}
// directory containing the 'engine' executable:
me = find_executable(args[0], NULL);
if (!me)
me = strdup(args[0]);
mydir = sl_append(strings, dirname(me));
free(me);
// Read config file
if (!configfn) {
int i;
sl* trycf = sl_new(4);
sl_appendf(trycf, "%s/%s/%s", mydir, default_config_path, default_configfn);
// if I'm in /usr/bin, look for config file in /etc
if (streq(mydir, "/usr/bin")) {
sl_appendf(trycf, "/etc/%s", default_configfn);
}
sl_appendf(trycf, "%s/%s", mydir, default_configfn);
sl_appendf(trycf, "./%s", default_configfn);
sl_appendf(trycf, "./%s/%s", default_config_path, default_configfn);
for (i=0; i<sl_size(trycf); i++) {
char* cf = sl_get(trycf, i);
if (file_exists(cf)) {
configfn = strdup(cf);
logverb("Using config file \"%s\"\n", cf);
break;
} else {
logverb("Config file \"%s\" doesn't exist.\n", cf);
}
}
if (!configfn) {
char* cflist = sl_join(trycf, "\n ");
logerr("Couldn't find config file: tried:\n %s\n", cflist);
free(cflist);
}
sl_free2(trycf);
}
if (!streq(configfn, "none")) {
if (engine_parse_config_file(engine, configfn)) {
logerr("Failed to parse (or encountered an error while interpreting) config file \"%s\"\n", configfn);
exit( -1);
}
}
if (sl_size(inds)) {
// Expand globs.
for (i=0; i<sl_size(inds); i++) {
char* s = sl_get(inds, i);
glob_t myglob;
int flags = GLOB_TILDE | GLOB_BRACE;
if (glob(s, flags, NULL, &myglob)) {
SYSERROR("Failed to expand wildcards in index-file path \"%s\"", s);
exit(-1);
}
for (c=0; c<myglob.gl_pathc; c++) {
if (engine_add_index(engine, myglob.gl_pathv[c])) {
ERROR("Failed to add index \"%s\"", myglob.gl_pathv[c]);
exit(-1);
}
}
globfree(&myglob);
}
}
if (!pl_size(engine->indexes)) {
logerr("\n\n"
"---------------------------------------------------------------------\n"
"You must list at least one index in the config file (%s)\n\n"
"See http://astrometry.net/use.html about how to get some index files.\n"
"---------------------------------------------------------------------\n"
"\n", configfn);
exit(-1);
}
if (engine->minwidth <= 0.0 || engine->maxwidth <= 0.0) {
logerr("\"minwidth\" and \"maxwidth\" in the config file %s must be positive!\n", configfn);
exit(-1);
}
free(configfn);
if (!il_size(engine->default_depths)) {
parse_depth_string(engine->default_depths,
"10 20 30 40 50 60 70 80 90 100 "
"110 120 130 140 150 160 170 180 190 200");
}
engine->cancelfn = cancelfn;
engine->solvedfn = solvedfn;
i = optind;
while (1) {
char* jobfn;
job_t* job;
struct timeval tv1, tv2;
if (infn) {
// Read name of next input file to be read.
logverb("\nWaiting for next input filename...\n");
jobfn = read_string_terminated(fin, "\n\r\0", 3, FALSE);
if (strlen(jobfn) == 0)
break;
} else {
if (i == argc)
break;
jobfn = args[i];
i++;
}
gettimeofday(&tv1, NULL);
logmsg("Reading file \"%s\"...\n", jobfn);
job = engine_read_job_file(engine, jobfn);
if (!job) {
ERROR("Failed to read job file \"%s\"", jobfn);
exit(-1);
}
if (basedir) {
logverb("Setting job's output base directory to %s\n", basedir);
job_set_output_base_dir(job, basedir);
}
if (engine_run_job(engine, job))
logerr("Failed to run_job()\n");
job_free(job);
gettimeofday(&tv2, NULL);
logverb("Spent %g seconds on this field.\n", millis_between(&tv1, &tv2)/1000.0);
}
engine_free(engine);
sl_free2(strings);
sl_free2(inds);
if (fin && !fromstdin)
fclose(fin);
return 0;
}
//---------------------------------------------------------------------------
void dma_sound_set_mode(BYTE new_mode)
{
dma_sound_mode=new_mode;
dma_sound_freq=dma_sound_mode_to_freq[dma_sound_mode & 3];
log_to(LOGSECTION_SOUND,EasyStr("SOUND: ")+HEXSl(old_pc,6)+" - DMA sound mode set to $"+HEXSl(dma_sound_mode,2)+" freq="+dma_sound_freq);
}
