int main(int argc, char *argv[])
{
ProgramMode mode;
LHAOptions options;
#ifdef TEST_BUILD
// When running tests, give output to stdout in binary mode;
// on Windows, this gives the expected output (which was
// constructed for Unix):
lha_arch_set_binary(stdout);
#endif
// Parse the command line options and run command.
// As a shortcut, a single argument can be provided to list the
// contents of an archive ("lha foo.lzh" == "lha l foo.lzh").
init_options(&options);
if (argc >= 3 && parse_command_line(argv[1], &mode, &options)) {
return !do_command(mode, argv[2], &options,
argv + 3, argc - 3);
} else if (argc == 2) {
return !do_command(MODE_LIST, argv[1], &options, NULL, 0);
} else {
help_page(argv[0]);
return 0;
}
}
void pager_fn(player * p, char *str)
{
ed_info *e;
e = p->edit_info;
if((int)strlen(str)<2) {
switch (tolower(*str))
{
case 0:
/* player hit return - next page */
forward_page(p, e);
break;
case 'p':
back_page(p, e);
break;
case 'n':
forward_page(p, e);
break;
case 'l':
last_page(p, e);
break;
case 'f':
e->current = e->buffer;
e->size = 0;
break;
case '?':
help_page(p);
p->input_to_fn = pager_help_pause;
return;
case 'q':
quit_pager(p, e);
return;
case 'r':
/* redraw the screen */
break;
default:
/* this is what happens if it doesnt recognise the command */
p->input_to_fn = 0;
input_for_one(p);
p->input_to_fn = pager_fn;
draw_page(p, e->current, 0);
return;
}
if (!draw_page(p, e->current, 1))
quit_pager(p, e);
}
else {
p->input_to_fn = 0;
input_for_one(p);
p->input_to_fn = pager_fn;
draw_page(p, e->current, 0);
}
}
/*--------------------------------------------------------------------*/
INT cnafsub(BOOL cmd_mode, char *cmd)
{
char str[128], line[128];
INT status, j;
CAMAC *P, *p = NULL, *job;
/* Loop return label */
if (jobflag) {
jobflag = FALSE;
}
/* Load default CAMAC */
P = Prompt;
while (1) {
if (!cmd_mode) {
make_display_string(MAIN, P, addr);
/* prompt */
printf("mCNAF> [%s] :", addr);
ss_gets(str, 128);
} else {
strcpy(str, cmd);
}
/* decode line */
status = decode_line(P, str);
if (status == QUIT)
return status;
else if (status == MCSTD) {
mcstd_func(P);
status = decode_line(P, str);
} else if (status == HELP)
help_page(MAIN);
else if (status == JOB) {
if (!cmd_mode) {
/* interactive session, display default job name */
printf("\nmCNAF> Job file name [%s]:", job_name);
ss_gets(line, 128);
if (strlen(line) == 0)
strcpy(line, job_name); // Use default
else {
strcpy(job_name, line);
}
} else {
/* from command line, skip @ */
strcpy(line, &str[1]);
}
/* Check if file exists */
status = read_job_file(pF, CHECK, &job, line);
if (status == JOB)
status = read_job_file(pF, READ, &job, line);
}
if (status == LOOP || status == JOB) {
for (j = 0; j < P->r; j++) {
if (status == LOOP)
p = P;
if (status == JOB)
p = job;
while (p->m) {
if (p->n == 28 || p->n == 29 || p->n == 30)
cc_services(p);
else if (p->m == 24) { /* Actual 24 bits CAMAC operation */
if (p->f < 8)
cam24i_q(p->c, p->n, p->a, p->f, &p->d24, &p->x, &p->q);
else if (p->f < 16)
camc_q(p->c, p->n, p->a, p->f, &p->q);
else if (p->f < 24)
cam24o_q(p->c, p->n, p->a, p->f, p->d24, &p->x, &p->q);
else
camc_q(p->c, p->n, p->a, p->f, &p->q);
}
else {
if (p->f < 16) /* Actual 16 bits CAMAC operation */
cam16i_q(p->c, p->n, p->a, p->f, &p->d16, &p->x, &p->q);
else if (p->f < 24)
cam16o_q(p->c, p->n, p->a, p->f, (WORD)p->d24, &p->x, &p->q);
else
camc_q(p->c, p->n, p->a, p->f, &p->q);
}
make_display_string(MAIN, p, addr);
/* Result display */
if (p->r > 1) {
/* repeat mode */
if (status == JOB) {
if (!cmd_mode)
printf("\nmCNAF> [%s]", addr);
if (p->w != 0)
ss_sleep(p->w);
} else {
if (!cmd_mode)
printf("mCNAF> [%s] <-%03i\n", addr, j + 1);
if (p->w != 0)
ss_sleep(p->w);
if (j > p->r - 1)
break;
}
} else {
/* single command */
if (status == JOB) {
if (!cmd_mode)
printf("mCNAF> [%s]\n", addr);
if (p->w != 0)
ss_sleep(p->w);
}
}
p++;
}
};
if (status == JOB) {
free(job);
if (!cmd_mode)
printf("\n");
}
}
if (cmd_mode)
break;
}
return status;
}
/*--------------------------------------------------------------------*/
void mcstd_func(CAMAC * PP)
{
char paddr[128], pstr[128];
int i, status, pstatus = 0;
WORD dd16[100];
WORD *pdd16;
DWORD dd24[100];
DWORD *pdd24;
DWORD lam;
CAMAC *p;
/* Load default CAMAC */
// PP = &Prompt[1];
while (1) {
make_display_string(MCSTD, PP, paddr);
/* prompt */
printf("MCStd> [%s] :", paddr);
ss_gets(pstr, 128);
/* decode line */
status = decode_line(PP, pstr);
p = PP;
if (status == LOOP)
status = pstatus;
if (status != SKIP && status != HELP)
pstatus = status;
i = 0;
pdd16 = dd16;
pdd24 = dd24;
switch (status) {
/* system */
case CAMST:
printf("cam_op\n");
cam_op();
break;
case CAM_LAM_ENABLE:
cam_lam_enable(p->c, p->n);
printf("cam_lam_enable:C%i-N%i\n", p->c, p->n);
break;
case CAM_LAM_DISABLE:
cam_lam_disable(p->c, p->n);
printf("cam_lam_disable:C%i-N%i\n", p->c, p->n);
break;
case CAM_LAM_READ:
cam_lam_read(p->c, &lam);
printf("cam_lam_read:C%i-> 0x%x\n", p->c, lam);
break;
case CAM_LAM_CLEAR:
cam_lam_clear(p->c, p->n);
printf("cam_lam_clear:C%i \n", p->c);
break;
case CAM_INHIBIT_SET:
cam_inhibit_set(p->c);
printf("cam_inhibit_set:C%i\n", p->c);
break;
case CAM_INHIBIT_CLEAR:
cam_inhibit_clear(p->c);
printf("cam_inhibit_clear:C%i\n", p->c);
break;
case CAM_CRATE_CLEAR:
cam_crate_clear(p->c);
printf("cam_crate_clear:C%i\n", p->c);
break;
case CAM_CRATE_ZINIT:
cam_crate_zinit(p->c);
printf("cam_crate_zinit:C%i\n", p->c);
break;
/* command */
case CAMC:
do {
camc(p->c, p->n, p->a, p->f);
printf("camc:[R%i]-C%i-N%i-A%i-F%i\n", ++i, p->c, p->n, p->a, p->f);
} while (i < p->r);
break;
case CAMC_Q:
do {
camc_q(p->c, p->n, p->a, p->f, &p->q);
printf("camc_q:[R%i]-C%i-N%i-A%i-F%i -Q:%i\n", ++i, p->c, p->n, p->a, p->f,
p->q);
} while (i < p->r);
break;
case CAMC_SA:
camc(p->c, p->n, p->a, p->f);
printf("camc_sa:C%i-N%i-A%i-F%i\n", p->c, p->n, p->a, p->f);
break;
case CAMC_SN:
camc(p->c, p->n, p->a, p->f);
printf("camc_sn:C%i-N%i-A%i-F%i\n", p->c, p->n, p->a, p->f);
break;
/* output */
case CAM16O:
do {
cam16o(p->c, p->n, p->a, p->f, p->d16);
printf("cam16o:[R%i]-C%i-N%i-A%i-F%i <- 0x%x\n", ++i, p->c, p->n, p->a, p->f,
p->d16);
} while (i < p->r);
break;
case CAM24O:
do {
cam24o(p->c, p->n, p->a, p->f, p->d24);
printf("cam24o:[R%i]-C%i-N%i-A%i-F%i <- 0x%x\n", ++i, p->c, p->n, p->a, p->f,
p->d24);
} while (i < p->r);
break;
case CAM16O_Q:
do {
cam16o_q(p->c, p->n, p->a, p->f, p->d16, &p->x, &p->q);
printf("cam16o_q:[R%i]-C%i-N%i-A%i-F%i <- 0x%x X:%i-Q:%i\n", ++i, p->c, p->n,
p->a, p->f, p->d16, p->x, p->q);
} while (i < p->r);
break;
case CAM24O_Q:
do {
cam24o_q(p->c, p->n, p->a, p->f, p->d24, &p->x, &p->q);
printf("cam24o_q:[R%i]-C%i-N%i-A%i-F%i <- 0x%x X:%i-Q:%i\n", ++i, p->c, p->n,
p->a, p->f, p->d24, p->x, p->q);
} while (i < p->r);
break;
case CAM16O_R:
cam16o_r(p->c, p->n, p->a, p->f, pdd16, p->r);
printf("cam16o_r:C%i-N%i-A%i-F%i <- 0x%x\n", p->c, p->n, p->a, p->f, p->d16);
break;
case CAM24O_R:
cam24o_r(p->c, p->n, p->a, p->f, pdd24, p->r);
printf("cam24o_r:C%i-N%i-A%i-F%i <- 0x%x\n", p->c, p->n, p->a, p->f, p->d24);
break;
/* inputs */
case CAM16I:
do {
cam16i(p->c, p->n, p->a, p->f, &p->d16);
printf("cam16i:[R%i]-C%i-N%i-A%i-F%i-> 0x%4.4x\n", ++i, p->c, p->n, p->a,
p->f, p->d16);
} while (i < p->r);
break;
case CAM24I:
do {
cam24i(p->c, p->n, p->a, p->f, &p->d24);
printf("cam24i:[R%i]-C%i-N%i-A%i-F%i-> 0x%6.6x\n", ++i, p->c, p->n, p->a,
p->f, p->d24);
} while (i < p->r);
break;
case CAM16I_Q:
do {
cam16i_q(p->c, p->n, p->a, p->f, &p->d16, &p->x, &p->q);
printf("cam16i_q:[R%i]-C%i-N%i-A%i-F%i-> 0x%4.4x X:%i-Q:%i\n", ++i, p->c,
p->n, p->a, p->f, p->d16, p->x, p->q);
} while (i < p->r);
break;
case CAM24I_Q:
do {
cam24i_q(p->c, p->n, p->a, p->f, &p->d24, &p->x, &p->q);
printf("cam24i_q:[R%i]-C%i-N%i-A%i-F%i-> 0x%6.6x X:%i-Q:%i\n", ++i, p->c,
p->n, p->a, p->f, p->d24, p->x, p->q);
} while (i < p->r);
break;
case CAM16I_R:
memset(pdd16, 0, sizeof(dd16));
cam16i_r(p->c, p->n, p->a, p->f, &pdd16, p->r);
for (i = 0; i < p->r; i++)
printf("cam16i_r:[R%i]-C%i-N%i-A%i-F%i-> 0x%4.4x\n", i + 1, p->c, p->n, p->a,
p->f, dd16[i]);
break;
case CAM24I_R:
memset(pdd24, 0, sizeof(dd24));
cam24i_r(p->c, p->n, p->a, p->f, &pdd24, p->r);
for (i = 0; i < p->r; i++)
printf("cam24i_r:[R%i]-C%i-N%i-A%i-F%i-> 0x%6.6x\n", i + 1, p->c, p->n, p->a,
p->f, dd24[i]);
break;
case CAM16I_RQ:
memset(pdd16, 0, sizeof(dd16));
cam16i_rq(p->c, p->n, p->a, p->f, &pdd16, p->r);
for (i = 0; i < p->r; i++)
printf("cam16i_rq:[R%i]-C%i-N%i-A%i-F%i-> 0x%4.4x\n", i + 1, p->c, p->n, p->a,
p->f, dd16[i]);
break;
case CAM24I_RQ:
memset(pdd24, 0, sizeof(dd24));
cam24i_rq(p->c, p->n, p->a, p->f, &pdd24, p->r);
for (i = 0; i < p->r; i++)
printf("cam24i_rq:[R%i]-C%i-N%i-A%i-F%i-> 0x%6.6x\n", i + 1, p->c, p->n,
p->a, p->f, dd24[i]);
break;
case CAM16I_SA:
memset(pdd16, 0, sizeof(dd16));
cam16i_sa(p->c, p->n, p->a, p->f, &pdd16, p->r);
for (i = 0; i < p->r; i++)
printf("cam16i_sa:[R%i]-C%i-N%i-A%i-F%i-> 0x%4.4x\n", i + 1, p->c, p->n,
p->a + i, p->f, dd16[i]);
break;
case CAM24I_SA:
memset(pdd24, 0, sizeof(dd24));
cam24i_sa(p->c, p->n, p->a, p->f, &pdd24, p->r);
for (i = 0; i < p->r; i++)
printf("cam24i_sa:[R%i]-C%i-N%i-A%i-F%i-> 0x%6.6x\n", i + 1, p->c, p->n,
p->a + i, p->f, dd24[i]);
break;
case CAM16I_SN:
memset(pdd16, 0, sizeof(dd16));
cam16i_sa(p->c, p->n, p->a, p->f, &pdd16, p->r);
for (i = 0; i < p->r; i++)
printf("cam16i_sn:[R%i]-C%i-N%i-A%i-F%i-> 0x%x\n", i + 1, p->c, p->n + i,
p->a, p->f, dd16[i]);
break;
case CAM24I_SN:
memset(pdd24, 0, sizeof(dd24));
cam24i_sn(p->c, p->n, p->a, p->f, &pdd24, p->r);
for (i = 0; i < p->r; i++)
printf("cam24i_sn:[R%i]-C%i-N%i-A%i-F%i-> 0x%x\n", i + 1, p->c, p->n + i,
p->a, p->f, dd24[i]);
break;
case QUIT:
p->r = 1;
return;
case HELP:
help_page(MCSTD);
break;
case SKIP:
break;
default:
status = SKIP;
break;
}
}
}
int
page_switch()
{
register char *s;
switch (*buf) {
case 'd':
case Ctl('d'): /* half page */
special = TRUE;
slines = LINES / 2 + 1;
if (marking && *blinebeg != '\f'
#ifdef CUSTOMLINES
&& (!pagestop || blinebeg != art_buf ||
!execute(&page_compex,blinebeg))
#endif
) {
up_line();
highlight = --artline;
restart = blinebeg;
artpos = alinebeg;
}
return PS_NORM;
case '!': /* shell escape */
escapade();
return PS_ASK;
#ifdef INNERSEARCH
case Ctl('i'):
gline = 3;
sprintf(cmd_buf,"^[^%c]",*blinebeg);
compile(&gcompex,cmd_buf,TRUE,TRUE);
goto caseG;
case Ctl('g'):
gline = 3;
compile(&gcompex,"^Subject:",TRUE,TRUE);
goto caseG;
case 'g': /* in-article search */
if (!finish_command(FALSE))/* get rest of command */
return PS_ASK;
s = buf+1;
if (isspace(*s))
s++;
if ((s = compile(&gcompex,s,TRUE,TRUE)) != Nullch) {
/* compile regular expression */
printf("\n%s\n",s) FLUSH;
return PS_ASK;
}
carriage_return();
erase_eol(); /* erase the prompt */
/* FALL THROUGH */
caseG:
case 'G': {
/* ART_LINE lines_to_skip = 0; */
ART_POS start_where;
if (gline < 0 || gline > LINES-2)
gline = LINES-2;
#ifdef DEBUGGING
if (debug & DEB_INNERSRCH)
printf("Start here? %d >=? %d\n",topline + gline + 1,artline)
FLUSH;
#endif
if (*buf == Ctl('i') || topline+gline+1 >= artline)
start_where = artpos;
/* in case we had a line wrap */
else {
start_where = vrdary(topline+gline+1);
if (start_where < 0)
start_where = -start_where;
}
if (start_where < htype[PAST_HEADER].ht_minpos)
start_where = htype[PAST_HEADER].ht_minpos;
fseek(artfp,(long)start_where,0);
innersearch = 0; /* assume not found */
while (fgets(buf, sizeof buf, artfp) != Nullch) {
/* lines_to_skip++; NOT USED NOW */
#ifdef DEBUGGING
if (debug & DEB_INNERSRCH)
printf("Test %s",buf) FLUSH;
#endif
if (execute(&gcompex,buf) != Nullch) {
innersearch = ftell(artfp);
break;
}
}
if (!innersearch) {
fseek(artfp,artpos,0);
fputs("(Not found)",stdout) FLUSH;
return PS_ASK;
}
#ifdef DEBUGGING
if (debug & DEB_INNERSRCH)
printf("On page? %ld <=? %ld\n",(long)innersearch,(long)artpos)
FLUSH;
#endif
if (innersearch <= artpos) { /* already on page? */
if (innersearch < artpos) {
artline = topline+1;
while (vrdary(artline) < innersearch)
artline++;
}
highlight = artline - 1;
#ifdef DEBUGGING
if (debug & DEB_INNERSRCH)
printf("@ %d\n",highlight) FLUSH;
#endif
topline = highlight - gline;
if (topline < -1)
topline = -1;
*buf = '\f'; /* fake up a refresh */
innersearch = 0;
return page_switch();
}
else { /* who knows how many lines it is? */
do_fseek = TRUE;
hide_everything = TRUE;
}
return PS_NORM;
}
#else
case 'g': case 'G': case Ctl('g'):
notincl("g");
return PS_ASK;
#endif
case '\n': /* one line */
special = TRUE;
slines = 2;
return PS_NORM;
#ifdef ROTATION
case 'X':
rotate = !rotate;
/* FALL THROUGH */
#endif
case 'l':
case '\f': /* refresh screen */
#ifdef DEBUGGING
if (debug & DEB_INNERSRCH) {
printf("Topline = %d",topline) FLUSH;
gets(buf);
}
#endif
clear();
do_fseek = TRUE;
artline = topline;
if (artline < 0)
artline = 0;
firstpage = (topline < 0);
return PS_NORM;
case 'b':
case '\b': /* I like backspace for this -- PWP */
/* Leaving it undocumented in case */
/* I want to steal the key--LAW */
case Ctl('b'): { /* back up a page */
ART_LINE target;
#ifndef CLEAREOL
clear();
#else
if (can_home_clear) /* if we can home do it -- PWP */
home_cursor();
else
clear();
#endif CLEAREOL
do_fseek = TRUE; /* reposition article file */
target = topline - (LINES - 2);
artline = topline;
do {
artline--;
} while (artline >= 0 && artline > target &&
vrdary(artline-1) >= 0);
topline = artline;
/* remember top line of screen */
/* (line # within article file) */
if (artline < 0)
artline = 0;
firstpage = (topline < 0);
return PS_NORM;
}
case 'h': { /* help */
int cmd;
if ((cmd = help_page()) > 0)
pushchar(cmd);
return PS_ASK;
}
case '\177':
case '\0': /* treat del,break as 'n' */
*buf = 'n';
/* FALL THROUGH */
case 'k': case 'K':
case 'n': case 'N': case Ctl('n'):
case 's': case 'S':
case 'u':
case 'w': case 'W':
case '|':
mark_as_read(art); /* mark article as read */
/* FALL THROUGH */
case '#':
case '$':
case '&':
case '-':
case '.':
case '/':
case '1': case '2': case '3': case '4': case '5':
case '6': case '7': case '8': case '9':
case '=':
case '?':
case 'c': case 'C':
case 'f': case 'F':
case 'j':
case Ctl('k'):
case 'm': case 'M':
case 'p': case 'P': case Ctl('p'):
case 'Q':
case 'r': case 'R': case Ctl('r'):
case 'v':
case 'Y':
#ifndef ROTATION
case 'x': case 'X':
#endif
case Ctl('x'):
case '^':
#ifdef ROTATION
rotate = FALSE;
#endif
reread = FALSE;
do_hiding = TRUE;
if (index("nNpP",*buf) == Nullch &&
index("wWsS!&|/?123456789.",*buf) != Nullch) {
setdfltcmd();
standout(); /* enter standout mode */
printf(prompt,mailcall,dfltcmd);
/* print prompt, whatever it is */
un_standout(); /* leave standout mode */
putchar(' ');
fflush(stdout);
}
return PS_RAISE; /* and pretend we were at end */
#ifdef ROTATION
case 'x':
rotate = TRUE;
/* FALL THROUGH */
#endif
case 'y':
case Ctl('v'): /* I like emacs -- PWP */
/* Leaving it undocumented in case */
/* I want to steal the key--LAW */
case ' ': /* continue current article */
if (erase_screen) { /* -e? */
#ifndef CLEAREOL
clear(); /* clear screen */
#else
if (can_home_clear) /* if we can home do it -- PWP */
home_cursor();
else
clear(); /* else clear screen */
#endif CLEAREOL
if (*blinebeg != '\f'
#ifdef CUSTOMLINES
&& (!pagestop || blinebeg != art_buf ||
!execute(&page_compex,blinebeg))
#endif
) {
restart = blinebeg;
artline--; /* restart this line */
artpos = alinebeg;
if (marking) /* and mark repeated line */
highlight = artline;
}
topline = artline;
/* and remember top line of screen */
/* (line # within article file) */
}
else if (marking && *blinebeg != '\f'
#ifdef CUSTOMLINES
&& (!pagestop || blinebeg != art_buf ||
!execute(&page_compex,blinebeg))
#endif
) {
/* are we marking repeats? */
up_line(); /* go up one line */
highlight = --artline;/* and get ready to highlight */
restart = blinebeg; /* the old line */
artpos = alinebeg;
}
return PS_NORM;
case 'q': /* quit this article? */
do_hiding = TRUE;
return PS_TOEND;
default:
fputs(hforhelp,stdout) FLUSH;
settle_down();
return PS_ASK;
}
}
/* Main program */
int main(int argc, char *argv[])
{
FILE *fpLook=NULL, *fpIncid=NULL, *fpRange=NULL, *fpIn=NULL, *fpMask=NULL;
meta_parameters *meta;
stateVector stVec;
int ii, kk, ll;
char inFile[255], metaFile[255], dataFile[255], outLook[255], outIncid[255];
char outRange[255], outBase[255], outFile[255], *maskFile=NULL;
char cmd[255], *bufMask=NULL;
float *bufImage=NULL, *bufLook=NULL, *bufIncid=NULL, *bufRange=NULL;
double latitude, longitude, time, doppler, earth_radius=0, satellite_height, range;
double look_angle, incidence_angle, height;
double line, sample, re=6378144.0, rp=6356754.9, px, py;
double firstLook=0.0, firstIncid=0.0, firstRange=0.0;
flag_indices_t flags[NUM_FLAGS];
/* Set all flags to 'not set' */
for (ii=0; ii<NUM_FLAGS; ii++) {
flags[ii] = FLAG_NOT_SET;
}
/**********************BEGIN COMMAND LINE PARSING STUFF**********************/
/* Check to see if any options were provided */
if (checkForOption("-help", argc, argv) != -1) /* Most important */
help_page();
flags[f_LOOK] = checkForOption("-look", argc, argv);
flags[f_INCIDENCE] = checkForOption("-incidence", argc, argv);
flags[f_RANGE] = checkForOption("-range", argc, argv);
flags[f_LINE] = checkForOption("-line", argc, argv);
flags[f_SAMPLE] = checkForOption("-sample", argc, argv);
flags[f_MIN] = checkForOption("-min", argc, argv);
flags[f_MAX] = checkForOption("-max", argc, argv);
flags[f_BINS] = checkForOption("-bins", argc, argv);
flags[f_INTERVAL] = checkForOption("-interval", argc, argv);
/* Make sure to set log & quiet flags (for use in our libraries) */
logflag = (flags[f_LOG]!=FLAG_NOT_SET) ? TRUE : FALSE;
quietflag = (flags[f_QUIET]!=FLAG_NOT_SET) ? TRUE : FALSE;
{ /* We need to make sure the user specified the proper number of arguments */
int needed_args = 4;/*command & in_base & out_base */
if (flags[f_MIN] != FLAG_NOT_SET) needed_args += 2; /* option & value */
if (flags[f_MAX] != FLAG_NOT_SET) needed_args += 2; /* option & value */
if (flags[f_BINS] != FLAG_NOT_SET) needed_args += 2; /* option & value */
if (flags[f_INTERVAL] != FLAG_NOT_SET) needed_args += 2; /* option & value */
/*Make sure we have enough arguments*/
if (argc != needed_args)
usage();/*This exits with a failure*/
}
/* We must be close to good enough at this point...start filling in fields
as needed */
if (flags[f_MIN] != FLAG_NOT_SET)
min = atof(argv[flags[f_MIN] + 1]);
if (flags[f_MAX] != FLAG_NOT_SET)
max = atof(argv[flags[f_MAX] + 1]);
if (flags[f_BINS] != FLAG_NOT_SET)
bins = atoi(argv[flags[f_BINS] + 1]);
if (flags[f_INTERVAL] != FLAG_NOT_SET)
interval = atof(argv[flags[f_INTERVAL] + 1]);
if (flags[f_QUIET] == FLAG_NOT_SET)
/* display splash screen if not quiet */
print_splash_screen(argc, argv);
if (flags[f_LOG] != FLAG_NOT_SET)
strcpy(logFile, argv[flags[f_LOG] + 1]);
else
/* default behavior: log to tmp<pid>.log */
sprintf(logFile, "tmp%i.log", (int)getpid());
fLog = FOPEN(logFile, "a");
/* Fetch required arguments */
strcpy(inFile,argv[argc - 2]);
strcpy(outBase,argv[argc - 1]);
/***********************END COMMAND LINE PARSING STUFF***********************/
create_name(metaFile, inFile, ".meta");
create_name(dataFile, inFile, ".img");
/* Read metadata */
meta = meta_read(inFile);
lines = meta->general->line_count;
samples = meta->general->sample_count;
/* Set some values */
doppler = 0.0;
/* Determine what kind of image it is */
if (meta->sar->image_type=='P') {
if (meta->projection->type==SCANSAR_PROJECTION)
printf(" Detected ScanSAR ");
}
else if (meta->sar->image_type=='S')
printf(" Detected slant range ");
else if (meta->sar->image_type=='G')
printf(" Detected ground range ");
/*
switch (meta->general->image_data_type)
{
case AMPLITUDE_IMAGE:
printf("amplitude image ...\n");
break;
case SIGMA_IMAGE:
printf("sigma image ...\n");
break;
case GAMMA_IMAGE:
printf("gamma image ...\n");
break;
case BETA_IMAGE:
printf("beta image ...\n");
break;
case RAW_IMAGE:
case COMPLEX_IMAGE:
case PHASE_IMAGE:
case POWER_IMAGE:
case COHERENCE_IMAGE:
case GEOREFERENCED_IMAGE:
case GEOCODED_IMAGE:
case POLARIMETRIC_IMAGE:
case LUT_IMAGE:
case ELEVATION:
case DEM:
case IMAGE:
case MASK:
break;
}
*/
/* Create a mask file for background fill - required only for ScanSAR */
if (meta->sar->image_type=='P') {
if (meta->projection->type==SCANSAR_PROJECTION) {
fpIn = fopenImage(inFile, "rb");
bufImage = (float *) MALLOC(samples * sizeof(float));
printf(" Generating mask file ...\n");
maskFile = (char *) MALLOC(255*sizeof(char));
sprintf(maskFile, "tmp%i.mask", (int)getpid());
fpMask = fopenImage(maskFile, "wb");
bufMask = (unsigned char *) MALLOC(samples * sizeof(char));
for (ii=0; ii<lines; ii++) {
get_float_line(fpIn, meta, ii, bufImage);
for (kk=0; kk<samples; kk++) {
if (bufImage[kk]>0.0)
bufMask[kk] = 1;
else
bufMask[kk] = 0;
}
ASF_FWRITE(bufMask, sizeof(char), samples, fpMask);
}
FCLOSE(fpMask);
FREE(bufMask);
FCLOSE(fpIn);
FREE(bufImage);
}
}
/* Create grid for least square approach */
printf(" Initialization ...\n");
if (flags[f_LOOK] != FLAG_NOT_SET) {
sprintf(outLook, "tmp%i.look", (int)getpid());
fpLook = FOPEN(outLook, "w");
}
if (flags[f_INCIDENCE] != FLAG_NOT_SET) {
sprintf(outIncid, "tmp%i.incid", (int)getpid());
fpIncid = FOPEN(outIncid, "w");
}
if (flags[f_RANGE] != FLAG_NOT_SET) {
sprintf(outRange, "tmp%i.range", (int)getpid());
fpRange = FOPEN(outRange, "w");
}
if (flags[f_LOOK] != FLAG_NOT_SET || flags[f_INCIDENCE] != FLAG_NOT_SET ||
flags[f_RANGE] != FLAG_NOT_SET) {
for (ll=0; ll<=RES_X; ll++)
for (kk=0; kk<=RES_Y; kk++) {
line = ll * lines / RES_Y;
sample = kk * samples / RES_X;
if (meta->sar->image_type=='P') {
px = meta->projection->startX + meta->projection->perX * sample;
py = meta->projection->startY + meta->projection->perY * line;
proj_to_latlon(meta->projection, px, py, 0.0,
&latitude, &longitude, &height);
latLon2timeSlant(meta, latitude, longitude, &time, &range, &doppler);
}
else
time = meta_get_time(meta, line, sample);
stVec = meta_get_stVec(meta, time);
if (meta->sar->image_type=='P') {
if (meta->projection->type==SCANSAR_PROJECTION)
earth_radius = meta->projection->param.atct.rlocal;
else
asfPrintError("Unable to determine earth radius.\n");
}
else
earth_radius = my_get_earth_radius(time, stVec, re, rp);
satellite_height = my_get_satellite_height(time, stVec);
range = my_get_slant_range(meta, earth_radius, satellite_height, line, sample);
look_angle = my_get_look_angle(earth_radius, satellite_height, range);
incidence_angle = my_get_incidence_angle(earth_radius, satellite_height, range);
if (ll==0 && kk==0) {
firstLook = look_angle * R2D;
firstIncid = incidence_angle * R2D;
firstRange = range;
}
if (flags[f_LOOK] != FLAG_NOT_SET)
fprintf(fpLook, "%.18f %.12f %.12f\n", (float)look_angle*R2D,
line, sample);
if (flags[f_INCIDENCE] != FLAG_NOT_SET)
fprintf(fpIncid, "%.18f %.12f %.12f\n", (float)incidence_angle*R2D,
line, sample);
if (flags[f_RANGE] != FLAG_NOT_SET)
fprintf(fpRange, "%.18f %.12f %.12f\n", (float)range, line, sample);
}
}
/* Close files for now */
if (flags[f_LOOK] != FLAG_NOT_SET) {
FCLOSE(fpLook);
FREE(bufLook);
}
if (flags[f_INCIDENCE] != FLAG_NOT_SET) {
FCLOSE(fpIncid);
FREE(bufIncid);
}
if (flags[f_RANGE] != FLAG_NOT_SET) {
FCLOSE(fpRange);
FREE(bufRange);
}
/* Calculate plots */
if (flags[f_LOOK] != FLAG_NOT_SET) {
create_name(outFile, outBase, "_look.plot");
calculate_plot("Look angle", outLook, dataFile, maskFile, outFile,
meta, firstLook);
}
if (flags[f_INCIDENCE] != FLAG_NOT_SET) {
create_name(outFile, outBase, "_incid.plot");
calculate_plot("Incidence angle", outIncid, dataFile, maskFile, outFile,
meta, firstIncid);
}
if (flags[f_RANGE] != FLAG_NOT_SET) {
create_name(outFile, outBase, "_range.plot");
calculate_plot("Range", outRange, dataFile, maskFile, outFile,
meta, firstRange);
}
if (flags[f_LINE] != FLAG_NOT_SET) {
create_name(outFile, outBase, "_line.plot");
calculate_plot("Line", NULL, dataFile, maskFile, outFile,
meta, 0.0);
}
if (flags[f_SAMPLE] != FLAG_NOT_SET) {
create_name(outFile, outBase, "_sample.plot");
calculate_plot("Sample", NULL, dataFile, maskFile, outFile,
meta, 0.0);
}
/* Clean up */
sprintf(cmd, "rm -rf tmp*");
system(cmd);
exit(0);
}
int main(int argc, char *argv[])
{
char szImg[255], szImage[255], buffer[1000], crID[10], szCrList[255], szOut[255];
int ii, kk, size, bigSize=oversampling_factor*srcSize;
int mainlobe_azimuth_min, mainlobe_azimuth_max, mainlobe_range_min;
int mainlobe_range_max, sidelobe_azimuth_min, sidelobe_azimuth_max;
int sidelobe_range_min, sidelobe_range_max, peak_line, peak_sample;
float azimuth_processing_bandwidth, chirp_rate, pulse_duration, sampling_rate;
float prf, srcPeakX, srcPeakY, bigPeakX, bigPeakY, clutter_power, peak_power, scr;
float azimuth_resolution, range_resolution, azimuth_pslr, range_pslr;
float azimuth_window_size, range_window_size;
float azimuth_profile[bigSize], range_profile[bigSize];
static complexFloat *s, *t;
double lat, lon, elev, posX, posY, look_angle;
FILE *fpIn, *fpOut, *fp, *fpText;
meta_parameters *meta, *meta_debug;
float *original_amplitude, *amplitude, *phase;
fcpx *src_fft, *trg_fft;
int debug=FALSE;
char *text=NULL;
int overwrite=FALSE;
if (argc==1) usage();
if (strcmp(argv[1],"-help")==0) help_page(); /* exits program */
if (strcmp(argv[1],"-overwrite")==0) overwrite=TRUE;
int required_args = 4;
if (overwrite) ++required_args;
if(argc != required_args)
usage();/*This exits with a failure*/
/* Fetch required arguments */
strcpy(szImg, argv[argc - 3]);
strcpy(szCrList,argv[argc - 2]);
strcpy(szOut,argv[argc - 1]);
/* DEFAULT VALUES:
size of region to oversample - 64 pixels
mainlobe width factor - 2.6
sidelobe width factor - 20.0
maximum oversampling factor - 8
*/
// Read metadata
sprintf(szImage, "%s.img", szImg);
meta = meta_read(szImage);
lines = meta->general->line_count;
samples = meta->general->sample_count;
text = (char *) MALLOC(255*sizeof(char));
// Handle input and output file
fpIn = FOPEN(szCrList, "r");
fpOut = FOPEN(szOut, "w");
fprintf(fpOut, "POINT TARGET ANALYSIS RESULTS\n\n");
fprintf(fpOut, "CR\tLat\tLon\tElev\tAz peak\tRng peak\tLook\t"
"Az res\tRng res\tAz PSLR\tRng PSLR\tSCR\n");
// RCS needs some more coding
// Loop through corner reflector location file
while (fgets(buffer, 1000, fpIn))
{
if (overwrite) {
sscanf(buffer, "%s\t%lf\t%lf", crID, &posY, &posX);
printf(" %s: posX = %.2lf, posY = %.2lf\n", crID, posX, posY);
}
else {
sscanf(buffer, "%s\t%lf\t%lf\t%lf", crID, &lat, &lon, &elev);
meta_get_lineSamp(meta, lat, lon, elev, &posY, &posX);
printf(" %s: lat = %.4lf, lon = %.4lf, posX = %.2lf, posY = %.2lf\n",
crID, lat, lon, posX, posY);
}
// Check bounds - Get average spectra from chip in range direction
if (!(outOfBounds(posX, posY, srcSize)))
{
// READ SUBSET FROM THE IMAGE WITH CORNER REFLECTOR IN THE CENTER
size = srcSize*srcSize*sizeof(float);
original_amplitude = (float *) MALLOC(size);
phase = (float *) MALLOC(size);
s = (complexFloat *) MALLOC(2*size);
readComplexSubset(szImage, srcSize, srcSize, posX-srcSize/2,
posY-srcSize/2, s);
my_complex2polar(s, srcSize, srcSize, original_amplitude, phase);
if (debug) { // Store original image for debugging
fp = FOPEN("original.img", "wb");
size = bigSize*bigSize*sizeof(float);
FWRITE(original_amplitude, size, 1, fp);
FCLOSE(fp);
meta_debug = meta_init(szImage);
meta_debug->general->line_count =
meta_debug->general->sample_count = srcSize;
meta_debug->general->data_type = REAL32;
meta_debug->general->start_line = posY-srcSize/2;
meta_debug->general->start_sample = posX-srcSize/2;
meta_debug->general->center_latitude = lat;
meta_debug->general->center_longitude = lon;
meta_write(meta_debug, "original.meta");
meta_free(meta_debug);
}
// Find amplitude peak in original image chip
if (!findPeak(original_amplitude, srcSize, &srcPeakX, &srcPeakY)) {
fprintf(fpOut,
" Could not find amplitude peak in original image chip!\n");
goto SKIP;
}
// Cut out the subset again around the peak to make sure we have data for
// the analysis
readComplexSubset(szImage, srcSize, srcSize, posX-srcSize+srcPeakY,
posY-srcSize+srcPeakX, s);
my_complex2polar(s, srcSize, srcSize, original_amplitude, phase);
FREE(phase);
findPeak(original_amplitude, srcSize, &srcPeakX, &srcPeakY);
// Determine look angle
look_angle =
meta_look(meta, srcSize/2, srcSize/2);
/****************************
- special ScanSAR case: images are "projected" - need to be rotated back to
allow analysis in azimuth and range direction (ss_extract.c)
*********************/
// BASEBAND THE DATA IN EACH DIMENSION IN THE FREQUENCY DOMAIN
// Oversample image
src_fft = forward_fft(s, srcSize, srcSize);
trg_fft = oversample(src_fft, srcSize, oversampling_factor);
// Determine azimuth and range window size
azimuth_processing_bandwidth =
(float) meta->sar->azimuth_processing_bandwidth;
prf = (float) meta->sar->prf;
chirp_rate = (float) meta->sar->chirp_rate;
pulse_duration = (float) meta->sar->pulse_duration;
sampling_rate = (float) meta->sar->range_sampling_rate;
azimuth_window_size = azimuth_processing_bandwidth / prf;
range_window_size = fabs(chirp_rate) * pulse_duration / sampling_rate;
printf("azimuth window size: %.2f, range window size: %.2f\n",
azimuth_window_size, range_window_size);
asfRequire(azimuth_window_size > 0.0 && azimuth_window_size < 1.0,
"azimuth window size out of range (0 to 1)!\n");
asfRequire(range_window_size > 0.0 && range_window_size < 1.0,
"range window size out of range (0 to 1)!\n");
if (range_window_size < 0.5)
range_window_size = 0.5;
// for ScanSAR both 0.5
// run debugger to check units are correct!
// Baseband image in range direction
//baseband(src_fft, range_window_size);
/*
// Transpose matrix to work in azimuth direction
//transpose(s);
// Baseband image in azimuth direction
// baseband(s, azimuth_window_size);
// Transpose matrix back into original orientation
//transpose(s);
*/
t = inverse_fft(trg_fft, bigSize, bigSize);
amplitude = (float *) MALLOC(sizeof(float)*bigSize*bigSize);
phase = (float *) MALLOC(sizeof(float)*bigSize*bigSize);
my_complex2polar(t, bigSize, bigSize, amplitude, phase);
FREE(phase);
if (debug) { // Store oversampled image for debugging
fp = FOPEN("oversample.img", "wb");
size = bigSize*bigSize*sizeof(float);
FWRITE(amplitude, size, 1, fp);
FCLOSE(fp);
meta_debug = meta_init("oversample.meta");
meta_debug->general->line_count =
meta_debug->general->sample_count = bigSize;
meta_debug->general->data_type = REAL32;
meta_write(meta_debug, "oversample.meta");
meta_free(meta_debug);
}
// Find the amplitude peak in oversampled image
if (!findPeak(amplitude, bigSize, &bigPeakX, &bigPeakY)) {
fprintf(fpOut,
" Could not find amplitude peak in oversampled image chip!\n");
goto SKIP;
}
peak_line = (int)(bigPeakX + 0.5);
peak_sample = (int)(bigPeakY + 0.5);
// Write text version of oversampled image
sprintf(text, "%s_%s_chip.txt", szImg, crID);
fpText = FOPEN(text, "w");
for (ii=peak_line-32; ii<peak_line+32; ii++) {
for (kk=peak_sample-32; kk<peak_sample+32; kk++)
fprintf(fpText, "%12.4f\t", amplitude[ii*bigSize+kk]);
fprintf(fpText, "\n");
}
FCLOSE(fpText);
// EXTRACTING PROFILES IN AZIMUTH AND RANGE THROUGH PEAK
for (ii=0; ii<bigSize; ii++) {
azimuth_profile[ii] = amplitude[ii*bigSize+peak_sample];
range_profile[ii] = amplitude[bigSize*peak_line+ii];
}
sprintf(text, "%s_%s_azimuth.txt", szImg, crID);
fp = FOPEN(text, "w");
fprintf(fp, "Azimuth profile\n");
for (ii=0; ii<bigSize; ii++)
fprintf(fp, "%.3f\n", azimuth_profile[ii]);
FCLOSE(fp);
sprintf(text, "%s_%s_range.txt", szImg, crID);
fp = FOPEN(text, "w");
fprintf(fp, "Range profile\n");
for (ii=0; ii<bigSize; ii++)
fprintf(fp, "%.3f\n", range_profile[ii]);
FCLOSE(fp);
// FINALLY GET TO THE IMAGE QUALITY PARAMETERS
clutter_power = 0.0;
// Find main lobes in oversampled image
if (!find_mainlobe(amplitude, azimuth_profile, bigSize, peak_line,
clutter_power, &mainlobe_azimuth_min,
&mainlobe_azimuth_max)) {
fprintf(fpOut, " No mainlobes could be found for %s in azimuth!\n",
crID);
goto SKIP;
}
//printf("mainlobe azimuth: min = %d, max = %d\n",
// mainlobe_azimuth_min, mainlobe_azimuth_max);
if (!find_mainlobe(amplitude, range_profile, bigSize, peak_sample,
clutter_power, &mainlobe_range_min,
&mainlobe_range_max)) {
fprintf(fpOut, " No mainlobes could be found for %s in range!\n", crID);
goto SKIP;
}
//printf("mainlobe range: min = %d, max = %d\n",
// mainlobe_range_min, mainlobe_range_max);
// Calculate resolution in azimuth and range for profiles
if (!calc_resolution(azimuth_profile, mainlobe_azimuth_min,
mainlobe_azimuth_max, peak_line,
meta->general->y_pixel_size, clutter_power,
&azimuth_resolution))
fprintf(fpOut, " Negative azimuth resolution for %s - invalid result!"
"\n", crID);
//printf("azimuth resolution = %.2f\n", azimuth_resolution);
if (!calc_resolution(range_profile, mainlobe_range_min,
mainlobe_range_max, peak_sample,
meta->general->x_pixel_size, clutter_power,
&range_resolution))
fprintf(fpOut, " Negative range resolution for %s - invalid result!\n",
crID);
//printf("range resolution = %.2f\n", range_resolution);
// Find peak of original data - thought we had that already: check !!!
// Calculate the clutter power
azimuth_resolution /= meta->general->x_pixel_size;
range_resolution /= meta->general->y_pixel_size;
clutter_power =
calc_clutter_power(original_amplitude, srcSize, peak_sample, peak_line,
azimuth_resolution, range_resolution);
//printf(" Clutter power: %8.3f\n", clutter_power);
// Calculate resolution in azimuth and range with estimated clutter power
if (!calc_resolution(azimuth_profile, mainlobe_azimuth_min,
mainlobe_azimuth_max, peak_line,
meta->general->y_pixel_size, clutter_power,
&azimuth_resolution))
fprintf(fpOut, " Negative azimuth resolution for %s - invalid result!"
"\n", crID);
if (!calc_resolution(range_profile, mainlobe_range_min,
mainlobe_range_max, peak_sample,
meta->general->x_pixel_size, clutter_power,
&range_resolution))
fprintf(fpOut, " Negative range resolution for %s - invalid result!\n",
crID);
//printf(" Azimuth resolution: %.3f\n", azimuth_resolution);
//printf(" Range resolution: %.3f\n", range_resolution);
// Find sidelobes in oversampled image and calculate the point-to-sidelobe
// ratio in azimuth and range direction
if (find_sidelobe(azimuth_profile, bigSize, 1, peak_line,
mainlobe_azimuth_max, &sidelobe_azimuth_max) &&
find_sidelobe(azimuth_profile, bigSize, -1, peak_line,
mainlobe_azimuth_min, &sidelobe_azimuth_min)) {
if (!calc_pslr(azimuth_profile, bigSize, peak_line, sidelobe_azimuth_min,
sidelobe_azimuth_max, &azimuth_pslr))
//printf(" Azimuth PSLR: %.3f\n", azimuth_pslr);
//printf(" No valid PSLR in azimuth could be determined!\n");
;
}
else {
fprintf(fpOut, " Problem in finding sidelobes for %s in azimuth - "
"invalid PSLR!\n", crID);
}
if (find_sidelobe(range_profile, bigSize, 1, peak_sample,
mainlobe_range_max, &sidelobe_range_max) &&
find_sidelobe(range_profile, bigSize, -1, peak_sample,
mainlobe_range_min, &sidelobe_range_min)) {
if (!calc_pslr(range_profile, bigSize, peak_sample, sidelobe_range_min,
sidelobe_range_max, &range_pslr))
//printf(" Range PSLR: %.3f\n", range_pslr);
//printf(" No valid PSLR in range could be determined!\n");
;
}
else {
fprintf(fpOut, " Problem in finding sidelobes for %s in range -"
" invalid PSLR!\n", crID);
}
//printf("sidelobe_azimuth: min = %d, max = %d\n",
// sidelobe_azimuth_min, sidelobe_azimuth_max);
//printf("sidelobe_range: min = %d, max = %d\n",
// sidelobe_range_min, sidelobe_range_max);
// Calculate the signal-to-clutter ratio (SCR)
peak_power = amplitude[peak_line*bigSize+peak_sample] *
amplitude[peak_line*bigSize+peak_sample];
if (clutter_power>0 && peak_power>clutter_power)
scr = 10 * log((peak_power - clutter_power)/clutter_power);
else
scr = 0.0;
if (peak_power > 0.0) {
peak_power = 10 * log(peak_power);
//printf(" Peak power: %.3f\n", peak_power);
//printf(" SCR: %.3f\n", scr);
}
else
fprintf(fpOut, " Negative peak power - invalid result!\n");
FREE(amplitude);
FREE(original_amplitude);
// Write values in output files
fprintf(fpOut, "%s\t%.4lf\t%.4lf\t%.1lf\t%.1lf\t%.1f\t%.3f\t"
"%.3f\t%.3f\t%.3f\t%.3f\t%.3f\n",
crID, lat, lon, elev, posX-srcSize+srcPeakY, posY-srcSize+srcPeakX,
look_angle*R2D, azimuth_resolution, range_resolution, azimuth_pslr,
range_pslr, scr);
SKIP: continue;
}
else
fprintf(fpOut, "\n WARNING: Target %s outside the image boundaries!\n",
crID);
}
FCLOSE(fpIn);
FCLOSE(fpOut);
FREE(meta);
return(0);
}