static void conv_case(
char * name, /* (diretory) Name */
char * lim, /* End of (directory) name */
int upper /* TRUE if to upper */
)
/* Convert a string to upper-case letters or lower-case letters in-place */
{
int c;
char * sp;
for (sp = name; sp < lim; sp++) {
c = *sp & UCHARMAX;
#if MBCHAR
if ((char_type[ c] & mbstart)) {
char tmp[ PATHMAX+1];
char * tp = tmp;
*tp++ = *sp++;
mb_read( c, &sp, &tp);
} else
#endif
{
if (upper)
*sp = toupper( c);
else
*sp = tolower( c);
}
}
}
static char * esc_mbchar(
char * str, /* String literal or character constant without 'L' */
char * str_end /* The end of the token */
)
/*
* Insert \ before the byte of 0x5c('\\') of the SJIS, BIGFIVE or ISO2022_JP
* multi-byte character code in string literal or character constant.
* Insert \ also before the byte of 0x22('"') and 0x27('\'') of ISO2022_JP.
* esc_mbchar() does in-place insertion.
*/
{
char * cp;
int delim;
int c;
if (! bsl_need_escape)
return str_end;
if ((delim = *str++) == 'L')
delim = *str++; /* The quote character */
while ((c = *str++ & UCHARMAX) != delim) {
if (char_type[ c] & mbchk) { /* MBCHAR */
cp = str;
mb_read( c, &str, (workp = work_buf, &workp));
while (cp++ < str) {
c = *(cp - 1);
if (c == '\\' || c == '"' || c == '\'') {
/* Insert \ before 0x5c, 0x22, 0x27 */
memmove( cp, cp - 1, (size_t) (str_end - cp) + 2);
*(cp++ - 1) = '\\';
str++;
str_end++;
}
}
} else if (c == '\\' && ! (char_type[ *str & UCHARMAX] & mbchk)) {
str++; /* Escape sequence */
}
}
return str_end;
}
int main (int argc, char **argv)
{
extern char *optarg;
int errflg = 0;
int c;
int help = 0;
int flag = 0;
/* MBIO status variables */
int status = MB_SUCCESS;
int verbose = 0;
int error = MB_ERROR_NO_ERROR;
char *message;
/* MBIO read control parameters */
int format;
int pings;
int lonflip;
double bounds[4];
int btime_i[7];
int etime_i[7];
double btime_d;
double etime_d;
double speedmin;
double timegap;
int beams_bath;
int beams_amp;
int pixels_ss;
void *mbio_ptr = NULL;
/* mbrollbias control variables */
int iformat;
int jformat;
char ifile[MB_PATH_MAXLINE];
char jfile[MB_PATH_MAXLINE];
int xdim, ydim;
/* mbio read values */
int rpings;
int kind;
int time_i[7];
double time_d;
double navlon;
double navlat;
double speed;
double heading;
double distance;
double altitude;
double sonardepth;
char *beamflag = NULL;
double *bath = NULL;
double *bathlon = NULL;
double *bathlat = NULL;
double *amp = NULL;
double *ss = NULL;
double *sslon = NULL;
double *sslat = NULL;
char comment[MB_COMMENT_MAXLINE];
/* grid variables */
double deglontokm, deglattokm;
double mtodeglon, mtodeglat;
double dx, dy;
int *icount = NULL;
int *jcount = NULL;
struct bathptr *idata = NULL;
struct bathptr *jdata = NULL;
struct bath *zone = NULL;
int ndatafile;
double iaa, ibb, icc, ihh;
double jaa, jbb, jcc, jhh;
double hx, hy, dd;
double isine, icosine, jsine, jcosine;
double roll_bias;
/* matrix parameters */
int nmatrix = 3;
double matrix[3][3];
double vector[3];
double xx[3];
/* output stream for basic stuff (stdout if verbose <= 1,
stderr if verbose > 1) */
FILE *outfp;
/* other variables */
int i, j, k;
int ii, jj, kk;
int ib, ix, iy, indx;
/* get current default values */
status = mb_defaults(verbose,&format,&pings,&lonflip,bounds,
btime_i,etime_i,&speedmin,&timegap);
/* set default input and output */
strcpy (ifile, "\0");
strcpy (jfile, "\0");
/* initialize some values */
pings = 1;
iformat = format;
jformat = format;
btime_i[0] = 1962;
btime_i[1] = 2;
btime_i[2] = 21;
btime_i[3] = 10;
btime_i[4] = 30;
btime_i[5] = 0;
btime_i[6] = 0;
etime_i[0] = 2062;
etime_i[1] = 2;
etime_i[2] = 21;
etime_i[3] = 10;
etime_i[4] = 30;
etime_i[5] = 0;
etime_i[6] = 0;
speedmin = 0.0;
timegap = 1000000000.0;
bounds[0] = 0.0;
bounds[1] = 0.0;
bounds[2] = 0.0;
bounds[3] = 0.0;
xdim = 5;
ydim = 5;
/* process argument list */
while ((c = getopt(argc, argv, "VvHhL:l:R:r:F:f:I:i:J:j:D:d:")) != -1)
switch (c)
{
case 'H':
case 'h':
help++;
break;
case 'V':
case 'v':
verbose++;
break;
case 'L':
case 'l':
sscanf (optarg,"%d", &lonflip);
flag++;
break;
case 'R':
case 'r':
mb_get_bounds(optarg, bounds);
flag++;
break;
case 'F':
case 'f':
sscanf (optarg,"%d/%d", &iformat,&jformat);
flag++;
break;
case 'I':
case 'i':
sscanf (optarg,"%s", ifile);
flag++;
break;
case 'J':
case 'j':
sscanf (optarg,"%s", jfile);
flag++;
break;
case 'D':
case 'd':
sscanf (optarg,"%d/%d", &xdim, &ydim);
flag++;
break;
case '?':
errflg++;
}
/* set output stream */
if (verbose <= 1)
outfp = stdout;
else
outfp = stderr;
/* if error flagged then print it and exit */
if (errflg)
{
fprintf(outfp,"usage: %s\n", usage_message);
fprintf(outfp,"\nProgram <%s> Terminated\n",
program_name);
error = MB_ERROR_BAD_USAGE;
exit(error);
}
/* print starting message */
if (verbose == 1 || help)
{
fprintf(outfp,"\nProgram %s\n",program_name);
fprintf(outfp,"Version %s\n",rcs_id);
fprintf(outfp,"MB-system Version %s\n",MB_VERSION);
}
/* print starting debug statements */
if (verbose >= 2)
{
fprintf(outfp,"\ndbg2 Program <%s>\n",program_name);
fprintf(outfp,"dbg2 Version %s\n",rcs_id);
fprintf(outfp,"dbg2 MB-system Version %s\n",MB_VERSION);
fprintf(outfp,"dbg2 Control Parameters:\n");
fprintf(outfp,"dbg2 verbose: %d\n",verbose);
fprintf(outfp,"dbg2 help: %d\n",help);
fprintf(outfp,"dbg2 pings: %d\n",pings);
fprintf(outfp,"dbg2 lonflip: %d\n",lonflip);
fprintf(outfp,"dbg2 btime_i[0]: %d\n",btime_i[0]);
fprintf(outfp,"dbg2 btime_i[1]: %d\n",btime_i[1]);
fprintf(outfp,"dbg2 btime_i[2]: %d\n",btime_i[2]);
fprintf(outfp,"dbg2 btime_i[3]: %d\n",btime_i[3]);
fprintf(outfp,"dbg2 btime_i[4]: %d\n",btime_i[4]);
fprintf(outfp,"dbg2 btime_i[5]: %d\n",btime_i[5]);
fprintf(outfp,"dbg2 btime_i[6]: %d\n",btime_i[6]);
fprintf(outfp,"dbg2 etime_i[0]: %d\n",etime_i[0]);
fprintf(outfp,"dbg2 etime_i[1]: %d\n",etime_i[1]);
fprintf(outfp,"dbg2 etime_i[2]: %d\n",etime_i[2]);
fprintf(outfp,"dbg2 etime_i[3]: %d\n",etime_i[3]);
fprintf(outfp,"dbg2 etime_i[4]: %d\n",etime_i[4]);
fprintf(outfp,"dbg2 etime_i[5]: %d\n",etime_i[5]);
fprintf(outfp,"dbg2 etime_i[6]: %d\n",etime_i[6]);
fprintf(outfp,"dbg2 speedmin: %f\n",speedmin);
fprintf(outfp,"dbg2 timegap: %f\n",timegap);
fprintf(outfp,"dbg2 input file 1: %s\n",ifile);
fprintf(outfp,"dbg2 input file 2: %s\n",jfile);
fprintf(outfp,"dbg2 file 1 format: %d\n",iformat);
fprintf(outfp,"dbg2 file 2 format: %d\n",jformat);
fprintf(outfp,"dbg2 grid x dimension: %d\n",xdim);
fprintf(outfp,"dbg2 grid y dimension: %d\n",ydim);
fprintf(outfp,"dbg2 grid bounds[0]: %f\n",bounds[0]);
fprintf(outfp,"dbg2 grid bounds[1]: %f\n",bounds[1]);
fprintf(outfp,"dbg2 grid bounds[2]: %f\n",bounds[2]);
fprintf(outfp,"dbg2 grid bounds[3]: %f\n",bounds[3]);
}
/* if help desired then print it and exit */
if (help)
{
fprintf(outfp,"\n%s\n",help_message);
fprintf(outfp,"\nusage: %s\n", usage_message);
exit(error);
}
/* get format if required */
if (format == 0)
mb_get_format(verbose,ifile,NULL,&format,&error);
/* if bounds not specified then quit */
if (bounds[0] >= bounds[1] || bounds[2] >= bounds[3]
|| bounds[2] <= -90.0 || bounds[3] >= 90.0)
{
fprintf(outfp,"\nGrid bounds not properly specified:\n\t%f %f %f %f\n",bounds[0],bounds[1],bounds[2],bounds[3]);
fprintf(outfp,"\nProgram <%s> Terminated\n",
program_name);
error = MB_ERROR_BAD_PARAMETER;
exit(error);
}
/* calculate grid properties and other values */
mb_coor_scale(verbose,0.5*(bounds[2]+bounds[3]),&mtodeglon,&mtodeglat);
deglontokm = 0.001/mtodeglon;
deglattokm = 0.001/mtodeglat;
dx = (bounds[1] - bounds[0])/(xdim);
dy = (bounds[3] - bounds[2])/(ydim);
/* output info */
if (verbose >= 0)
{
fprintf(outfp,"\nMBROLLBIAS Parameters:\n");
fprintf(outfp,"Input file 1: %s\n",ifile);
fprintf(outfp,"Input file 2: %s\n",jfile);
fprintf(outfp,"Region grid bounds:\n");
fprintf(outfp," Longitude: %9.4f %9.4f\n",bounds[0],bounds[1]);
fprintf(outfp," Latitude: %9.4f %9.4f\n",bounds[2],bounds[3]);
fprintf(outfp,"Region grid dimensions: %d %d\n",xdim,ydim);
fprintf(outfp,"Longitude interval: %f degrees or %f km\n",
dx,dx*deglontokm);
fprintf(outfp,"Latitude interval: %f degrees or %f km\n",
dy,dy*deglattokm);
fprintf(outfp,"Longitude flipping: %d\n",lonflip);
fprintf(outfp,"\n");
}
/* allocate memory for counting arrays */
status = mb_mallocd(verbose,__FILE__,__LINE__,xdim*ydim*sizeof(int),(void **)&icount,&error);
status = mb_mallocd(verbose,__FILE__,__LINE__,xdim*ydim*sizeof(int),(void **)&jcount,&error);
/* if error initializing memory then quit */
if (error != MB_ERROR_NO_ERROR)
{
mb_error(verbose,error,&message);
fprintf(outfp,"\nMBIO Error allocating data arrays:\n%s\n",
message);
fprintf(outfp,"\nProgram <%s> Terminated\n",
program_name);
exit(error);
}
/* initialize arrays */
for (i=0;i<xdim*ydim;i++)
{
icount[i] = 0;
jcount[i] = 0;
}
/* count data in first swath file */
/* initialize the first swath file */
ndatafile = 0;
if ((status = mb_read_init(
verbose,ifile,iformat,pings,lonflip,bounds,
btime_i,etime_i,speedmin,timegap,
&mbio_ptr,&btime_d,&etime_d,
&beams_bath,&beams_amp,&pixels_ss,&error)) != MB_SUCCESS)
{
mb_error(verbose,error,&message);
fprintf(outfp,"\nMBIO Error returned from function <mb_read_init>:\n%s\n",message);
fprintf(outfp,"\nMultibeam File <%s> not initialized for reading\n",ifile);
fprintf(outfp,"\nProgram <%s> Terminated\n",
program_name);
exit(error);
}
/* allocate memory for reading data arrays */
status = mb_mallocd(verbose,__FILE__,__LINE__,beams_bath*sizeof(char),(void **)&beamflag,&error);
status = mb_mallocd(verbose,__FILE__,__LINE__,beams_bath*sizeof(double),(void **)&bath,&error);
status = mb_mallocd(verbose,__FILE__,__LINE__,beams_bath*sizeof(double),(void **)&bathlon,&error);
status = mb_mallocd(verbose,__FILE__,__LINE__,beams_bath*sizeof(double),(void **)&bathlat,&error);
status = mb_mallocd(verbose,__FILE__,__LINE__,beams_amp*sizeof(double),(void **)&,&error);
status = mb_mallocd(verbose,__FILE__,__LINE__,pixels_ss*sizeof(double),(void **)&ss,&error);
status = mb_mallocd(verbose,__FILE__,__LINE__,pixels_ss*sizeof(double),(void **)&sslon,&error);
status = mb_mallocd(verbose,__FILE__,__LINE__,pixels_ss*sizeof(double),(void **)&sslat,&error);
/* if error initializing memory then quit */
if (error != MB_ERROR_NO_ERROR)
{
mb_error(verbose,error,&message);
fprintf(outfp,"\nMBIO Error allocating data arrays:\n%s\n",
message);
fprintf(outfp,"\nProgram <%s> Terminated\n",
program_name);
exit(error);
}
/* loop over reading */
while (error <= MB_ERROR_NO_ERROR)
{
status = mb_read(verbose,mbio_ptr,&kind,
&rpings,time_i,&time_d,
&navlon,&navlat,
&speed,&heading,
&distance,&altitude,&sonardepth,
&beams_bath,&beams_amp,&pixels_ss,
beamflag,bath,amp,bathlon,bathlat,
ss,sslon,sslat,
comment,&error);
/* time gaps are not a problem here */
if (error == MB_ERROR_TIME_GAP)
{
error = MB_ERROR_NO_ERROR;
status = MB_SUCCESS;
}
/* print debug statements */
if (verbose >= 2)
{
fprintf(stderr,"\ndbg2 Ping read in program <%s>\n",program_name);
fprintf(stderr,"dbg2 kind: %d\n",kind);
fprintf(stderr,"dbg2 beams_bath: %d\n",beams_bath);
fprintf(stderr,"dbg2 beams_amp: %d\n",beams_amp);
fprintf(stderr,"dbg2 pixels_ss: %d\n",pixels_ss);
fprintf(stderr,"dbg2 error: %d\n",error);
fprintf(stderr,"dbg2 status: %d\n",status);
}
if (error == MB_ERROR_NO_ERROR)
{
for (ib=0;ib<beams_bath;ib++)
if (mb_beam_ok(beamflag[ib]))
{
ix = (bathlon[ib] - bounds[0])/dx;
iy = (bathlat[ib] - bounds[2])/dy;
if (ix >= 0 && ix < xdim
&& iy >= 0 && iy < ydim)
{
indx = ix + iy*xdim;
icount[indx]++;
ndatafile++;
}
}
}
}
status = mb_close(verbose,&mbio_ptr,&error);
mb_freed(verbose,__FILE__,__LINE__,(void **)&beamflag,&error);
mb_freed(verbose,__FILE__,__LINE__,(void **)&bath,&error);
mb_freed(verbose,__FILE__,__LINE__,(void **)&bathlon,&error);
mb_freed(verbose,__FILE__,__LINE__,(void **)&bathlat,&error);
mb_freed(verbose,__FILE__,__LINE__,(void **)&,&error);
mb_freed(verbose,__FILE__,__LINE__,(void **)&ss,&error);
mb_freed(verbose,__FILE__,__LINE__,(void **)&sslon,&error);
mb_freed(verbose,__FILE__,__LINE__,(void **)&sslat,&error);
status = MB_SUCCESS;
error = MB_ERROR_NO_ERROR;
if (verbose >= 2)
fprintf(outfp,"\n");
fprintf(outfp,"%d depth points counted in %s\n",
ndatafile,ifile);
/* count data in second swath file */
/* initialize the second swath file */
ndatafile = 0;
if ((status = mb_read_init(
verbose,jfile,jformat,pings,lonflip,bounds,
btime_i,etime_i,speedmin,timegap,
&mbio_ptr,&btime_d,&etime_d,
&beams_bath,&beams_amp,&pixels_ss,&error)) != MB_SUCCESS)
{
mb_error(verbose,error,&message);
fprintf(outfp,"\nMBIO Error returned from function <mb_read_init>:\n%s\n",message);
fprintf(outfp,"\nMultibeam File <%s> not initialized for reading\n",jfile);
fprintf(outfp,"\nProgram <%s> Terminated\n",
program_name);
exit(error);
}
/* allocate memory for reading data arrays */
status = mb_mallocd(verbose,__FILE__,__LINE__,beams_bath*sizeof(char),(void **)&beamflag,&error);
status = mb_mallocd(verbose,__FILE__,__LINE__,beams_bath*sizeof(double),(void **)&bath,&error);
status = mb_mallocd(verbose,__FILE__,__LINE__,beams_bath*sizeof(double),(void **)&bathlon,&error);
status = mb_mallocd(verbose,__FILE__,__LINE__,beams_bath*sizeof(double),(void **)&bathlat,&error);
status = mb_mallocd(verbose,__FILE__,__LINE__,beams_amp*sizeof(double),(void **)&,&error);
status = mb_mallocd(verbose,__FILE__,__LINE__,pixels_ss*sizeof(double),(void **)&ss,&error);
status = mb_mallocd(verbose,__FILE__,__LINE__,pixels_ss*sizeof(double),(void **)&sslon,&error);
status = mb_mallocd(verbose,__FILE__,__LINE__,pixels_ss*sizeof(double),(void **)&sslat,&error);
/* if error initializing memory then quit */
if (error != MB_ERROR_NO_ERROR)
{
mb_error(verbose,error,&message);
fprintf(outfp,"\nMBIO Error allocating data arrays:\n%s\n",
message);
fprintf(outfp,"\nProgram <%s> Terminated\n",
program_name);
exit(error);
}
/* loop over reading */
while (error <= MB_ERROR_NO_ERROR)
{
status = mb_read(verbose,mbio_ptr,&kind,
&rpings,time_i,&time_d,
&navlon,&navlat,
&speed,&heading,
&distance,&altitude,&sonardepth,
&beams_bath,&beams_amp,&pixels_ss,
beamflag,bath,amp,bathlon,bathlat,
ss,sslon,sslat,
comment,&error);
/* time gaps are not a problem here */
if (error == MB_ERROR_TIME_GAP)
{
error = MB_ERROR_NO_ERROR;
status = MB_SUCCESS;
}
/* print debug statements */
if (verbose >= 2)
{
fprintf(stderr,"\ndbg2 Ping read in program <%s>\n",program_name);
fprintf(stderr,"dbg2 kind: %d\n",kind);
fprintf(stderr,"dbg2 beams_bath: %d\n",beams_bath);
fprintf(stderr,"dbg2 beams_amp: %d\n",beams_amp);
fprintf(stderr,"dbg2 pixels_ss: %d\n",pixels_ss);
fprintf(stderr,"dbg2 error: %d\n",error);
fprintf(stderr,"dbg2 status: %d\n",status);
}
if (error == MB_ERROR_NO_ERROR)
{
for (ib=0;ib<beams_bath;ib++)
if (mb_beam_ok(beamflag[ib]))
{
ix = (bathlon[ib] - bounds[0])/dx;
iy = (bathlat[ib] - bounds[2])/dy;
if (ix >= 0 && ix < xdim
&& iy >= 0 && iy < ydim)
{
indx = ix + iy*xdim;
jcount[indx]++;
ndatafile++;
}
}
}
}
status = mb_close(verbose,&mbio_ptr,&error);
mb_freed(verbose,__FILE__,__LINE__,(void **)&beamflag,&error);
mb_freed(verbose,__FILE__,__LINE__,(void **)&bath,&error);
mb_freed(verbose,__FILE__,__LINE__,(void **)&bathlon,&error);
mb_freed(verbose,__FILE__,__LINE__,(void **)&bathlat,&error);
mb_freed(verbose,__FILE__,__LINE__,(void **)&,&error);
mb_freed(verbose,__FILE__,__LINE__,(void **)&ss,&error);
mb_freed(verbose,__FILE__,__LINE__,(void **)&sslon,&error);
mb_freed(verbose,__FILE__,__LINE__,(void **)&sslat,&error);
status = MB_SUCCESS;
error = MB_ERROR_NO_ERROR;
if (verbose >= 2)
fprintf(outfp,"\n");
fprintf(outfp,"%d depth points counted in %s\n",
ndatafile,jfile);
/* allocate space for data */
status = mb_mallocd(verbose,__FILE__,__LINE__,xdim*ydim*sizeof(struct bathptr),
(void **)&idata,&error);
status = mb_mallocd(verbose,__FILE__,__LINE__,xdim*ydim*sizeof(struct bathptr),
(void **)&jdata,&error);
for (i=0;i<xdim;i++)
for (j=0;j<ydim;j++)
{
k = i*ydim + j;
idata[k].ptr = NULL;
jdata[k].ptr = NULL;
if (icount[k] > 0)
{
status = mb_mallocd(verbose,__FILE__,__LINE__,
icount[k]*sizeof(struct bath),
(void **)&(idata[k].ptr),&error);
icount[k] = 0;
}
if (jcount[k] > 0)
{
status = mb_mallocd(verbose,__FILE__,__LINE__,
jcount[k]*sizeof(struct bath),
(void **)&(jdata[k].ptr),&error);
jcount[k] = 0;
}
}
/* if error initializing memory then quit */
if (error != MB_ERROR_NO_ERROR)
{
mb_error(verbose,error,&message);
fprintf(outfp,"\nMBIO Error allocating data arrays:\n%s\n",
message);
fprintf(outfp,"Try using ping averaging to reduce the number of data.\n");
fprintf(outfp,"\nProgram <%s> Terminated\n",
program_name);
exit(error);
}
/* read data in first swath file */
/* initialize the first swath file */
ndatafile = 0;
if ((status = mb_read_init(
verbose,ifile,iformat,pings,lonflip,bounds,
btime_i,etime_i,speedmin,timegap,
&mbio_ptr,&btime_d,&etime_d,
&beams_bath,&beams_amp,&pixels_ss,&error)) != MB_SUCCESS)
{
mb_error(verbose,error,&message);
fprintf(outfp,"\nMBIO Error returned from function <mb_read_init>:\n%s\n",message);
fprintf(outfp,"\nMultibeam File <%s> not initialized for reading\n",ifile);
fprintf(outfp,"\nProgram <%s> Terminated\n",
program_name);
exit(error);
}
/* allocate memory for reading data arrays */
status = mb_mallocd(verbose,__FILE__,__LINE__,beams_bath*sizeof(double),(void **)&beamflag,&error);
status = mb_mallocd(verbose,__FILE__,__LINE__,beams_bath*sizeof(double),(void **)&bath,&error);
status = mb_mallocd(verbose,__FILE__,__LINE__,beams_bath*sizeof(double),(void **)&bathlon,&error);
status = mb_mallocd(verbose,__FILE__,__LINE__,beams_bath*sizeof(double),(void **)&bathlat,&error);
status = mb_mallocd(verbose,__FILE__,__LINE__,beams_amp*sizeof(double),(void **)&,&error);
status = mb_mallocd(verbose,__FILE__,__LINE__,pixels_ss*sizeof(double),(void **)&ss,&error);
status = mb_mallocd(verbose,__FILE__,__LINE__,pixels_ss*sizeof(double),(void **)&sslon,&error);
status = mb_mallocd(verbose,__FILE__,__LINE__,pixels_ss*sizeof(double),(void **)&sslat,&error);
/* if error initializing memory then quit */
if (error != MB_ERROR_NO_ERROR)
{
mb_error(verbose,error,&message);
fprintf(outfp,"\nMBIO Error allocating data arrays:\n%s\n",
message);
fprintf(outfp,"\nProgram <%s> Terminated\n",
program_name);
exit(error);
}
/* loop over reading */
while (error <= MB_ERROR_NO_ERROR)
{
status = mb_read(verbose,mbio_ptr,&kind,
&rpings,time_i,&time_d,
&navlon,&navlat,
&speed,&heading,
&distance,&altitude,&sonardepth,
&beams_bath,&beams_amp,&pixels_ss,
beamflag,bath,amp,bathlon,bathlat,
ss,sslon,sslat,
comment,&error);
/* time gaps are not a problem here */
if (error == MB_ERROR_TIME_GAP)
{
error = MB_ERROR_NO_ERROR;
status = MB_SUCCESS;
}
/* print debug statements */
if (verbose >= 2)
{
fprintf(stderr,"\ndbg2 Ping read in program <%s>\n",program_name);
fprintf(stderr,"dbg2 kind: %d\n",kind);
fprintf(stderr,"dbg2 beams_bath: %d\n",beams_bath);
fprintf(stderr,"dbg2 beams_amp: %d\n",beams_amp);
fprintf(stderr,"dbg2 pixels_ss: %d\n",pixels_ss);
fprintf(stderr,"dbg2 error: %d\n",error);
fprintf(stderr,"dbg2 status: %d\n",status);
}
if (error == MB_ERROR_NO_ERROR)
{
for (ib=0;ib<beams_bath;ib++)
if (mb_beam_ok(beamflag[ib]))
{
ix = (bathlon[ib] - bounds[0])/dx;
iy = (bathlat[ib] - bounds[2])/dy;
if (ix >= 0 && ix < xdim
&& iy >= 0 && iy < ydim)
{
indx = ix + iy*xdim;
zone = idata[indx].ptr;
zone[icount[indx]].x =
deglontokm*
(bathlon[ib] - bounds[0]);
zone[icount[indx]].y =
deglattokm*
(bathlat[ib] - bounds[2]);
zone[icount[indx]].d = 0.001*bath[ib];
zone[icount[indx]].h = heading;
icount[indx]++;
ndatafile++;
}
}
}
}
status = mb_close(verbose,&mbio_ptr,&error);
mb_freed(verbose,__FILE__,__LINE__,(void **)&beamflag,&error);
mb_freed(verbose,__FILE__,__LINE__,(void **)&bath,&error);
mb_freed(verbose,__FILE__,__LINE__,(void **)&bathlon,&error);
mb_freed(verbose,__FILE__,__LINE__,(void **)&bathlat,&error);
mb_freed(verbose,__FILE__,__LINE__,(void **)&,&error);
mb_freed(verbose,__FILE__,__LINE__,(void **)&ss,&error);
mb_freed(verbose,__FILE__,__LINE__,(void **)&sslon,&error);
mb_freed(verbose,__FILE__,__LINE__,(void **)&sslat,&error);
status = MB_SUCCESS;
error = MB_ERROR_NO_ERROR;
if (verbose >= 2)
fprintf(outfp,"\n");
fprintf(outfp,"%d depth points read from %s\n",
ndatafile,ifile);
/* read data in second swath file */
/* initialize the second swath file */
ndatafile = 0;
if ((status = mb_read_init(
verbose,jfile,jformat,pings,lonflip,bounds,
btime_i,etime_i,speedmin,timegap,
&mbio_ptr,&btime_d,&etime_d,
&beams_bath,&beams_amp,&pixels_ss,&error)) != MB_SUCCESS)
{
mb_error(verbose,error,&message);
fprintf(outfp,"\nMBIO Error returned from function <mb_read_init>:\n%s\n",message);
fprintf(outfp,"\nMultibeam File <%s> not initialized for reading\n",jfile);
fprintf(outfp,"\nProgram <%s> Terminated\n",
program_name);
exit(error);
}
/* allocate memory for reading data arrays */
status = mb_mallocd(verbose,__FILE__,__LINE__,beams_bath*sizeof(char),(void **)&beamflag,&error);
status = mb_mallocd(verbose,__FILE__,__LINE__,beams_bath*sizeof(double),(void **)&bath,&error);
status = mb_mallocd(verbose,__FILE__,__LINE__,beams_bath*sizeof(double),(void **)&bathlon,&error);
status = mb_mallocd(verbose,__FILE__,__LINE__,beams_bath*sizeof(double),(void **)&bathlat,&error);
status = mb_mallocd(verbose,__FILE__,__LINE__,beams_amp*sizeof(double),(void **)&,&error);
status = mb_mallocd(verbose,__FILE__,__LINE__,pixels_ss*sizeof(double),(void **)&ss,&error);
status = mb_mallocd(verbose,__FILE__,__LINE__,pixels_ss*sizeof(double),(void **)&sslon,&error);
status = mb_mallocd(verbose,__FILE__,__LINE__,pixels_ss*sizeof(double),(void **)&sslat,&error);
/* if error initializing memory then quit */
if (error != MB_ERROR_NO_ERROR)
{
mb_error(verbose,error,&message);
fprintf(outfp,"\nMBIO Error allocating data arrays:\n%s\n",
message);
fprintf(outfp,"\nProgram <%s> Terminated\n",
program_name);
exit(error);
}
/* loop over reading */
while (error <= MB_ERROR_NO_ERROR)
{
status = mb_read(verbose,mbio_ptr,&kind,
&rpings,time_i,&time_d,
&navlon,&navlat,
&speed,&heading,
&distance,&altitude,&sonardepth,
&beams_bath,&beams_amp,&pixels_ss,
beamflag,bath,amp,bathlon,bathlat,
ss,sslon,sslat,
comment,&error);
/* time gaps are not a problem here */
if (error == MB_ERROR_TIME_GAP)
{
error = MB_ERROR_NO_ERROR;
status = MB_SUCCESS;
}
/* print debug statements */
if (verbose >= 2)
{
fprintf(stderr,"\ndbg2 Ping read in program <%s>\n",program_name);
fprintf(stderr,"dbg2 kind: %d\n",kind);
fprintf(stderr,"dbg2 beams_bath: %d\n",beams_bath);
fprintf(stderr,"dbg2 beams_amp: %d\n",beams_amp);
fprintf(stderr,"dbg2 pixels_ss: %d\n",pixels_ss);
fprintf(stderr,"dbg2 error: %d\n",error);
fprintf(stderr,"dbg2 status: %d\n",status);
}
if (error == MB_ERROR_NO_ERROR)
{
for (ib=0;ib<beams_bath;ib++)
if (mb_beam_ok(beamflag[ib]))
{
ix = (bathlon[ib] - bounds[0])/dx;
iy = (bathlat[ib] - bounds[2])/dy;
if (ix >= 0 && ix < xdim
&& iy >= 0 && iy < ydim)
{
indx = ix + iy*xdim;
zone = jdata[indx].ptr;
zone[jcount[indx]].x =
deglontokm*
(bathlon[ib] - bounds[0]);
zone[jcount[indx]].y =
deglattokm*
(bathlat[ib] - bounds[2]);
zone[jcount[indx]].d = 0.001*bath[ib];
zone[jcount[indx]].h = heading;
jcount[indx]++;
ndatafile++;
}
}
}
}
status = mb_close(verbose,&mbio_ptr,&error);
mb_freed(verbose,__FILE__,__LINE__,(void **)&beamflag,&error);
mb_freed(verbose,__FILE__,__LINE__,(void **)&bath,&error);
mb_freed(verbose,__FILE__,__LINE__,(void **)&bathlon,&error);
mb_freed(verbose,__FILE__,__LINE__,(void **)&bathlat,&error);
mb_freed(verbose,__FILE__,__LINE__,(void **)&,&error);
mb_freed(verbose,__FILE__,__LINE__,(void **)&ss,&error);
mb_freed(verbose,__FILE__,__LINE__,(void **)&sslon,&error);
mb_freed(verbose,__FILE__,__LINE__,(void **)&sslat,&error);
status = MB_SUCCESS;
error = MB_ERROR_NO_ERROR;
if (verbose >= 2)
fprintf(outfp,"\n");
fprintf(outfp,"%d depth points read from %s\n",
ndatafile,jfile);
/* loop over regions */
for (i=0;i<xdim;i++)
for (j=0;j<ydim;j++)
{
/* set index */
indx = i + j*xdim;
/* print out id info */
fprintf(outfp,"\nRegion %d (%d %d) bounds:\n",j+i*ydim,i,j);
fprintf(outfp," Longitude: %9.4f %9.4f\n",
bounds[0]+dx*i,bounds[0]+dx*(i+1));
fprintf(outfp," Latitude: %9.4f %9.4f\n",
bounds[2]+dy*j,bounds[2]+dy*(j+1));
/* get the best fitting planes */
if (icount[indx] >= MINIMUM_NUMBER_DATA
&& jcount[indx] >= MINIMUM_NUMBER_DATA)
{
/* use data from first data file */
zone = idata[indx].ptr;
/* zero the arrays */
ihh = 0.0;
hx = 0.0;
hy = 0.0;
for (ii=0;ii<nmatrix;ii++)
{
vector[ii] = 0.0;
for (jj=0;jj<nmatrix;jj++)
matrix[ii][jj] = 0.0;
}
/* construct normal equations */
for (kk=0;kk<icount[indx];kk++)
{
ihh += zone[kk].h;
hx += sin(DTR * zone[kk].h);
hy += cos(DTR * zone[kk].h);
xx[0] = 1.0;
xx[1] = zone[kk].x;
xx[2] = zone[kk].y;
for (ii=0;ii<nmatrix;ii++)
{
vector[ii] += zone[kk].d * xx[ii];
for (jj=0;jj<nmatrix;jj++)
{
matrix[ii][jj] += xx[ii] * xx[jj];
}
}
}
/* solve the normal equations */
gauss((double *)matrix,vector,nmatrix,nmatrix,1.0e-08,&error,1);
/* get the solution */
iaa = vector[0];
ibb = vector[1];
icc = vector[2];
hx = hx/icount[indx];
hy = hy/icount[indx];
dd = sqrt(hx * hx + hy * hy);
if (dd > 0.0)
ihh = RTD * atan2((hx/dd), (hy/dd));
else
ihh = ihh/icount[indx];
if (ihh > 360.0)
ihh = ihh - 360.0;
else if (ihh < 0.0)
ihh = ihh + 360.0;
/* use data from second data file */
zone = jdata[indx].ptr;
/* zero the arrays */
jhh = 0.0;
hx = 0.0;
hy = 0.0;
for (ii=0;ii<nmatrix;ii++)
{
vector[ii] = 0.0;
for (jj=0;jj<nmatrix;jj++)
matrix[ii][jj] = 0.0;
}
/* construct normal equations */
for (kk=0;kk<jcount[indx];kk++)
{
jhh += zone[kk].h;
hx += sin(DTR * zone[kk].h);
hy += cos(DTR * zone[kk].h);
xx[0] = 1.0;
xx[1] = zone[kk].x;
xx[2] = zone[kk].y;
for (ii=0;ii<nmatrix;ii++)
{
vector[ii] += zone[kk].d * xx[ii];
for (jj=0;jj<nmatrix;jj++)
{
matrix[ii][jj] += xx[ii] * xx[jj];
}
}
}
/* solve the normal equations */
gauss((double *)matrix,vector,nmatrix,nmatrix,1.0e-08,&error,1);
if (error != 0)
{
fprintf(outfp,"matrix inversion error: %d\n",error);
}
/* get the solution */
jaa = vector[0];
jbb = vector[1];
jcc = vector[2];
hx = hx/jcount[indx];
hy = hy/jcount[indx];
dd = sqrt(hx * hx + hy * hy);
if (dd > 0.0)
jhh = RTD * atan2((hx/dd), (hy/dd));
else
jhh = jhh/jcount[indx];
if (jhh > 360.0)
jhh = jhh - 360.0;
else if (jhh < 0.0)
jhh = jhh + 360.0;
/* report results */
fprintf(outfp,"First data file: %s\n",ifile);
fprintf(outfp," Number of data: %d\n",
icount[indx]);
fprintf(outfp," Mean heading: %f\n",ihh);
fprintf(outfp," Plane fit: %f %f %f\n",
iaa,ibb,icc);
fprintf(outfp,"Second data file: %s\n",jfile);
fprintf(outfp," Number of data: %d\n",
jcount[indx]);
fprintf(outfp," Mean heading: %f\n",jhh);
fprintf(outfp," Plane fit: %f %f %f\n",
jaa,jbb,jcc);
/* calculate roll bias */
if (fabs(ihh - jhh) > 90.0)
{
isine = sin(DTR*ihh);
icosine = cos(DTR*ihh);
jsine = sin(DTR*jhh);
jcosine = cos(DTR*jhh);
if (fabs(jcosine-icosine) > 1.0)
{
roll_bias = -(ibb - jbb)
/(jcosine - icosine);
}
else
{
roll_bias = -(icc - jcc)
/(isine - jsine);
}
fprintf(outfp,"Roll bias: %f (%f degrees)\n",
roll_bias,atan(roll_bias)/DTR);
fprintf(outfp,"Roll bias is positive to starboard, negative to port.\n");
fprintf(outfp,"A postive roll bias means the vertical reference used by \n the swath system is biased to starboard, \n giving rise to shallow bathymetry to port and \n deep bathymetry to starboard.\n");
}
else
fprintf(outfp,"Track headings too similar to calculate roll bias!\n");
}
else
fprintf(outfp,"Not enough data to proceed!\n");
}
/* deallocate space for data */
for (i=0;i<xdim;i++)
for (j=0;j<ydim;j++)
{
k = i*ydim + j;
if (icount[k] > 0)
{
status = mb_freed(verbose,__FILE__,__LINE__,(void **)&idata[k].ptr,&error);
}
if (jcount[k] > 0)
{
status = mb_freed(verbose,__FILE__,__LINE__,(void **)&jdata[k].ptr,&error);
}
}
status = mb_freed(verbose,__FILE__,__LINE__,(void **)&idata,&error);
status = mb_freed(verbose,__FILE__,__LINE__,(void **)&jdata,&error);
status = mb_freed(verbose,__FILE__,__LINE__,(void **)&icount,&error);
status = mb_freed(verbose,__FILE__,__LINE__,(void **)&jcount,&error);
/* check memory */
if (verbose >= 4)
status = mb_memory_list(verbose,&error);
/* print output debug statements */
if (verbose >= 2)
{
fprintf(stderr,"\ndbg2 Program <%s> completed\n",
program_name);
fprintf(stderr,"dbg2 Ending status:\n");
fprintf(stderr,"dbg2 status: %d\n",status);
}
/* end it all */
exit(error);
}
int
main()
{
mb_id_t mbid;
pid_t pid;
int nb_loops;
int status;
unsigned long mbcheck;
const char *tagmb = "test_mailbox";
cm_openlog("test_mailbox", CM_TRACE_LEVEL_NOTICE);
mbid = mb_create(tagmb, MB_LEN);
if (mbid == MB_INVALID_ID) {
return (1);
}
pid = fork();
if (pid == 0) {
/*
* Child - process callback
*/
mb_id_t child_mbid = mb_init(tagmb, act_callback);
if (mb_len(mbid) != MB_LEN) {
cm_trace(CM_TRACE_LEVEL_ERROR,
"mb_len returns bad result");
exit(1);
}
while (1) {
if (mb_hbt(child_mbid, NULL) != MB_OK) {
cm_trace(CM_TRACE_LEVEL_ERROR,
"mb_hbt failed %s", strerror(errno));
exit(1);
}
usleep(100000);
}
} else if (pid == -1) {
cm_trace(CM_TRACE_LEVEL_ERROR, "fork failed");
exit(1);
}
/*
* Father - check service state machine
*/
if (wait_for(mbid, SRV_READY) < 0) {
cm_trace(CM_TRACE_LEVEL_ERROR, "failed to init");
kill(pid, SIGKILL);
return (1);
}
if (wait_for(mbid, SRV_RUNNING) < 0) {
cm_trace(CM_TRACE_LEVEL_ERROR, "failed to start");
kill(pid, SIGKILL);
return (1);
}
if (mb_read(mbid, &mbcheck, MB_OFFSET, sizeof(mbcheck)) == MB_ERROR) {
cm_trace(CM_TRACE_LEVEL_ERROR, "mb_read failed");
kill(pid, SIGKILL);
return (1);
}
if (mbcheck != MB_CHECK) {
cm_trace(CM_TRACE_LEVEL_ERROR, "mb_read returns wrong result");
kill(pid, SIGKILL);
return (1);
}
if (wait_for(mbid, SRV_READY) < 0) {
cm_trace(CM_TRACE_LEVEL_ERROR, "failed to stop");
kill(pid, SIGKILL);
return (1);
}
if (mb_setexpectedstate(mbid, SRV_DESTROY) == MB_ERROR) {
cm_trace(CM_TRACE_LEVEL_ERROR, "failed to destroy");
kill(pid, SIGKILL);
return (1);
}
nb_loops = 0;
do {
pid_t wpid = waitpid(pid, &status, WNOHANG);
if (wpid == pid) {
break;
} else if (wpid < 0) {
cm_trace(CM_TRACE_LEVEL_ERROR, "waitpid failed");
kill(pid, SIGKILL);
return (1);
}
usleep(100000);
} while (nb_loops++ < 5);
if (nb_loops >= 5) {
cm_trace(CM_TRACE_LEVEL_ERROR, "destroy failed");
kill(pid, SIGKILL);
return (1);
}
if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
cm_trace(CM_TRACE_LEVEL_ERROR, "bad exit status");
kill(pid, SIGKILL);
return (1);
}
cm_trace(CM_TRACE_LEVEL_NOTICE, "mailbox test passed");
cm_closelog();
return (0);
}
int main (int argc, char **argv)
{
#ifdef MBCONTOURFILTER
char program_name[] = "MBCONTOURFILTER";
char help_message[] = "MBCONTOURFILTER is a utility which creates a pen plot \ncontour map of multibeam swath bathymetry. \nThe primary purpose of this program is to serve as \npart of a real-time plotting system. The contour \nlevels and colors can be controlled \ndirectly or set implicitly using contour and color change intervals. \nContours can also be set to have ticks pointing downhill.";
char usage_message[] = "mbcontourfilter -Jparameters -Rwest/east/south/north \n\t[-Acontour_int/color_int/tick_int/label_int/tick_len/label_hgt/label_spacing \n\t-Btickinfo -byr/mon/day/hour/min/sec -Ccontourfile \n\t-Dtime_tick/time_annot/date_annot/time_tick_len -Eyr/mon/day/hour/min/sec \n\t-fformat -Fred/green/blue -Idatalist -K -Llonflip -M -O -Nnplot \n\t-P -ppings -Q -Ttimegap -U -Xx-shift -Yy-shift -Zalgorithm -#copies -V -H]";
#else
char program_name[] = "MBCONTOUR";
char help_message[] = "MBCONTOUR is a GMT compatible utility which creates a color postscript \ncontour map of multibeam swath bathymetry. \nComplete maps are made by using MBCONTOUR in conjunction with the \nusual GMT programs. The contour levels and colors can be controlled \ndirectly or set implicitly using contour and color change intervals. \nContours can also be set to have ticks pointing downhill.";
char usage_message[] = "mbcontour -Jparameters -Rwest/east/south/north \n\t[-Acontour_int/color_int/tick_int/label_int/tick_len/label_hgt/label_spacing \n\t-Btickinfo -byr/mon/day/hour/min/sec -Ccontourfile -ccopies \n\t-Dtime_tick/time_annot/date_annot/time_tick_len \n\t-Eyr/mon/day/hour/min/sec \n\t-fformat -Fred/green/blue -Idatalist -K -Llonflip -Nnplot -O \n\t-P -ppings -U -Xx-shift -Yy-shift -Zalgorithm -V -H]";
#endif
extern char *optarg;
int argc_gmt = 0;
char *argv_gmt[MBCONTOUR_GMT_ARG_MAX];
int errflg = 0;
int c;
int help = 0;
int flag = 0;
/* MBIO status variables */
int status = MB_SUCCESS;
int verbose = 0;
int error = MB_ERROR_NO_ERROR;
char *message = NULL;
/* MBIO read control parameters */
char read_file[MBCONTOUR_LABEL_LEN];
int read_datalist;
int read_data;
void *datalist;
int look_processed = MB_DATALIST_LOOK_UNSET;
double file_weight;
FILE *fp;
int format;
int pings;
int lonflip;
int lonflip_set = MB_NO;
double bounds[4];
double mb_bounds[4];
int btime_i[7];
int etime_i[7];
double btime_d;
double etime_d;
double speedmin;
double timegap;
char file[MB_PATH_MAXLINE];
int file_in_bounds;
int beams_bath;
int beams_amp;
int pixels_ss;
void *mbio_ptr = NULL;
/* mbio read values */
struct swath *swath_plot = NULL;
struct ping *pingcur = NULL;
int kind;
int pings_read;
int time_i[7];
double time_d;
double navlon;
double navlat;
double speed;
double heading;
double distance;
double altitude;
double sonardepth;
char *beamflag = NULL;
double *bath = NULL;
double *bathlon = NULL;
double *bathlat = NULL;
double *amp = NULL;
double *ss = NULL;
double *sslon = NULL;
double *sslat = NULL;
char comment[256];
int pingnumber;
/* plot control variables */
int contour_algorithm;
char contourfile[MB_PATH_MAXLINE];
int plot;
int done;
int flush;
int save_new;
int *npings = NULL;
int nping_read;
int nplot;
int plot_contours;
int plot_triangles;
int set_contours;
double cont_int;
double col_int;
double tick_int;
double label_int;
double tick_len;
double label_hgt;
double label_spacing;
double tick_len_map;
double label_hgt_map;
double label_spacing_map;
int plot_name;
int plotted_name;
int plot_track;
double time_tick_int;
double time_annot_int;
double date_annot_int;
double time_tick_len;
double time_tick_len_map;
double name_hgt;
double name_hgt_map;
int name_perp;
double scale;
int bathy_in_feet;
int plot_pingnumber;
int pingnumber_tick_int;
int pingnumber_annot_int;
double pingnumber_tick_len;
double pingnumber_tick_len_map;
/* pen variables */
int ncolor;
int nlevel;
double *level = NULL;
int *red = NULL;
int *green = NULL;
int *blue = NULL;
int *label = NULL;
int *tick = NULL;
/* inch to map scale */
double inchtolon;
/* other variables */
char line[MBCONTOUR_LABEL_LEN];
char labelstr[MBCONTOUR_LABEL_LEN], tickstr[MBCONTOUR_LABEL_LEN];
int count;
int setcolors;
double navlon_old;
double navlat_old;
int i1, i2;
double d1, d2, d3, d4, d5, d6, d7;
int nscan;
int i;
/* get current mb default values */
status = mb_defaults(verbose,&format,&pings,&lonflip,bounds,
btime_i,etime_i,&speedmin,&timegap);
/* set default input to stdin */
strcpy (read_file, "stdin");
/* initialize some values */
format = -1;
read_datalist = MB_NO;
contour_algorithm = MB_CONTOUR_OLD;
strcpy (contourfile,"\0");
set_contours = MB_NO;
bounds[0] = 0.0;
bounds[1] = 0.0;
bounds[2] = 0.0;
bounds[3] = 0.0;
scale = 0.0;
nplot = 0;
cont_int = 25.;
col_int = 100.;
tick_int = 100.;
label_int = 100.;
label_hgt = 0.1;
label_spacing = 0.0;
tick_len = 0.05;
plot_name = MB_NO;
plot_track = MB_NO;
time_tick_int = 0.25;
time_annot_int = 1.0;
date_annot_int = 4.0;
time_tick_len = 0.1;
name_hgt = 0.1;
name_perp = MB_NO;
ncolor = 4;
nlevel = 0;
plot_contours = MB_NO;
plot_triangles = MB_NO;
bathy_in_feet = MB_NO;
plot_pingnumber = MB_NO;
pingnumber_tick_int = 50;
pingnumber_annot_int = 100;
pingnumber_tick_len = 0.1;
/* get GMT options into separate argv */
argv_gmt[0] = argv[0];
argc_gmt = 1;
for (i=1;i<argc;i++)
{
if (argv[i][0] == '-')
{
switch (argv[i][1])
{
case 'B':
case 'F':
case 'J':
case 'j':
case 'K':
case 'k':
case 'O':
case 'o':
case 'P':
case 'R':
case 'r':
case 'U':
case 'u':
case 'V':
case 'v':
case 'X':
case 'x':
case 'Y':
case 'y':
case '#':
if (argc_gmt < MBCONTOUR_GMT_ARG_MAX)
{
argv_gmt[argc_gmt] = argv[i];
argc_gmt++;
break;
}
}
}
}
/* deal with mb options */
while ((c = getopt(argc, argv, "VvHhA:a:B:b:C:c:D:d:E:e:F:f:G:g:I:i:J:j:KkL:l:M:m:N:n:OoPp:QqR:r:S:s:T:t:UuWwX:x:Y:y:Z:z:")) != -1)
switch (c)
{
case 'A':
case 'a':
nscan = sscanf (optarg, "%lf/%lf/%lf/%lf/%lf/%lf/%lf",
&d1,&d2,&d3,&d4,&d5,&d6,&d7);
if (nscan >= 1)
cont_int = d1;
if (nscan >= 2)
col_int = d2;
if (nscan >= 3)
tick_int = d3;
if (nscan >= 4)
label_int = d4;
if (nscan >= 5)
tick_len = d5;
if (nscan >= 6)
label_hgt = d6;
if (nscan >= 7)
label_spacing = d7;
if (nscan >= 1)
plot_contours = MB_YES;
break;
case 'b':
sscanf (optarg, "%d/%d/%d/%d/%d/%d",
&btime_i[0],&btime_i[1],&btime_i[2],
&btime_i[3],&btime_i[4],&btime_i[5]);
btime_i[6] = 0;
break;
case 'C':
sscanf (optarg,"%s", contourfile);
plot_contours = MB_YES;
set_contours = MB_YES;
break;
case 'D':
case 'd':
sscanf (optarg, "%lf/%lf/%lf/%lf",
&time_tick_int,&time_annot_int,
&date_annot_int,&time_tick_len);
plot_track = MB_YES;
break;
case 'E':
case 'e':
sscanf (optarg, "%d/%d/%d/%d/%d/%d",
&etime_i[0],&etime_i[1],&etime_i[2],
&etime_i[3],&etime_i[4],&etime_i[5]);
etime_i[6] = 0;
break;
case 'f':
sscanf (optarg, "%d",&format);
break;
case 'G':
case 'g':
nscan = sscanf (optarg, "%lf/%d", &name_hgt, &name_perp);
plot_name = MB_YES;
if (nscan < 1)
name_hgt = 0.1;
if (nscan < 2)
name_perp = MB_NO;
break;
case 'H':
case 'h':
help++;
break;
case 'I':
case 'i':
sscanf (optarg,"%s", read_file);
flag++;
break;
case 'J':
if (optarg[0] == 'm')
sscanf (&optarg[1],"%lf", &scale);
flag++;
break;
case 'L':
case 'l':
sscanf (optarg,"%d", &lonflip);
lonflip_set = MB_YES;
flag++;
break;
case 'M':
case 'm':
nscan = sscanf (optarg, "%d/%d/%lf",
&i1,&i2,&d3);
if (nscan >= 1)
pingnumber_tick_int = i1;
if (nscan >= 2)
pingnumber_annot_int = i2;
if (nscan >= 3)
pingnumber_tick_len = d3;
if (nscan >= 1)
plot_pingnumber = MB_YES;
break;
case 'N':
case 'n':
sscanf (optarg,"%d", &nplot);
if (nplot < 3) nplot = 3;
break;
case 'p':
sscanf (optarg,"%d", &pings);
flag++;
break;
case 'Q':
case 'q':
plot_triangles = MB_YES;
break;
case 'R':
case 'r':
sscanf(optarg,"%lf/%lf/%lf/%lf",
&bounds[0],&bounds[1],
&bounds[2],&bounds[3]);
break;
case 'S':
case 's':
sscanf (optarg, "%lf", &speedmin);
break;
case 'T':
case 't':
sscanf (optarg,"%lf", &timegap);
flag++;
break;
case 'V':
case 'v':
verbose++;
break;
case 'W':
case 'w':
bathy_in_feet = MB_YES;
break;
case 'Z':
case 'z':
sscanf (optarg,"%d", &contour_algorithm);
flag++;
break;
case 'B':
case 'F':
case 'K':
case 'O':
case 'P':
case 'U':
case 'X':
case 'x':
case 'Y':
case 'y':
case '#':
break;
case '?':
errflg++;
}
/* if error flagged then print it and exit */
if (errflg)
{
fprintf(stderr,"usage: %s\n", usage_message);
fprintf(stderr,"\nProgram <%s> Terminated\n",
program_name);
error = MB_ERROR_BAD_USAGE;
exit(error);
}
/* set number of pings to be plotted if not set */
if (nplot == 0 && contour_algorithm == MB_CONTOUR_TRIANGLES)
nplot = 5;
else if (nplot == 0)
nplot = 50;
/* if nothing set to be plotted, plot contours and track */
if (plot_contours == MB_NO && plot_triangles == MB_NO
&& plot_track == MB_NO && plot_pingnumber == MB_NO)
{
plot_contours = MB_YES;
plot_track = MB_YES;
}
if (plot_name == MB_YES && plot_track == MB_NO
&& plot_pingnumber == MB_NO)
{
plot_track = MB_YES;
}
if (plot_track == MB_NO
&& plot_pingnumber == MB_YES)
{
plot_track = MB_YES;
time_tick_int = 10000000.0;
time_annot_int = 10000000.0;
date_annot_int = 10000000.0;
}
/* print starting message */
if (verbose == 1 || help)
{
fprintf(stderr,"\nProgram %s\n",program_name);
fprintf(stderr,"MB-system Version %s\n",MB_VERSION);
}
/* if help desired then print it and exit */
if (help)
{
fprintf(stderr,"\n%s\n",help_message);
fprintf(stderr,"\nusage: %s\n", usage_message);
exit(error);
}
/* initialize plotting */
status = plot_init(verbose,argc_gmt,argv_gmt,bounds,&scale,&inchtolon,&error);
/* if error flagged then print it and exit */
if (status == MB_FAILURE)
{
fprintf(stderr,"usage: %s\n", usage_message);
fprintf(stderr,"GMT option error\n");
fprintf(stderr,"\nProgram <%s> Terminated\n",
program_name);
error = MB_ERROR_BAD_USAGE;
exit(error);
}
/* print starting debug statements */
if (verbose >= 2)
{
fprintf(stderr,"\ndbg2 Program <%s>\n",program_name);
fprintf(stderr,"dbg2 MB-system Version %s\n",MB_VERSION);
fprintf(stderr,"dbg2 Control Parameters:\n");
fprintf(stderr,"dbg2 verbose: %d\n",verbose);
fprintf(stderr,"dbg2 help: %d\n",help);
fprintf(stderr,"dbg2 format: %d\n",format);
fprintf(stderr,"dbg2 pings: %d\n",pings);
fprintf(stderr,"dbg2 lonflip: %d\n",lonflip);
fprintf(stderr,"dbg2 btime_i[0]: %d\n",btime_i[0]);
fprintf(stderr,"dbg2 btime_i[1]: %d\n",btime_i[1]);
fprintf(stderr,"dbg2 btime_i[2]: %d\n",btime_i[2]);
fprintf(stderr,"dbg2 btime_i[3]: %d\n",btime_i[3]);
fprintf(stderr,"dbg2 btime_i[4]: %d\n",btime_i[4]);
fprintf(stderr,"dbg2 btime_i[5]: %d\n",btime_i[5]);
fprintf(stderr,"dbg2 btime_i[6]: %d\n",btime_i[6]);
fprintf(stderr,"dbg2 etime_i[0]: %d\n",etime_i[0]);
fprintf(stderr,"dbg2 etime_i[1]: %d\n",etime_i[1]);
fprintf(stderr,"dbg2 etime_i[2]: %d\n",etime_i[2]);
fprintf(stderr,"dbg2 etime_i[3]: %d\n",etime_i[3]);
fprintf(stderr,"dbg2 etime_i[4]: %d\n",etime_i[4]);
fprintf(stderr,"dbg2 etime_i[5]: %d\n",etime_i[5]);
fprintf(stderr,"dbg2 etime_i[6]: %d\n",etime_i[6]);
fprintf(stderr,"dbg2 speedmin: %f\n",speedmin);
fprintf(stderr,"dbg2 timegap: %f\n",timegap);
fprintf(stderr,"dbg2 read file: %s\n",read_file);
fprintf(stderr,"dbg2 bounds[0]: %f\n",bounds[0]);
fprintf(stderr,"dbg2 bounds[1]: %f\n",bounds[1]);
fprintf(stderr,"dbg2 bounds[2]: %f\n",bounds[2]);
fprintf(stderr,"dbg2 bounds[3]: %f\n",bounds[3]);
fprintf(stderr,"dbg2 contour algorithm: %d\n",contour_algorithm);
fprintf(stderr,"dbg2 plot contours: %d\n",plot_contours);
fprintf(stderr,"dbg2 plot triangles: %d\n",plot_triangles);
fprintf(stderr,"dbg2 plot track: %d\n",plot_track);
fprintf(stderr,"dbg2 plot_pingnumber: %d\n",plot_pingnumber);
fprintf(stderr,"dbg2 plot name: %d\n",plot_name);
fprintf(stderr,"dbg2 contour interval: %f\n",cont_int);
fprintf(stderr,"dbg2 color interval: %f\n",col_int);
fprintf(stderr,"dbg2 tick interval: %f\n",tick_int);
fprintf(stderr,"dbg2 label interval: %f\n",label_int);
fprintf(stderr,"dbg2 tick length: %f\n",tick_len);
fprintf(stderr,"dbg2 label height: %f\n",label_hgt);
fprintf(stderr,"dbg2 label spacing: %f\n",label_spacing);
fprintf(stderr,"dbg2 number contoured: %d\n",nplot);
fprintf(stderr,"dbg2 time tick int: %f\n",time_tick_int);
fprintf(stderr,"dbg2 time interval: %f\n",time_annot_int);
fprintf(stderr,"dbg2 date interval: %f\n",date_annot_int);
fprintf(stderr,"dbg2 time tick length: %f\n",time_tick_len);
fprintf(stderr,"dbg2 name height: %f\n",name_hgt);
fprintf(stderr,"dbg2 pingnumber tick int: %d\n",pingnumber_tick_int);
fprintf(stderr,"dbg2 pingnumber annot int: %d\n",pingnumber_annot_int);
fprintf(stderr,"dbg2 pingnumber tick len: %f\n",pingnumber_tick_len);
fprintf(stderr,"dbg2 bathy_in_feet: %d\n\n",bathy_in_feet);
}
/* if bounds not specified then quit */
if (bounds[0] >= bounds[1] || bounds[2] >= bounds[3]
|| bounds[2] <= -90.0 || bounds[3] >= 90.0)
{
fprintf(stderr,"\nRegion bounds not properly specified:\n\t%f %f %f %f\n",bounds[0],bounds[1],bounds[2],bounds[3]);
fprintf(stderr,"\nProgram <%s> Terminated\n",
program_name);
error = MB_ERROR_BAD_PARAMETER;
exit(error);
}
/* scale label and tick sizes */
label_hgt_map = inchtolon * label_hgt;
label_spacing_map = inchtolon * label_spacing;
tick_len_map = inchtolon * tick_len;
time_tick_len_map = inchtolon * time_tick_len;
name_hgt_map = inchtolon * name_hgt;
pingnumber_tick_len_map = inchtolon * pingnumber_tick_len;
/* read contours from file */
if (set_contours == MB_YES)
{
/* open contour file */
if ((fp = fopen(contourfile,"r")) == NULL)
{
error = MB_ERROR_OPEN_FAIL;
fprintf(stderr,"\nUnable to open contour file: %s\n",
contourfile);
fprintf(stderr,"\nProgram <%s> Terminated\n",
program_name);
exit(error);
}
/* count lines in file */
nlevel = 0;
while (fgets(line,MBCONTOUR_LABEL_LEN,fp) != NULL)
nlevel++;
fclose(fp);
/* set number of colors equal to levels */
ncolor = nlevel;
/* allocate memory */
status = mb_mallocd(verbose, __FILE__, __LINE__, nlevel*sizeof(double), (void **)&level,&error);
status = mb_mallocd(verbose, __FILE__, __LINE__, nlevel*sizeof(int), (void **)&label,&error);
status = mb_mallocd(verbose, __FILE__, __LINE__, nlevel*sizeof(int), (void **)&tick,&error);
status = mb_mallocd(verbose, __FILE__, __LINE__, ncolor*sizeof(int), (void **)&red,&error);
status = mb_mallocd(verbose, __FILE__, __LINE__, ncolor*sizeof(int), (void **)&green,&error);
status = mb_mallocd(verbose, __FILE__, __LINE__, ncolor*sizeof(int), (void **)&blue,&error);
/* reopen contour file */
if ((fp = fopen(contourfile,"r")) == NULL)
{
error = MB_ERROR_OPEN_FAIL;
fprintf(stderr,"\nUnable to open contour file: %s\n",
contourfile);
fprintf(stderr,"\nProgram <%s> Terminated\n",
program_name);
exit(error);
}
/* read contour levels from file */
nlevel = 0;
while (fgets(line,MBCONTOUR_LABEL_LEN,fp) != NULL)
{
count = sscanf(line,"%lf %s %s %d %d %d",
&level[nlevel],labelstr,tickstr,
&red[nlevel],&green[nlevel],&blue[nlevel]);
setcolors = MB_YES;
if (count >= 2 && labelstr[0] == 'a')
label[nlevel] = 1;
else if (count >= 2 && labelstr[0] == 'n')
label[nlevel] = 0;
else
{
label[nlevel] = 0;
setcolors = MB_NO;
}
if (count >= 3 && tickstr[0] == 't')
tick[nlevel] = 1;
else if (count >= 3 && tickstr[0] == 'n')
tick[nlevel] = 0;
else
{
tick[nlevel] = 0;
setcolors = MB_NO;
}
if (count < 6 || setcolors == MB_NO)
{
red[nlevel] = 0;
green[nlevel] = 0;
blue[nlevel] = 0;
}
if (count > 0) nlevel++;
}
fclose(fp);
}
/* else set default colors and use contour intervals */
else
{
/* set defaults */
nlevel = 0;
ncolor = 4;
/* allocate memory */
status = mb_mallocd(verbose, __FILE__, __LINE__, ncolor*sizeof(int), (void **)&red,&error);
status = mb_mallocd(verbose, __FILE__, __LINE__, ncolor*sizeof(int), (void **)&green,&error);
status = mb_mallocd(verbose, __FILE__, __LINE__, ncolor*sizeof(int), (void **)&blue,&error);
/* set colors */
red[0] = 0; green[0] = 0; blue[0] = 0; /* black */
red[1] = 255; green[1] = 0; blue[1] = 0; /* red */
red[2] = 0; green[2] = 200; blue[2] = 0; /* green */
red[3] = 0; green[3] = 0; blue[3] = 255; /* blue */
}
/* set colors */
set_colors(ncolor,red,green,blue);
/* set bounds for multibeam reading larger than
map borders */
mb_bounds[0] = bounds[0] - 0.25*(bounds[1] - bounds[0]);
mb_bounds[1] = bounds[1] + 0.25*(bounds[1] - bounds[0]);
mb_bounds[2] = bounds[2] - 0.25*(bounds[3] - bounds[2]);
mb_bounds[3] = bounds[3] + 0.25*(bounds[3] - bounds[2]);
/* set lonflip if possible */
if (lonflip_set == MB_NO)
{
if (mb_bounds[0] < -180.0)
lonflip = -1;
else if (mb_bounds[1] > 180.0)
lonflip = 1;
else if (lonflip == -1 && mb_bounds[1] > 0.0)
lonflip = 0;
else if (lonflip == 1 && mb_bounds[0] < 0.0)
lonflip = 0;
}
/* determine whether to read one file or a list of files */
if (format < 0)
read_datalist = MB_YES;
/* open file list */
nping_read = 0;
if (read_datalist == MB_YES)
{
if ((status = mb_datalist_open(verbose,&datalist,
read_file,look_processed,&error)) != MB_SUCCESS)
{
error = MB_ERROR_OPEN_FAIL;
fprintf(stderr,"\nUnable to open data list file: %s\n",
read_file);
fprintf(stderr,"\nProgram <%s> Terminated\n",
program_name);
exit(error);
}
if ((status = mb_datalist_read(verbose,datalist,
file,&format,&file_weight,&error))
== MB_SUCCESS)
read_data = MB_YES;
else
read_data = MB_NO;
}
else
{
strcpy(file,read_file);
read_data = MB_YES;
}
/* loop over files in file list */
if (verbose == 1)
fprintf(stderr,"\n");
while (read_data == MB_YES)
{
/* check for mbinfo file - get file bounds if possible */
status = mb_check_info(verbose, file, lonflip, bounds,
&file_in_bounds, &error);
if (status == MB_FAILURE)
{
file_in_bounds = MB_YES;
status = MB_SUCCESS;
error = MB_ERROR_NO_ERROR;
}
/* read if data may be in bounds */
if (file_in_bounds == MB_YES)
{
/* check for "fast bathymetry" or "fbt" file */
if (plot_contours == MB_YES)
{
mb_get_fbt(verbose, file, &format, &error);
}
/* else check for "fast nav" or "fnv" file */
else if (plot_track == MB_YES || plot_pingnumber == MB_YES)
{
mb_get_fnv(verbose, file, &format, &error);
}
/* call mb_read_init() */
if ((status = mb_read_init(
verbose,file,format,pings,lonflip,mb_bounds,
btime_i,etime_i,speedmin,timegap,
&mbio_ptr,&btime_d,&etime_d,
&beams_bath,&beams_amp,&pixels_ss,&error)) != MB_SUCCESS)
{
mb_error(verbose,error,&message);
fprintf(stderr,"\nMBIO Error returned from function <mb_read_init>:\n%s\n",message);
fprintf(stderr,"\nMultibeam File <%s> not initialized for reading\n",file);
fprintf(stderr,"\nProgram <%s> Terminated\n",
program_name);
exit(error);
}
/* allocate memory for data arrays */
if (error == MB_ERROR_NO_ERROR)
status = mb_register_array(verbose, mbio_ptr, MB_MEM_TYPE_BATHYMETRY,
sizeof(char), (void **)&beamflag, &error);
if (error == MB_ERROR_NO_ERROR)
status = mb_register_array(verbose, mbio_ptr, MB_MEM_TYPE_BATHYMETRY,
sizeof(double), (void **)&bath, &error);
if (error == MB_ERROR_NO_ERROR)
status = mb_register_array(verbose, mbio_ptr, MB_MEM_TYPE_AMPLITUDE,
sizeof(double), (void **)&, &error);
if (error == MB_ERROR_NO_ERROR)
status = mb_register_array(verbose, mbio_ptr, MB_MEM_TYPE_BATHYMETRY,
sizeof(double), (void **)&bathlon, &error);
if (error == MB_ERROR_NO_ERROR)
status = mb_register_array(verbose, mbio_ptr, MB_MEM_TYPE_BATHYMETRY,
sizeof(double), (void **)&bathlat, &error);
if (error == MB_ERROR_NO_ERROR)
status = mb_register_array(verbose, mbio_ptr, MB_MEM_TYPE_SIDESCAN,
sizeof(double), (void **)&ss, &error);
if (error == MB_ERROR_NO_ERROR)
status = mb_register_array(verbose, mbio_ptr, MB_MEM_TYPE_SIDESCAN,
sizeof(double), (void **)&sslon, &error);
if (error == MB_ERROR_NO_ERROR)
status = mb_register_array(verbose, mbio_ptr, MB_MEM_TYPE_SIDESCAN,
sizeof(double), (void **)&sslat, &error);
/* if error initializing memory then quit */
if (error != MB_ERROR_NO_ERROR)
{
mb_error(verbose,error,&message);
fprintf(stderr,"\nMBIO Error allocating data arrays:\n%s\n",message);
fprintf(stderr,"\nProgram <%s> Terminated\n",
program_name);
exit(error);
}
/* initialize contour controls */
status = mb_contour_init(verbose,&swath_plot,nplot,beams_bath,
contour_algorithm,
plot_contours,plot_triangles,
plot_track,plot_name,plot_pingnumber,
cont_int,col_int,tick_int,label_int,
tick_len_map,label_hgt_map,label_spacing_map,
ncolor,nlevel,level,label,tick,
time_tick_int,time_annot_int,
date_annot_int,time_tick_len_map,name_hgt_map,
pingnumber_tick_int,pingnumber_annot_int,
pingnumber_tick_len_map,
&error);
swath_plot->beams_bath = beams_bath;
/* if error initializing memory then quit */
if (error != MB_ERROR_NO_ERROR)
{
mb_error(verbose,error,&message);
fprintf(stderr,"\nMBIO Error allocating contour control structure:\n%s\n",message);
fprintf(stderr,"\nProgram <%s> Terminated\n",
program_name);
exit(error);
}
/* print message */
if (verbose >= 2)
fprintf(stderr,"\n");
if (verbose >= 1)
fprintf(stderr,"processing data in %s...\n",file);
/* loop over reading */
npings = &swath_plot->npings;
*npings = 0;
done = MB_NO;
plotted_name = MB_NO;
while (done == MB_NO)
{
/* read the next ping */
status = mb_read(verbose,mbio_ptr,&kind,
&pings_read,time_i,&time_d,
&navlon,&navlat,
&speed,&heading,
&distance,&altitude,&sonardepth,
&beams_bath,&beams_amp,&pixels_ss,
beamflag,bath,amp,bathlon,bathlat,
ss,sslon,sslat,
comment,&error);
/* get pingnumber */
if (status == MB_SUCCESS)
{
status = mb_pingnumber(verbose,mbio_ptr,&pingnumber,&error);
}
/* copy data to swath_plot */
if (status == MB_SUCCESS || error == MB_ERROR_TIME_GAP)
{
pingcur = &swath_plot->pings[*npings];
/* make sure enough memory is allocated */
if (pingcur->beams_bath_alloc < beams_bath)
{
status = mb_reallocd(verbose, __FILE__, __LINE__, beams_bath*sizeof(char),
(void **)&(pingcur->beamflag),&error);
status = mb_reallocd(verbose, __FILE__, __LINE__, beams_bath*sizeof(double),
(void **)&(pingcur->bath),&error);
status = mb_reallocd(verbose, __FILE__, __LINE__, beams_bath*sizeof(double),
(void **)&(pingcur->bathlon),&error);
status = mb_reallocd(verbose, __FILE__, __LINE__, beams_bath*sizeof(double),
(void **)&(pingcur->bathlat),&error);
status = mb_reallocd(verbose,__FILE__,__LINE__,beams_bath*sizeof(int),
(void **)&(pingcur->bflag[0]),&error);
status = mb_reallocd(verbose,__FILE__,__LINE__,beams_bath*sizeof(int),
(void **)&(pingcur->bflag[1]),&error);
pingcur->beams_bath_alloc = beams_bath;
}
/* insert the data */
for (i=0;i<7;i++)
pingcur->time_i[i] = time_i[i];
pingcur->time_d = time_d;
pingcur->navlon = navlon;
pingcur->navlat = navlat;
pingcur->heading = heading;
pingcur->beams_bath = beams_bath;
pingcur->pingnumber = pingnumber;
for (i=0;i<beams_bath;i++)
{
pingcur->beamflag[i] = beamflag[i];
pingcur->bath[i] = bath[i];
pingcur->bathlon[i] = bathlon[i];
pingcur->bathlat[i] = bathlat[i];
pingcur->bflag[0][i] = 0;
pingcur->bflag[1][i] = 0;
}
}
/* null out any unused beams for formats with
variable numbers of beams */
for (i=beams_bath;i<swath_plot->beams_bath;i++)
beamflag[i] = MB_FLAG_NULL;
/* print debug statements */
if (verbose >= 2)
{
fprintf(stderr,"\ndbg2 Ping read in program <%s>\n",
program_name);
fprintf(stderr,"dbg2 kind: %d\n",
kind);
fprintf(stderr,"dbg2 npings: %d\n",
*npings);
fprintf(stderr,"dbg2 time: %4d %2d %2d %2d %2d %2d %6.6d\n",
time_i[0],time_i[1],time_i[2],
time_i[3],time_i[4],time_i[5],time_i[6]);
fprintf(stderr,"dbg2 navigation: %f %f\n",
navlon, navlat);
fprintf(stderr,"dbg2 beams_bath: %d\n",
beams_bath);
fprintf(stderr,"dbg2 beams_amp: %d\n",
beams_amp);
fprintf(stderr,"dbg2 pixels_ss: %d\n",
pixels_ss);
fprintf(stderr,"dbg2 error: %d\n",
error);
fprintf(stderr,"dbg2 status: %d\n",
status);
}
/* scale bathymetry if necessary */
if (error == MB_ERROR_NO_ERROR
&& bathy_in_feet == MB_YES)
{
for (i=0;i<beams_bath;i++)
{
bath[i] = 3.2808399 * bath[i];
}
}
/* update bookkeeping */
if (error == MB_ERROR_NO_ERROR)
{
/*if (*npings == 0 ||
(*npings > 0
&& contour_algorithm == MB_CONTOUR_TRIANGLES)
|| (*npings > 0
&& (navlon != navlon_old
|| navlat != navlat_old)))*/
{
nping_read += pings_read;
(*npings)++;
navlon_old = navlon;
navlat_old = navlat;
}
}
/* decide whether to plot, whether to
save the new ping, and if done */
plot = MB_NO;
flush = MB_NO;
if (*npings >= nplot)
plot = MB_YES;
if (*npings > 0
&& (error > MB_ERROR_NO_ERROR
|| error == MB_ERROR_TIME_GAP
|| error == MB_ERROR_OUT_BOUNDS
|| error == MB_ERROR_OUT_TIME
|| error == MB_ERROR_SPEED_TOO_SMALL))
{
plot = MB_YES;
flush = MB_YES;
}
save_new = MB_NO;
if (error == MB_ERROR_TIME_GAP)
save_new = MB_YES;
if (error > MB_ERROR_NO_ERROR)
done = MB_YES;
/* if enough pings read in, plot them */
if (plot == MB_YES)
{
/* print debug statements */
if (verbose >= 2)
{
fprintf(stderr,"\ndbg2 Plotting %d pings in program <%s>\n",
*npings,program_name);
for (i=0;i<*npings;i++)
{
pingcur = &swath_plot->pings[i];
fprintf(stderr,"dbg2 %4d %4d %2d %2d %2d %2d %2d %6.6d\n",
i,pingcur->time_i[0],
pingcur->time_i[1],
pingcur->time_i[2],
pingcur->time_i[3],
pingcur->time_i[4],
pingcur->time_i[5],
pingcur->time_i[6]);
}
}
/* plot data */
if (plot_contours == MB_YES
|| plot_triangles == MB_YES)
mb_contour(verbose,swath_plot,&error);
/* plot nav track */
if (plot_track == MB_YES)
mb_track(verbose,swath_plot,&error);
/* annotate pingnumber */
if (plot_pingnumber == MB_YES)
{
mb_trackpingnumber(verbose,swath_plot,&error);
}
if (plot_name == MB_YES && plotted_name == MB_NO)
{
mb_trackname(verbose,name_perp,swath_plot,file,&error);
plotted_name = MB_YES;
}
/* reorganize data */
if (flush == MB_YES && save_new == MB_YES)
{
status = ping_copy(verbose,0,*npings,
swath_plot,&error);
*npings = 1;
}
else if (flush == MB_YES)
{
*npings = 0;
}
else if (*npings > 1)
{
status = ping_copy(verbose,0,*npings-1,
swath_plot,&error);
*npings = 1;
}
}
}
status = mb_close(verbose,&mbio_ptr,&error);
/* deallocate memory for data arrays */
status = mb_contour_deall(verbose,swath_plot,&error);
} /* end if file in bounds */
/* figure out whether and what to read next */
if (read_datalist == MB_YES)
{
if ((status = mb_datalist_read(verbose,datalist,
file,&format,&file_weight,&error))
== MB_SUCCESS)
read_data = MB_YES;
else
read_data = MB_NO;
}
else
{
read_data = MB_NO;
}
/* end loop over files in list */
}
if (read_datalist == MB_YES)
mb_datalist_close(verbose,&datalist,&error);
/* end plot */
plot_end(verbose,&error);
/* deallocate memory for data arrays */
mb_freed(verbose,__FILE__, __LINE__, (void **)&level,&error);
mb_freed(verbose,__FILE__, __LINE__, (void **)&label,&error);
mb_freed(verbose,__FILE__, __LINE__, (void **)&tick,&error);
mb_freed(verbose,__FILE__, __LINE__, (void **)&red,&error);
mb_freed(verbose,__FILE__, __LINE__, (void **)&green,&error);
mb_freed(verbose,__FILE__, __LINE__, (void **)&blue,&error);
/* print ending info */
if (verbose >= 1)
fprintf(stderr,"\n%d pings read and plotted\n",
nping_read);
/* check memory */
if (verbose >= 2)
status = mb_memory_list(verbose,&error);
/* print output debug statements */
if (verbose >= 2)
{
fprintf(stderr,"\ndbg2 Program <%s> completed\n",
program_name);
fprintf(stderr,"dbg2 Ending status:\n");
fprintf(stderr,"dbg2 status: %d\n",status);
}
/* end it all */
plot_exit(argc,argv);
exit(status);
}
