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 (int argc, char **argv)
{
char program_name[] = "mbnavlist";
char help_message[] = "mbnavlist prints the specified contents of navigation records\nin a swath sonar data file to stdout. The form of the \noutput is quite flexible; mbnavlist is tailored to produce \nascii files in spreadsheet style with data columns separated by tabs.";
char usage_message[] = "mbnavlist [-Byr/mo/da/hr/mn/sc -Ddecimate -Eyr/mo/da/hr/mn/sc \n-Fformat -Gdelimiter -H -Ifile -Kkind -Llonflip \n-Ooptions -Rw/e/s/n -Sspeed \n-Ttimegap -V -Zsegment]";
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 read_datalist = MB_NO;
char read_file[MB_PATH_MAXLINE];
void *datalist;
int look_processed = MB_DATALIST_LOOK_UNSET;
double file_weight;
int format;
int pings;
int decimate;
int lonflip;
double 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 beams_bath;
int beams_amp;
int pixels_ss;
/* data record source types */
int nav_source;
int heading_source;
int vru_source;
int svp_source;
int aux_nav_channel = -1;
int data_kind = -1;
/* output format list controls */
char list[MAX_OPTIONS];
int n_list;
double distance_total;
int nread;
int time_j[5];
int invert_next_value = MB_NO;
int signflip_next_value = MB_NO;
int first = MB_YES;
int ascii = MB_YES;
int segment = MB_NO;
char segment_tag[MB_PATH_MAXLINE];
char delimiter[MB_PATH_MAXLINE];
/* MBIO read values */
void *mbio_ptr = NULL;
void *store_ptr;
int kind;
int time_i[7];
double time_d;
double navlon;
double navlat;
double speed;
double heading;
double distance;
double altitude;
double sonardepth;
double draft;
double roll;
double pitch;
double heave;
char *beamflag = NULL;
double *bath = NULL;
double *bathacrosstrack = NULL;
double *bathalongtrack = NULL;
double *amp = NULL;
double *ss = NULL;
double *ssacrosstrack = NULL;
double *ssalongtrack = NULL;
char comment[MB_COMMENT_MAXLINE];
int atime_i[7 * MB_ASYNCH_SAVE_MAX];
double atime_d[MB_ASYNCH_SAVE_MAX];
double anavlon[MB_ASYNCH_SAVE_MAX];
double anavlat[MB_ASYNCH_SAVE_MAX];
double aspeed[MB_ASYNCH_SAVE_MAX];
double aheading[MB_ASYNCH_SAVE_MAX];
double adraft[MB_ASYNCH_SAVE_MAX];
double aroll[MB_ASYNCH_SAVE_MAX];
double apitch[MB_ASYNCH_SAVE_MAX];
double aheave[MB_ASYNCH_SAVE_MAX];
/* additional time variables */
int first_m = MB_YES;
double time_d_ref;
int first_u = MB_YES;
time_t time_u;
time_t time_u_ref;
/* course calculation variables */
double dlon, dlat, minutes;
int degrees;
char hemi;
double headingx, headingy, mtodeglon, mtodeglat;
double course, course_old;
double time_d_old;
double time_interval;
double speed_made_good, speed_made_good_old;
double navlon_old, navlat_old;
double dx, dy;
double b;
int read_data;
int inav, n;
int nnav;
int i, j;
/* get current default values */
status = mb_defaults(verbose,&format,&pings,&lonflip,bounds,
btime_i,etime_i,&speedmin,&timegap);
/* set default input to datalist.mb-1 */
strcpy (read_file, "datalist.mb-1");
/* set up the default list controls
(lon, lat, along-track distance, center beam depth) */
list[0]='t';
list[1]='M';
list[2]='X';
list[3]='Y';
list[4]='H';
list[5]='s';
n_list = 6;
sprintf(delimiter, "\t");
decimate = 1;
/* process argument list */
while ((c = getopt(argc, argv, "AaB:b:D:d:E:e:F:f:G:g:I:i:K:k:L:l:N:n:O:o:R:r:S:s:T:t:Z:z:VvHh")) != -1)
switch (c)
{
case 'H':
case 'h':
help++;
break;
case 'V':
case 'v':
verbose++;
break;
case 'A':
case 'a':
ascii = MB_NO;
flag++;
break;
case 'B':
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;
flag++;
break;
case 'D':
case 'd':
sscanf (optarg,"%d", &decimate);
flag++;
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;
flag++;
break;
case 'F':
case 'f':
sscanf (optarg,"%d", &format);
flag++;
break;
case 'G':
case 'g':
sscanf (optarg,"%s", delimiter);
flag++;
break;
case 'I':
case 'i':
sscanf (optarg,"%s", read_file);
flag++;
break;
case 'K':
case 'k':
sscanf (optarg,"%d", &data_kind);
flag++;
break;
case 'L':
case 'l':
sscanf (optarg,"%d", &lonflip);
flag++;
break;
case 'N':
case 'n':
sscanf (optarg,"%d", &aux_nav_channel);
flag++;
break;
case 'O':
case 'o':
for(j=0,n_list=0;j<(int)strlen(optarg);j++,n_list++)
if (n_list<MAX_OPTIONS)
list[n_list] = optarg[j];
flag++;
break;
case 'R':
case 'r':
mb_get_bounds(optarg, bounds);
flag++;
break;
case 'S':
case 's':
sscanf (optarg,"%lf", &speedmin);
flag++;
break;
case 'T':
case 't':
sscanf (optarg,"%lf", &timegap);
flag++;
break;
case 'Z':
case 'z':
segment = MB_YES;
sscanf (optarg,"%s", segment_tag);
flag++;
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);
}
/* print starting message */
if (verbose == 1 || help)
{
fprintf(stderr,"\nProgram %s\n",program_name);
fprintf(stderr,"MB-system Version %s\n",MB_VERSION);
}
/* 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 decimate: %d\n",decimate);
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 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 aux_nav_channel:%d\n",aux_nav_channel);
fprintf(stderr,"dbg2 data_kind: %d\n",data_kind);
fprintf(stderr,"dbg2 ascii: %d\n",ascii);
fprintf(stderr,"dbg2 segment: %d\n",segment);
fprintf(stderr,"dbg2 segment_tag: %s\n",segment_tag);
fprintf(stderr,"dbg2 delimiter: %s\n",delimiter);
fprintf(stderr,"dbg2 file: %s\n",file);
fprintf(stderr,"dbg2 n_list: %d\n",n_list);
for (i=0;i<n_list;i++)
fprintf(stderr,"dbg2 list[%d]: %c\n",
i,list[i]);
}
/* 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);
}
/* get format if required */
if (format == 0)
mb_get_format(verbose,read_file,NULL,&format,&error);
/* determine whether to read one file or a list of files */
if (format < 0)
read_datalist = MB_YES;
/* open file list */
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 copy single filename to be read */
else
{
strcpy(file, read_file);
read_data = MB_YES;
}
/* loop over all files to be read */
while (read_data == MB_YES)
{
/* check format and get data sources */
if ((status = mb_format_source(verbose, &format,
&nav_source, &heading_source,
&vru_source, &svp_source,
&error)) == MB_FAILURE)
{
mb_error(verbose,error,&message);
fprintf(stderr,"\nMBIO Error returned from function <mb_format_source>:\n%s\n",message);
fprintf(stderr,"\nProgram <%s> Terminated\n",
program_name);
exit(error);
}
/* set auxilliary nav source if requested
- note this is superceded by data_kind if the -K option is used */
if (aux_nav_channel > 0)
{
if (aux_nav_channel == 1)
nav_source = MB_DATA_NAV1;
else if (aux_nav_channel == 2)
nav_source = MB_DATA_NAV2;
else if (aux_nav_channel == 3)
nav_source = MB_DATA_NAV3;
}
/* initialize reading the swath file */
if ((status = mb_read_init(
verbose,file,format,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(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 **)&bathacrosstrack, &error);
if (error == MB_ERROR_NO_ERROR)
status = mb_register_array(verbose, mbio_ptr, MB_MEM_TYPE_BATHYMETRY,
sizeof(double), (void **)&bathalongtrack, &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 **)&ssacrosstrack, &error);
if (error == MB_ERROR_NO_ERROR)
status = mb_register_array(verbose, mbio_ptr, MB_MEM_TYPE_SIDESCAN,
sizeof(double), (void **)&ssalongtrack, &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);
}
/* output separator for GMT style segment file output */
if (segment == MB_YES && ascii == MB_YES)
{
printf("%s\n", segment_tag);
}
/* read and print data */
distance_total = 0.0;
nread = 0;
nnav = 0;
first = MB_YES;
while (error <= MB_ERROR_NO_ERROR)
{
/* read a ping of data */
status = mb_get_all(verbose,mbio_ptr,&store_ptr,&kind,
time_i,&time_d,&navlon,&navlat,
&speed,&heading,
&distance,&altitude,&sonardepth,
&beams_bath,&beams_amp,&pixels_ss,
beamflag,bath,amp,bathacrosstrack,bathalongtrack,
ss,ssacrosstrack,ssalongtrack,
comment,&error);
/* time gaps are not a problem here */
if (error == MB_ERROR_TIME_GAP)
{
error = MB_ERROR_NO_ERROR;
status = MB_SUCCESS;
}
/* check for appropriate navigation record */
/* if the -K option is used look for a particular
sort of data record */
if (error <= MB_ERROR_NO_ERROR
&& data_kind > 0)
{
if (error <= MB_ERROR_NO_ERROR
&& kind == data_kind)
{
error = MB_ERROR_NO_ERROR;
status = MB_SUCCESS;
}
else
{
error = MB_ERROR_IGNORE;
status = MB_FAILURE;
}
}
else if (error <= MB_ERROR_NO_ERROR
&& kind != nav_source)
{
error = MB_ERROR_IGNORE;
status = MB_FAILURE;
}
else if (error <= MB_ERROR_NO_ERROR
&& kind == nav_source)
{
error = MB_ERROR_NO_ERROR;
status = MB_SUCCESS;
}
/* extract additional nav info */
if (error == MB_ERROR_NO_ERROR)
status = mb_extract_nnav(verbose,mbio_ptr,store_ptr,
MB_ASYNCH_SAVE_MAX, &kind, &n,
atime_i,atime_d,anavlon,anavlat,
aspeed,aheading,adraft,
aroll,apitch,aheave,&error);
/* increment counter */
if (error == MB_ERROR_NO_ERROR)
nread++;
/* print debug statements */
if (verbose >= 2)
{
fprintf(stderr,"\ndbg2 Nsv data read in program <%s>\n",
program_name);
fprintf(stderr,"dbg2 kind: %d\n",kind);
fprintf(stderr,"dbg2 error: %d\n",error);
fprintf(stderr,"dbg2 status: %d\n",status);
fprintf(stderr,"dbg2 n: %d\n",n);
}
/* loop over the n navigation points, outputting each one */
/* calculate course made good and distance */
if (error == MB_ERROR_NO_ERROR && n > 0)
{
for (inav=0;inav<n;inav++)
{
/* get data */
for (j=0;j<7;j++)
time_i[j] = atime_i[inav * 7 + j];
time_d = atime_d[inav];
navlon = anavlon[inav];
navlat = anavlat[inav];
speed = aspeed[inav];
heading = aheading[inav];
draft = adraft[inav];
roll = aroll[inav];
pitch = apitch[inav];
heave = aheave[inav];
/*fprintf(stdout, "kind:%d error:%d %d of %d: time:%4d/%2d/%2d %2.2d:%2.2d:%2.2d.%6.6d\n",
kind, error, i, n,
time_i[0], time_i[1], time_i[2],
time_i[3], time_i[4], time_i[5], time_i[6]);*/
/* calculate course made good and distance */
mb_coor_scale(verbose,navlat, &mtodeglon, &mtodeglat);
headingx = sin(DTR * heading);
headingy = cos(DTR * heading);
if (first == MB_YES)
{
time_interval = 0.0;
course = heading;
speed_made_good = 0.0;
course_old = heading;
speed_made_good_old = speed;
distance = 0.0;
}
else
{
time_interval = time_d - time_d_old;
dx = (navlon - navlon_old)/mtodeglon;
dy = (navlat - navlat_old)/mtodeglat;
distance = sqrt(dx*dx + dy*dy);
if (distance > 0.0)
course = RTD*atan2(dx/distance,dy/distance);
else
course = course_old;
if (course < 0.0)
course = course + 360.0;
if (time_interval > 0.0)
speed_made_good = 3.6*distance/time_interval;
else
speed_made_good
= speed_made_good_old;
}
distance_total += 0.001 * distance;
/* reset old values */
navlon_old = navlon;
navlat_old = navlat;
course_old = course;
speed_made_good_old = speed_made_good;
time_d_old = time_d;
/* now loop over list of output parameters */
if (nnav % decimate == 0)
for (i=0; i<n_list; i++)
{
switch (list[i])
{
case '/': /* Inverts next simple value */
invert_next_value = MB_YES;
break;
case '-': /* Flip sign on next simple value */
signflip_next_value = MB_YES;
break;
case 'c': /* Sonar transducer depth (m) */
printsimplevalue(verbose, sonardepth, 0, 3, ascii,
&invert_next_value,
&signflip_next_value, &error);
break;
case 'H': /* heading */
printsimplevalue(verbose, heading, 6, 2, ascii,
&invert_next_value,
&signflip_next_value, &error);
break;
case 'h': /* course */
printsimplevalue(verbose, course, 6, 2, ascii,
&invert_next_value,
&signflip_next_value, &error);
break;
case 'J': /* time string */
mb_get_jtime(verbose,time_i,time_j);
if (ascii == MB_YES)
{
printf("%.4d %.3d %.2d %.2d %.2d.%6.6d",
time_j[0],time_j[1],
time_i[3],time_i[4],
time_i[5],time_i[6]);
}
else
{
b = time_j[0];
fwrite(&b, sizeof(double), 1, stdout);
b = time_j[1];
fwrite(&b, sizeof(double), 1, stdout);
b = time_i[3];
fwrite(&b, sizeof(double), 1, stdout);
b = time_i[4];
fwrite(&b, sizeof(double), 1, stdout);
b = time_i[5];
fwrite(&b, sizeof(double), 1, stdout);
b = time_i[6];
fwrite(&b, sizeof(double), 1, stdout);
}
break;
case 'j': /* time string */
mb_get_jtime(verbose,time_i,time_j);
if (ascii == MB_YES)
{
printf("%.4d %.3d %.4d %.2d.%6.6d",
time_j[0],time_j[1],
time_j[2],time_j[3],time_j[4]);
}
else
{
b = time_j[0];
fwrite(&b, sizeof(double), 1, stdout);
b = time_j[1];
fwrite(&b, sizeof(double), 1, stdout);
b = time_j[2];
fwrite(&b, sizeof(double), 1, stdout);
b = time_j[3];
fwrite(&b, sizeof(double), 1, stdout);
b = time_j[4];
fwrite(&b, sizeof(double), 1, stdout);
}
break;
case 'L': /* along-track distance (km) */
printsimplevalue(verbose, distance_total, 7, 3, ascii,
&invert_next_value,
&signflip_next_value, &error);
break;
case 'l': /* along-track distance (m) */
printsimplevalue(verbose, 1000.0 * distance_total, 7, 3, ascii,
&invert_next_value,
&signflip_next_value, &error);
break;
case 'M': /* Decimal unix seconds since
1/1/70 00:00:00 */
printsimplevalue(verbose, time_d, 0, 6, ascii,
&invert_next_value,
&signflip_next_value, &error);
break;
case 'm': /* time in decimal seconds since
first record */
if (first_m == MB_YES)
{
time_d_ref = time_d;
first_m = MB_NO;
}
b = time_d - time_d_ref;
printsimplevalue(verbose, b, 0, 6, ascii,
&invert_next_value,
&signflip_next_value, &error);
break;
case 'P': /* pitch */
printsimplevalue(verbose, pitch, 5, 2, ascii,
&invert_next_value,
&signflip_next_value, &error);
break;
case 'p': /* draft */
printsimplevalue(verbose, draft, 5, 2, ascii,
&invert_next_value,
&signflip_next_value, &error);
break;
case 'R': /* roll */
printsimplevalue(verbose, roll, 5, 2, ascii,
&invert_next_value,
&signflip_next_value, &error);
break;
case 'r': /* heave */
printsimplevalue(verbose, heave, 5, 2, ascii,
&invert_next_value,
&signflip_next_value, &error);
break;
case 'S': /* speed */
printsimplevalue(verbose, speed, 5, 2, ascii,
&invert_next_value,
&signflip_next_value, &error);
break;
case 's': /* speed made good */
printsimplevalue(verbose, speed_made_good, 5, 2, ascii,
&invert_next_value,
&signflip_next_value, &error);
break;
case 'T': /* yyyy/mm/dd/hh/mm/ss time string */
if (ascii == MB_YES)
printf("%.4d/%.2d/%.2d/%.2d/%.2d/%.2d.%.6d",
time_i[0],time_i[1],time_i[2],
time_i[3],time_i[4],time_i[5],
time_i[6]);
else
{
b = time_i[0];
fwrite(&b, sizeof(double), 1, stdout);
b = time_i[1];
fwrite(&b, sizeof(double), 1, stdout);
b = time_i[2];
fwrite(&b, sizeof(double), 1, stdout);
b = time_i[3];
fwrite(&b, sizeof(double), 1, stdout);
b = time_i[4];
fwrite(&b, sizeof(double), 1, stdout);
b = time_i[5] + 1e-6 * time_i[6];
fwrite(&b, sizeof(double), 1, stdout);
}
break;
case 't': /* yyyy mm dd hh mm ss time string */
if (ascii == MB_YES)
printf("%.4d %.2d %.2d %.2d %.2d %.2d.%.6d",
time_i[0],time_i[1],time_i[2],
time_i[3],time_i[4],time_i[5],
time_i[6]);
else
{
b = time_i[0];
fwrite(&b, sizeof(double), 1, stdout);
b = time_i[1];
fwrite(&b, sizeof(double), 1, stdout);
b = time_i[2];
fwrite(&b, sizeof(double), 1, stdout);
b = time_i[3];
fwrite(&b, sizeof(double), 1, stdout);
b = time_i[4];
fwrite(&b, sizeof(double), 1, stdout);
b = time_i[5] + 1e-6 * time_i[6];
fwrite(&b, sizeof(double), 1, stdout);
}
break;
case 'U': /* unix time in seconds since 1/1/70 00:00:00 */
time_u = (int) time_d;
if (ascii == MB_YES)
printf("%ld",time_u);
else
{
b = time_u;
fwrite(&b, sizeof(double), 1, stdout);
}
break;
case 'u': /* time in seconds since first record */
time_u = (int) time_d;
if (first_u == MB_YES)
{
time_u_ref = time_u;
first_u = MB_NO;
}
if (ascii == MB_YES)
printf("%ld",time_u - time_u_ref);
else
{
b = time_u - time_u_ref;
fwrite(&b, sizeof(double), 1, stdout);
}
break;
case 'V': /* time in seconds since last ping */
case 'v':
if (ascii == MB_YES)
{
if ( fabs(time_interval) > 100. )
printf("%g",time_interval);
else
printf("%7.3f",time_interval);
}
else
{
fwrite(&time_interval, sizeof(double), 1, stdout);
}
break;
case 'X': /* longitude decimal degrees */
dlon = navlon;
printsimplevalue(verbose, dlon, 14, 9, ascii,
&invert_next_value,
&signflip_next_value, &error);
break;
case 'x': /* longitude degress + decimal minutes */
dlon = navlon;
if (dlon < 0.0)
{
hemi = 'W';
dlon = -dlon;
}
else
hemi = 'E';
degrees = (int) dlon;
minutes = 60.0*(dlon - degrees);
if (ascii == MB_YES)
{
printf("%3d %9.6f%c",
degrees, minutes, hemi);
}
else
{
b = degrees;
if (hemi == 'W') b = -b;
fwrite(&b, sizeof(double), 1, stdout);
b = minutes;
fwrite(&b, sizeof(double), 1, stdout);
}
break;
case 'Y': /* latitude decimal degrees */
dlat = navlat;
printsimplevalue(verbose, dlat, 14, 9, ascii,
&invert_next_value,
&signflip_next_value, &error);
break;
case 'y': /* latitude degrees + decimal minutes */
dlat = navlat;
if (dlat < 0.0)
{
hemi = 'S';
dlat = -dlat;
}
else
hemi = 'N';
degrees = (int) dlat;
minutes = 60.0*(dlat - degrees);
if (ascii == MB_YES)
{
printf("%3d %9.6f%c",
degrees, minutes, hemi);
}
else
{
b = degrees;
if (hemi == 'S') b = -b;
fwrite(&b, sizeof(double), 1, stdout);
b = minutes;
fwrite(&b, sizeof(double), 1, stdout);
}
break;
default:
if (ascii == MB_YES)
printf("<Invalid Option: %c>",
list[i]);
break;
}
if (ascii == MB_YES)
{
if (i<(n_list-1)) printf ("%s", delimiter);
else printf ("\n");
}
}
nnav++;
first = MB_NO;
}
}
}
/* close the swath file */
status = mb_close(verbose,&mbio_ptr,&error);
/* 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);
/* 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 (int argc, char **argv)
{
char program_name[] = "MBHISTOGRAM";
char help_message[] = "MBHISTOGRAM reads a swath sonar data file and generates a histogram\n\tof the bathymetry, amplitude, or sidescan values. Alternatively, \n\tmbhistogram can output a list of values which break up the\n\tdistribution into equal sized regions.\n\tThe results are dumped to stdout.";
char usage_message[] = "mbhistogram [-Akind -Byr/mo/da/hr/mn/sc -Dmin/max -Eyr/mo/da/hr/mn/sc -Fformat -G -Ifile -Llonflip -Mnintervals -Nnbins -Ppings -Rw/e/s/n -Sspeed -V -H]";
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 read_datalist = MB_NO;
char read_file[MB_PATH_MAXLINE];
void *datalist;
int look_processed = MB_DATALIST_LOOK_UNSET;
double file_weight;
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;
char file[MB_PATH_MAXLINE];
int beams_bath;
int beams_amp;
int pixels_ss;
/* MBIO read values */
void *mbio_ptr = NULL;
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 *bathacrosstrack = NULL;
double *bathalongtrack = NULL;
double *amp = NULL;
double *ss = NULL;
double *ssacrosstrack = NULL;
double *ssalongtrack = NULL;
char comment[MB_COMMENT_MAXLINE];
/* histogram variables */
int mode = MBHISTOGRAM_SS;
int gaussian = MB_NO;
int nbins = 0;
int nintervals = 0;
double value_min = 0.0;
double value_max = 128.0;
double dvalue_bin;
double value_bin_min;
double value_bin_max;
double data_min;
double data_max;
int data_first = MB_YES;
double target_min;
double target_max;
double *histogram = NULL;
double *intervals = NULL;
double total;
double sum;
double p;
double target;
double dinterval;
double bin_fraction;
int ibin;
/* output stream for basic stuff (stdout if verbose <= 1,
stderr if verbose > 1) */
FILE *output;
int read_data;
int nrec, nvalue;
int nrectot = 0;
int nvaluetot = 0;
int i, j;
/* get current 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");
/* process argument list */
while ((c = getopt(argc, argv, "A:a:B:b:D:d:E:e:F:f:GgHhI:i:L:l:M:m:N:n:P:p:R:r:S:s:T:t:Vv")) != -1)
switch (c)
{
case 'A':
case 'a':
sscanf (optarg,"%d", &mode);
flag++;
break;
case 'B':
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;
flag++;
break;
case 'D':
case 'd':
sscanf (optarg,"%lf/%lf", &value_min,&value_max);
flag++;
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;
flag++;
break;
case 'F':
case 'f':
sscanf (optarg,"%d", &format);
flag++;
break;
case 'G':
case 'g':
gaussian = MB_YES;
break;
case 'H':
case 'h':
help++;
break;
case 'I':
case 'i':
sscanf (optarg,"%s", read_file);
flag++;
break;
case 'L':
case 'l':
sscanf (optarg,"%d", &lonflip);
flag++;
break;
case 'M':
case 'm':
sscanf (optarg,"%d", &nintervals);
flag++;
break;
case 'N':
case 'n':
sscanf (optarg,"%d", &nbins);
flag++;
break;
case 'P':
case 'p':
sscanf (optarg,"%d", &pings);
flag++;
break;
case 'R':
case 'r':
mb_get_bounds(optarg, bounds);
flag++;
break;
case 'S':
case 's':
sscanf (optarg,"%lf", &speedmin);
flag++;
break;
case 'T':
case 't':
sscanf (optarg,"%lf", &timegap);
flag++;
break;
case 'V':
case 'v':
verbose++;
break;
case '?':
errflg++;
}
/* set output stream */
if (verbose <= 1)
output = stdout;
else
output = stderr;
/* if error flagged then print it and exit */
if (errflg)
{
fprintf(output,"usage: %s\n", usage_message);
fprintf(output,"\nProgram <%s> Terminated\n",
program_name);
error = MB_ERROR_BAD_USAGE;
exit(error);
}
/* print starting message */
if (verbose == 1 || help)
{
fprintf(output,"\nProgram %s\n",program_name);
fprintf(output,"Version %s\n",rcs_id);
fprintf(output,"MB-system Version %s\n",MB_VERSION);
}
/* get format if required */
if (format == 0)
mb_get_format(verbose,read_file,NULL,&format,&error);
/* figure out histogram dimensions */
if (nintervals > 0 && nbins <= 0)
nbins = 50*nintervals;
if (nbins <= 0)
nbins = 16;
/* print starting debug statements */
if (verbose >= 2)
{
fprintf(output,"\ndbg2 Program <%s>\n",program_name);
fprintf(output,"dbg2 Version %s\n",rcs_id);
fprintf(output,"dbg2 MB-system Version %s\n",MB_VERSION);
fprintf(output,"dbg2 Control Parameters:\n");
fprintf(output,"dbg2 verbose: %d\n",verbose);
fprintf(output,"dbg2 help: %d\n",help);
fprintf(output,"dbg2 format: %d\n",format);
fprintf(output,"dbg2 pings: %d\n",pings);
fprintf(output,"dbg2 lonflip: %d\n",lonflip);
fprintf(output,"dbg2 bounds[0]: %f\n",bounds[0]);
fprintf(output,"dbg2 bounds[1]: %f\n",bounds[1]);
fprintf(output,"dbg2 bounds[2]: %f\n",bounds[2]);
fprintf(output,"dbg2 bounds[3]: %f\n",bounds[3]);
fprintf(output,"dbg2 btime_i[0]: %d\n",btime_i[0]);
fprintf(output,"dbg2 btime_i[1]: %d\n",btime_i[1]);
fprintf(output,"dbg2 btime_i[2]: %d\n",btime_i[2]);
fprintf(output,"dbg2 btime_i[3]: %d\n",btime_i[3]);
fprintf(output,"dbg2 btime_i[4]: %d\n",btime_i[4]);
fprintf(output,"dbg2 btime_i[5]: %d\n",btime_i[5]);
fprintf(output,"dbg2 btime_i[6]: %d\n",btime_i[6]);
fprintf(output,"dbg2 etime_i[0]: %d\n",etime_i[0]);
fprintf(output,"dbg2 etime_i[1]: %d\n",etime_i[1]);
fprintf(output,"dbg2 etime_i[2]: %d\n",etime_i[2]);
fprintf(output,"dbg2 etime_i[3]: %d\n",etime_i[3]);
fprintf(output,"dbg2 etime_i[4]: %d\n",etime_i[4]);
fprintf(output,"dbg2 etime_i[5]: %d\n",etime_i[5]);
fprintf(output,"dbg2 etime_i[6]: %d\n",etime_i[6]);
fprintf(output,"dbg2 speedmin: %f\n",speedmin);
fprintf(output,"dbg2 timegap: %f\n",timegap);
fprintf(output,"dbg2 file: %s\n",read_file);
fprintf(output,"dbg2 mode: %d\n",mode);
fprintf(output,"dbg2 gaussian: %d\n",gaussian);
fprintf(output,"dbg2 nbins: %d\n",nbins);
fprintf(output,"dbg2 nintervals: %d\n",nintervals);
fprintf(output,"dbg2 value_min: %f\n",value_min);
fprintf(output,"dbg2 value_max: %f\n",value_max);
}
/* if help desired then print it and exit */
if (help)
{
fprintf(output,"\n%s\n",help_message);
fprintf(output,"\nusage: %s\n", usage_message);
exit(error);
}
/* allocate memory for histogram arrays */
if (error == MB_ERROR_NO_ERROR)
status = mb_mallocd(verbose,__FILE__,__LINE__,nbins*sizeof(double),
(void **)&histogram,&error);
if (error == MB_ERROR_NO_ERROR)
status = mb_mallocd(verbose,__FILE__,__LINE__,nintervals*sizeof(double),
(void **)&intervals,&error);
/* if error initializing memory then quit */
if (error != MB_ERROR_NO_ERROR)
{
mb_error(verbose,error,&message);
fprintf(output,"\nMBIO Error allocating histogram arrays:\n%s\n",message);
fprintf(output,"\nProgram <%s> Terminated\n",
program_name);
exit(error);
}
/* output some information */
if (verbose > 0)
{
fprintf(stderr, "\nNumber of data bins: %d\n", nbins);
fprintf(stderr, "Minimum value: %f\n", value_min);
fprintf(stderr, "Maximum value: %f\n", value_max);
if (mode == MBHISTOGRAM_BATH)
fprintf(stderr, "Working on bathymetry data...\n");
else if (mode == MBHISTOGRAM_AMP)
fprintf(stderr, "Working on beam amplitude data...\n");
else
fprintf(stderr, "Working on sidescan data...\n");
}
/* get size of bins */
dvalue_bin = (value_max - value_min)/(nbins-1);
value_bin_min = value_min - 0.5*dvalue_bin;
value_bin_max = value_max + 0.5*dvalue_bin;
/* initialize histogram */
for (i=0;i<nbins;i++)
histogram[i] = 0;
/* determine whether to read one file or a list of files */
if (format < 0)
read_datalist = MB_YES;
/* open file list */
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 copy single filename to be read */
else
{
strcpy(file, read_file);
read_data = MB_YES;
}
/* loop over all files to be read */
while (read_data == MB_YES)
{
/* obtain format array location - format id will
be aliased to current id if old format id given */
status = mb_format(verbose,&format,&error);
/* initialize reading the swath sonar data file */
if ((status = mb_read_init(
verbose,file,format,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(output,"\nMBIO Error returned from function <mb_read_init>:\n%s\n",message);
fprintf(output,"\nMultibeam File <%s> not initialized for reading\n",file);
fprintf(output,"\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 **)&bathacrosstrack, &error);
if (error == MB_ERROR_NO_ERROR)
status = mb_register_array(verbose, mbio_ptr, MB_MEM_TYPE_BATHYMETRY,
sizeof(double), (void **)&bathalongtrack, &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 **)&ssacrosstrack, &error);
if (error == MB_ERROR_NO_ERROR)
status = mb_register_array(verbose, mbio_ptr, MB_MEM_TYPE_SIDESCAN,
sizeof(double), (void **)&ssalongtrack, &error);
/* if error initializing memory then quit */
if (error != MB_ERROR_NO_ERROR)
{
mb_error(verbose,error,&message);
fprintf(output,"\nMBIO Error allocating data arrays:\n%s\n",message);
fprintf(output,"\nProgram <%s> Terminated\n",
program_name);
exit(error);
}
/* output information */
if (error == MB_ERROR_NO_ERROR && verbose > 0)
{
fprintf(stderr, "\nprocessing file: %s %d\n", file, format);
}
/* initialize counting variables */
nrec = 0;
nvalue = 0;
/* read and process data */
while (error <= MB_ERROR_NO_ERROR)
{
/* read a ping of data */
status = mb_get(verbose,mbio_ptr,&kind,&pings,
time_i,&time_d,
&navlon,&navlat,
&speed,&heading,
&distance,&altitude,&sonardepth,
&beams_bath,&beams_amp,&pixels_ss,
beamflag,bath,amp,bathacrosstrack,bathalongtrack,
ss,ssacrosstrack,ssalongtrack,
comment,&error);
/* process the pings */
if (error == MB_ERROR_NO_ERROR
|| error == MB_ERROR_TIME_GAP)
{
/* increment record counter */
nrec++;
/* do the bathymetry */
if (mode == MBHISTOGRAM_BATH)
for (i=0;i<beams_bath;i++)
{
if (mb_beam_ok(beamflag[i]))
{
nvalue++;
j = (bath[i] - value_bin_min)
/dvalue_bin;
if (j >= 0 && j < nbins)
histogram[j]++;
if (data_first == MB_YES)
{
data_min = bath[i];
data_max = bath[i];
data_first = MB_NO;
}
else
{
data_min = MIN(bath[i], data_min);
data_max = MAX(bath[i], data_max);
}
}
}
/* do the amplitude */
if (mode == MBHISTOGRAM_AMP)
for (i=0;i<beams_amp;i++)
{
if (mb_beam_ok(beamflag[i]))
{
nvalue++;
j = (amp[i] - value_bin_min)
/dvalue_bin;
if (j >= 0 && j < nbins)
histogram[j]++;
if (data_first == MB_YES)
{
data_min = amp[i];
data_max = amp[i];
data_first = MB_NO;
}
else
{
data_min = MIN(amp[i], data_min);
data_max = MAX(amp[i], data_max);
}
}
}
/* do the sidescan */
if (mode == MBHISTOGRAM_SS)
for (i=0;i<pixels_ss;i++)
{
if (ss[i] > MB_SIDESCAN_NULL)
{
nvalue++;
j = (ss[i] - value_bin_min)
/dvalue_bin;
if (j >= 0 && j < nbins)
histogram[j]++;
if (data_first == MB_YES)
{
data_min = ss[i];
data_max = ss[i];
data_first = MB_NO;
}
else
{
data_min = MIN(ss[i], data_min);
data_max = MAX(ss[i], data_max);
}
}
}
}
}
/* close the swath sonar data file */
status = mb_close(verbose,&mbio_ptr,&error);
nrectot += nrec;
nvaluetot += nvalue;
/* output information */
if (error == MB_ERROR_NO_ERROR && verbose > 0)
{
fprintf(stderr, "%d records processed\n%d data processed\n",
nrec, nvalue);
}
/* 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);
/* output information */
if (error == MB_ERROR_NO_ERROR && verbose > 0)
{
fprintf(stderr, "\n%d total records processed\n", nrectot);
fprintf(stderr, "%d total data processed\n\n", nvaluetot);
}
/* recast histogram as gaussian */
if (gaussian == MB_YES)
{
/* get total number of good values */
total = 0.0;
for (i=0;i<nbins;i++)
total = total + histogram[i];
/* recast histogram */
sum = 0.0;
for (i=0;i<nbins;i++)
{
p = (histogram[i]/2 + sum)/(total + 1);
sum = sum + histogram[i];
histogram[i] = qsnorm(p);
}
}
/* calculate gaussian intervals if required */
if (nintervals > 0 && gaussian == MB_YES)
{
/* get interval spacing */
target_min = -2.0;
target_max = 2.0;
dinterval = (target_max - target_min)/(nintervals-1);
/* get intervals */
intervals[0] = MAX(data_min, value_min);
intervals[nintervals-1] = MIN(data_max, value_max);
ibin = 0;
for (j=1;j<nintervals-1;j++)
{
target = target_min + j*dinterval;
while (histogram[ibin] < target && ibin < nbins-1)
ibin++;
if (ibin > 0)
bin_fraction = 1.0 - (histogram[ibin] - target)
/(histogram[ibin] - histogram[ibin-1]);
else
bin_fraction = 0.0;
intervals[j] = value_bin_min
+ dvalue_bin*ibin
+ bin_fraction*dvalue_bin;
}
}
/* calculate linear intervals if required */
else if (nintervals > 0)
{
/* get total number of good values */
total = 0.0;
for (i=0;i<nbins;i++)
total = total + histogram[i];
/* get interval spacing */
dinterval = total/(nintervals-1);
/* get intervals */
intervals[0] = value_bin_min;
total = 0.0;
ibin = -1;
for (j=1;j<nintervals;j++)
{
target = j*dinterval;
while (total < target && ibin < nbins-1)
{
ibin++;
total = total + histogram[ibin];
if (total <= 0.0)
intervals[0] = value_bin_min
+ dvalue_bin*ibin;
}
bin_fraction = 1.0 - (total - target)/histogram[ibin];
intervals[j] = value_bin_min
+ dvalue_bin*ibin
+ bin_fraction*dvalue_bin;
}
}
/* print out the results */
if (nintervals <= 0 && gaussian == MB_YES)
{
for (i=0;i<nbins;i++)
{
fprintf(output,"%f %f\n",
value_min+i*dvalue_bin,histogram[i]);
}
}
else if (nintervals <= 0)
{
for (i=0;i<nbins;i++)
{
fprintf(output,"%f %d\n",
value_min+i*dvalue_bin,(int)histogram[i]);
}
}
else
{
for (i=0;i<nintervals;i++)
fprintf(output,"%f\n",intervals[i]);
}
/* deallocate memory used for data arrays */
mb_freed(verbose,__FILE__,__LINE__,(void **)&histogram,&error);
mb_freed(verbose,__FILE__,__LINE__,(void **)&intervals,&error);
/* set program status */
status = MB_SUCCESS;
/* check memory */
if (verbose >= 4)
status = mb_memory_list(verbose,&error);
/* print output debug statements */
if (verbose >= 2)
{
fprintf(output,"\ndbg2 Program <%s> completed\n",
program_name);
fprintf(output,"dbg2 Ending status:\n");
fprintf(output,"dbg2 status: %d\n",status);
}
/* end it all */
fprintf(output,"\n");
exit(error);
}
