/*--------------------------------------------------------------------*/
int mbr_rt_hsurivax(int verbose, void *mbio_ptr, void *store_ptr, int *error) {
char *function_name = "mbr_rt_hsurivax";
int status = MB_SUCCESS;
struct mb_io_struct *mb_io_ptr;
struct mbf_hsuricen_struct *dataplus;
struct mbf_hsuricen_data_struct *data;
struct mbsys_hsds_struct *store;
char *datacomment;
int time_j[5];
int i;
int id;
/* print input debug statements */
if (verbose >= 2) {
fprintf(stderr, "\ndbg2 MBIO function <%s> called\n", function_name);
fprintf(stderr, "dbg2 Revision id: %s\n", rcs_id);
fprintf(stderr, "dbg2 Input arguments:\n");
fprintf(stderr, "dbg2 verbose: %d\n", verbose);
fprintf(stderr, "dbg2 mbio_ptr: %p\n", (void *)mbio_ptr);
fprintf(stderr, "dbg2 store_ptr: %p\n", (void *)store_ptr);
}
/* get pointer to mbio descriptor */
mb_io_ptr = (struct mb_io_struct *)mbio_ptr;
/* get pointer to raw data structure */
dataplus = (struct mbf_hsuricen_struct *)mb_io_ptr->raw_data;
data = &(dataplus->data);
datacomment = (char *)data;
dataplus->kind = MB_DATA_DATA;
store = (struct mbsys_hsds_struct *)store_ptr;
/* set file position */
mb_io_ptr->file_pos = mb_io_ptr->file_bytes;
/* read next record from file */
if ((status = fread(data, 1, mb_io_ptr->data_structure_size, mb_io_ptr->mbfp)) == mb_io_ptr->data_structure_size) {
mb_io_ptr->file_bytes += status;
status = MB_SUCCESS;
*error = MB_ERROR_NO_ERROR;
}
else {
mb_io_ptr->file_bytes += status;
status = MB_FAILURE;
*error = MB_ERROR_EOF;
}
/* byte swap the data if necessary */
#ifndef BYTESWAPPED
if (status == MB_SUCCESS && data->sec != 25443) {
data->sec = mb_swap_short(data->sec);
data->min = mb_swap_short(data->min);
data->day = mb_swap_short(data->day);
data->year = mb_swap_short(data->year);
data->lat = mb_swap_int(data->lat);
data->lon = mb_swap_int(data->lon);
data->hdg = mb_swap_short(data->hdg);
data->course = mb_swap_short(data->course);
data->speed = mb_swap_short(data->speed);
data->pitch = mb_swap_short(data->pitch);
data->scale = mb_swap_short(data->scale);
for (i = 0; i < MBSYS_HSDS_BEAMS; i++) {
data->dist[i] = mb_swap_short(data->dist[i]);
data->deph[i] = mb_swap_short(data->deph[i]);
}
}
#endif
/* check for comment or unintelligible records */
if (status == MB_SUCCESS) {
if (data->sec == 25443) {
dataplus->kind = MB_DATA_COMMENT;
}
else if (data->year == 0) {
dataplus->kind = MB_DATA_NONE;
status = MB_FAILURE;
*error = MB_ERROR_UNINTELLIGIBLE;
}
else {
dataplus->kind = MB_DATA_DATA;
}
}
/* set kind and error in mb_io_ptr */
mb_io_ptr->new_kind = dataplus->kind;
mb_io_ptr->new_error = *error;
/* translate values to hydrosweep data storage structure */
if (status == MB_SUCCESS && store != NULL) {
/* type of data record */
store->kind = dataplus->kind;
/* time stamp (all records ) */
time_j[0] = data->year;
time_j[1] = data->day;
time_j[2] = data->min;
time_j[3] = data->sec / 100;
time_j[4] = 10000 * (data->sec - 100 * time_j[3]);
mb_get_itime(verbose, time_j, mb_io_ptr->new_time_i);
mb_get_time(verbose, mb_io_ptr->new_time_i, &(mb_io_ptr->new_time_d));
store->year = mb_io_ptr->new_time_i[0];
store->month = mb_io_ptr->new_time_i[1];
store->day = mb_io_ptr->new_time_i[2];
store->hour = mb_io_ptr->new_time_i[3];
store->minute = mb_io_ptr->new_time_i[4];
store->second = mb_io_ptr->new_time_i[5];
store->alt_minute = 0;
store->alt_second = 0;
/* position (all records ) */
store->lon = 0.0000001 * data->lon;
store->lat = 0.0000001 * data->lat;
if (store->lon > 180.)
store->lon = store->lon - 360.;
else if (store->lon < -180.)
store->lon = store->lon + 360.;
/* additional navigation and depths (ERGNMESS and ERGNEICH) */
store->course_true = 0.1 * data->hdg;
store->speed_transverse = 0.0;
store->speed = 0.005092593 * data->speed;
store->speed_reference[0] = data->speed_ref;
store->pitch = 0.1 * data->pitch;
store->track = 0;
store->depth_scale = 0.01 * data->scale;
store->depth_center = store->depth_scale * data->deph[MBSYS_HSDS_BEAMS / 2];
store->spare = 1;
id = MBSYS_HSDS_BEAMS - 1;
for (i = 0; i < MBSYS_HSDS_BEAMS; i++) {
store->distance[i] = data->dist[i];
store->depth[i] = data->deph[i];
}
/* for (i=0;i<MBSYS_HSDS_BEAMS;i++)
{
store->distance[id-i] = data->dist[i];
store->depth[id-i] = data->deph[i];
}*/
/* travel time data (ERGNSLZT) */
store->course_ground = 0.1 * data->course;
store->speed_ground = 0.0;
store->heave = 0.0;
store->roll = 0.0;
store->time_center = 0.0;
store->time_scale = 0.0;
for (i = 0; i < MBSYS_HSDS_BEAMS; i++)
store->time[i] = 0;
for (i = 0; i < 11; i++)
store->gyro[i] = 0.0;
/* amplitude data (ERGNAMPL) */
store->mode[0] = '\0';
store->trans_strbd = 0;
store->trans_vert = 0;
store->trans_port = 0;
store->pulse_len_strbd = 0;
store->pulse_len_vert = 0;
store->pulse_len_port = 0;
store->gain_start = 0;
store->r_compensation_factor = 0;
store->compensation_start = 0;
store->increase_start = 0;
store->tvc_near = 0;
store->tvc_far = 0;
store->increase_int_near = 0;
store->increase_int_far = 0;
store->gain_center = 0;
store->filter_gain = 0.0;
store->amplitude_center = 0;
store->echo_duration_center = 0;
store->echo_scale_center = 0;
for (i = 0; i < MBSYS_HSDS_BEAMS; i++) {
store->amplitude[i] = 0;
store->echo_duration[i] = 0;
}
for (i = 0; i < 16; i++) {
store->gain[i] = 0;
store->echo_scale[i] = 0;
}
/* mean velocity (ERGNHYDI) */
store->draught = 0.0;
store->vel_mean = 0.0;
store->vel_keel = 0.0;
store->tide = 0.0;
/* water velocity profile (HS_ERGNCTDS) */
store->num_vel = 0.0;
/* navigation source (ERGNPOSI) */
store->pos_corr_x = 0.0;
store->pos_corr_y = 0.0;
strncpy(store->sensors, "\0", 8);
/* comment (LDEOCMNT) */
strncpy(store->comment, &datacomment[2], MBSYS_HSDS_MAXLINE);
/* processed backscatter */
store->back_scale = 0.0;
for (i = 0; i < MBSYS_HSDS_BEAMS; i++)
store->back[i] = 0;
}
/* print output debug statements */
if (verbose >= 2) {
fprintf(stderr, "\ndbg2 MBIO function <%s> completed\n", function_name);
fprintf(stderr, "dbg2 Return values:\n");
fprintf(stderr, "dbg2 error: %d\n", *error);
fprintf(stderr, "dbg2 Return status:\n");
fprintf(stderr, "dbg2 status: %d\n", status);
}
/* return status */
return (status);
}
int main
(
int argc,
char **argv
)
{
static char program_name[] = "mbotps";
static char help_message[] =
"MBotps predicts tides using methods and data derived from the OSU Tidal Prediction Software (OTPS) distributions.";
static char usage_message[] =
"mbotps [-Atideformat -Byear/month/day/hour/minute/second -Ctidestationformat\n"
"\t-Dinterval -Eyear/month/day/hour/minute/second -Fformat\n"
"\t-Idatalist -Lopts_path -Ntidestationfile -Ooutput -Potps_location\n"
"\t-Rlon/lat -S -Tmodel -Utidestationlon/tidestationlat -V]";
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;
mb_path read_file;
void *datalist;
int look_processed = MB_DATALIST_LOOK_UNSET;
double file_weight;
mb_path swath_file;
mb_path file;
mb_path dfile;
int format;
int pings;
int lonflip;
double bounds[4];
double speedmin;
double timegap;
int beams_bath;
int beams_amp;
int pixels_ss;
/* MBIO read values */
void *mbio_ptr = NULL;
void *store_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];
/* mbotps control parameters */
mb_path otps_location_use;
int notpsmodels = 0;
int nmodeldatafiles = 0;
int mbotps_mode = MBOTPS_MODE_POSITION;
double tidelon;
double tidelat;
double btime_d;
double etime_d;
int btime_i[7];
int etime_i[7];
double interval = 300.0;
mb_path tide_file;
int mbprocess_update = MB_NO;
int skip_existing = MB_NO;
int tideformat = 2;
int ngood;
/* tide station data */
mb_path tidestation_file;
double tidestation_lon = 0.0;
double tidestation_lat = 0.0;
int tidestation_format = 2;
int tidestation_ok = MB_NO;
int ntidestation = 0;
double *tidestation_time_d = NULL;
double *tidestation_tide = NULL;
double *tidestation_model = NULL;
double *tidestation_correction = NULL;
int time_j[5];
int tidestation_stime_i[7], tidestation_etime_i[7];
double tidestation_stime_d, tidestation_etime_d;
double tidestation_d_min, tidestation_d_max;
double tidestation_m_min, tidestation_m_max;
double tidestation_c_min, tidestation_c_max;
int ihr, intstat, itime;
int size;
double sec, correction;
/* time parameters */
time_t right_now;
char date[32], user[MB_PATH_MAXLINE], *user_ptr, host[MB_PATH_MAXLINE];
int pid;
FILE *tfp, *mfp, *ofp;
struct stat file_status;
int fstat;
double start_time_d;
double end_time_d;
int istart, iend;
int proceed = MB_YES;
int input_size, input_modtime, output_size, output_modtime;
mb_path lltfile = "";
mb_path otpsfile = "";
mb_path line = "";
mb_path predict_tide = "";
int otps_model_set = MB_NO;
mb_path otps_model = "";
mb_path modelname = "";
mb_path modelfile = "";
mb_path modeldatafile = "";
int read_data;
int ntime;
int nread;
int nline;
int nget;
int output;
double savetime_d;
double lasttime_d;
double lastlon;
double lastlat;
double lon;
double lat;
double tide;
double depth;
char *result;
int i;
/* 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 default location of the OTPS package */
strcpy(otps_location_use, otps_location);
/* set defaults for the AUV survey we were running on Coaxial Segment, Juan de Fuca Ridge
while I wrote this code */
sprintf(otps_model, MBOTPS_DEFAULT_MODEL);
sprintf(tide_file, "tide_model.txt");
tidelon = -129.588618;
tidelat = 46.50459;
interval = 60.0;
btime_i[0] = 2009;
btime_i[1] = 7;
btime_i[2] = 31;
btime_i[3] = 0;
btime_i[4] = 0;
btime_i[5] = 0;
btime_i[6] = 0;
etime_i[0] = 2009;
etime_i[1] = 8;
etime_i[2] = 2;
etime_i[3] = 1;
etime_i[4] = 0;
etime_i[5] = 0;
etime_i[6] = 0;
/* process argument list */
while ((c =
getopt(argc, argv, "A:a:B:b:C:c:D:d:E:e:F:f:I:i:MmN:n:O:o:P:p:R:r:SST:t:U:u:VvHh")) != -1)
switch (c)
{
case 'H':
case 'h':
help++;
break;
case 'V':
case 'v':
verbose++;
break;
case 'A':
case 'a':
sscanf(optarg, "%d", &tideformat);
if (tideformat != 2)
tideformat = 1;
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 'C':
case 'c':
sscanf(optarg, "%d", &tidestation_format);
if (tidestation_format < 1 || tidestation_format > 4)
tidestation_format = 2;
break;
case 'D':
case 'd':
sscanf(optarg, "%lf", &interval);
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 'I':
case 'i':
sscanf(optarg, "%s", read_file);
mbotps_mode = mbotps_mode | MBOTPS_MODE_NAVIGATION;
flag++;
break;
case 'M':
case 'm':
mbprocess_update = MB_YES;
break;
case 'N':
case 'n':
sscanf(optarg, "%s", tidestation_file);
mbotps_mode = mbotps_mode | MBOTPS_MODE_TIDESTATION;
break;
case 'O':
case 'o':
sscanf(optarg, "%s", tide_file);
break;
case 'P':
case 'p':
sscanf(optarg, "%s", otps_location_use);
break;
case 'R':
case 'r':
sscanf(optarg, "%lf/%lf", &tidelon, &tidelat);
break;
case 'S':
case 's':
skip_existing = MB_YES;
break;
case 'T':
case 't':
sscanf(optarg, "%s", otps_model);
otps_model_set = MB_YES;
break;
case 'U':
case 'u':
sscanf(optarg, "%lf/%lf", &tidestation_lon, &tidestation_lat);
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);
}
/* if help desired then print it and exit */
if (help)
{
fprintf(stderr, "\n%s\n", help_message);
fprintf(stderr, "\nusage: %s\n", usage_message);
}
/* Check for available tide models */
if (help || ( verbose > 0) )
{
fprintf(stderr, "\nChecking for available OTPS tide models\n");
fprintf(stderr, "OTPS location: %s\nValid OTPS tidal models:\n", otps_location_use);
}
notpsmodels = 0;
sprintf(line, "/bin/ls -1 %s/DATA | grep Model_ | sed \"s/^Model_//\"", otps_location_use);
if ((tfp = popen(line, "r")) != NULL)
{
/* send relevant input to predict_tide through its stdin stream */
while (fgets(line, sizeof(line), tfp))
{
sscanf(line, "%s", modelname);
sprintf(modelfile, "%s/DATA/Model_%s", otps_location_use, modelname);
nmodeldatafiles = 0;
/* check the files referenced in the model file */
if ((mfp = fopen(modelfile, "r")) != NULL)
{
/* stat the file referenced in each line */
while (fgets(modeldatafile, MB_PATH_MAXLINE, mfp) != NULL)
{
if (strlen(modeldatafile) > 0)
modeldatafile[strlen(modeldatafile) - 1] = '\0';
if (( (fstat =
stat(modeldatafile,
&file_status)) == 0) && ( (file_status.st_mode & S_IFMT) != S_IFDIR) )
nmodeldatafiles++;
}
fclose(mfp);
}
if (nmodeldatafiles >= 3)
{
if (help || ( verbose > 0) )
fprintf(stderr, " %s\n", modelname);
if (otps_model_set == MB_NO)
if (( notpsmodels == 0) || ( strcmp(modelname, MBOTPS_DEFAULT_MODEL) == 0) )
strcpy(otps_model, modelname);
notpsmodels++;
}
}
/* close the process */
pclose(tfp);
}
else
{
error = MB_ERROR_OPEN_FAIL;
fprintf(stderr, "\nUnable to open ls using popen()\n");
fprintf(stderr, "\nProgram <%s> Terminated\n", program_name);
exit(MB_FAILURE);
}
if (help || ( verbose > 0) )
{
fprintf(stderr, "Number of available OTPS tide models: %d\n", notpsmodels);
fprintf(stderr, "\nUsing OTPS tide model: %s\n", otps_model);
}
/* 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 otps_location: %s\n", otps_location);
fprintf(stderr, "dbg2 otps_location_use: %s\n", otps_location_use);
fprintf(stderr, "dbg2 otps_model_set: %d\n", otps_model_set);
fprintf(stderr, "dbg2 otps_model: %s\n", otps_model);
fprintf(stderr, "dbg2 mbotps_mode: %d\n", mbotps_mode);
fprintf(stderr, "dbg2 tidelon: %f\n", tidelon);
fprintf(stderr, "dbg2 tidelat: %f\n", tidelat);
fprintf(stderr, "dbg2 tidestation_file: %s\n", tidestation_file);
fprintf(stderr, "dbg2 tidestation_lon: %f\n", tidestation_lon);
fprintf(stderr, "dbg2 tidestation_lat: %f\n", tidestation_lat);
fprintf(stderr, "dbg2 tidestation_format: %d\n", tidestation_format);
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 interval: %f\n", interval);
fprintf(stderr, "dbg2 tide_file: %s\n", tide_file);
fprintf(stderr, "dbg2 mbprocess_update: %d\n", mbprocess_update);
fprintf(stderr, "dbg2 skip_existing: %d\n", skip_existing);
fprintf(stderr, "dbg2 tideformat: %d\n", tideformat);
fprintf(stderr, "dbg2 format: %d\n", format);
fprintf(stderr, "dbg2 read_file: %s\n", read_file);
}
/* exit if no valid OTPS models can be found */
if (notpsmodels <= 0)
{
error = MB_ERROR_OPEN_FAIL;
fprintf(stderr, "\nUnable to find a valid OTPS tidal model\n");
fprintf(stderr, "\nProgram <%s> Terminated\n", program_name);
exit(MB_FAILURE);
}
/* if help was all that was desired then exit */
if (help)
exit(error);
/* -------------------------------------------------------------------------
* if specified read in tide station data and calculate model values for the
* same location and times- the difference is applied as a correction to the
* model values calculated at the desired locations and times
* -----------------------------------------------------------------------*/
if (mbotps_mode & MBOTPS_MODE_TIDESTATION)
{
/* make sure longitude is positive */
if (tidestation_lon < 0.0)
tidestation_lon += 360.0;
/* open the tide station data file */
if ((tfp = fopen(tidestation_file, "r")) == NULL)
{
error = MB_ERROR_OPEN_FAIL;
fprintf(stderr,
"\nUnable to open tide station file <%s> for writing\n",
tidestation_file);
fprintf(stderr, "\nProgram <%s> Terminated\n", program_name);
exit(MB_FAILURE);
}
/* count the lines in the tide station data */
ntidestation = 0;
while ((result = fgets(line, MB_PATH_MAXLINE, tfp)) == line)
ntidestation++;
rewind(tfp);
/* allocate memory for tide station arrays */
size = ntidestation * sizeof(double);
status =mb_mallocd(verbose, __FILE__, __LINE__, size, (void **)&tidestation_time_d, &error);
if (error == MB_ERROR_NO_ERROR)
status = mb_mallocd(verbose, __FILE__, __LINE__, size, (void **)&tidestation_tide, &error);
if (error == MB_ERROR_NO_ERROR)
status = mb_mallocd(verbose, __FILE__, __LINE__, size, (void **)&tidestation_model, &error);
if (error == MB_ERROR_NO_ERROR)
status = mb_mallocd(verbose, __FILE__, __LINE__, size, (void **)&tidestation_correction, &error);
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);
}
/* read the tide station data in the specified format */
ntidestation = 0;
while ((result = fgets(line, MB_PATH_MAXLINE, tfp)) == line)
{
tidestation_ok = MB_NO;
/* ignore comments */
if (line[0] != '#')
{
/* deal with tide station data in form: time_d tide */
if (tidestation_format == 1)
{
nget = sscanf(line,
"%lf %lf",
&tidestation_time_d[ntidestation],
&tidestation_tide[ntidestation]);
if (nget == 2)
tidestation_ok = MB_YES;
}
/* deal with tide station data in form: yr mon day hour min sec tide */
else if (tidestation_format == 2)
{
nget = sscanf(line,
"%d %d %d %d %d %lf %lf",
&time_i[0],
&time_i[1],
&time_i[2],
&time_i[3],
&time_i[4],
&sec,
&tidestation_tide[ntidestation]);
time_i[5] = (int)sec;
time_i[6] = 1000000 * (sec - time_i[5]);
mb_get_time(verbose, time_i, &time_d);
tidestation_time_d[ntidestation] = time_d;
if (nget == 7)
tidestation_ok = MB_YES;
}
/* deal with tide station data in form: yr jday hour min sec tide */
else if (tidestation_format == 3)
{
nget = sscanf(line,
"%d %d %d %d %lf %lf",
&time_j[0],
&time_j[1],
&ihr,
&time_j[2],
&sec,
&tidestation_tide[ntidestation]);
time_j[2] = time_j[2] + 60 * ihr;
time_j[3] = (int)sec;
time_j[4] = 1000000 * (sec - time_j[3]);
mb_get_itime(verbose, time_j, time_i);
mb_get_time(verbose, time_i, &time_d);
tidestation_time_d[ntidestation] = time_d;
if (nget == 6)
tidestation_ok = MB_YES;
}
/* deal with tide station data in form: yr jday daymin sec tide */
else if (tidestation_format == 4)
{
nget = sscanf(line,
"%d %d %d %lf %lf",
&time_j[0],
&time_j[1],
&time_j[2],
&sec,
&tidestation_tide[ntidestation]);
time_j[3] = (int)sec;
time_j[4] = 1000000 * (sec - time_j[3]);
mb_get_itime(verbose, time_j, time_i);
mb_get_time(verbose, time_i, &time_d);
tidestation_time_d[ntidestation] = time_d;
if (nget == 5)
tidestation_ok = MB_YES;
}
}
/* output some debug values */
if ((verbose >= 5) && (tidestation_ok == MB_YES))
{
fprintf(stderr, "\ndbg5 New tide point read in program <%s>\n", program_name);
fprintf(stderr, "dbg5 tide[%d]: %f %f\n", ntidestation,
tidestation_time_d[ntidestation], tidestation_tide[ntidestation]);
}
else if (verbose >= 5)
{
fprintf(stderr,
"\ndbg5 Error parsing line in tide file in program <%s>\n",
program_name);
fprintf(stderr, "dbg5 line: %s\n", line);
}
/* check for reverses or repeats in time */
if (tidestation_ok == MB_YES)
{
if (ntidestation == 0)
{
ntidestation++;
}
else if (tidestation_time_d[ntidestation] > tidestation_time_d[ntidestation - 1])
{
ntidestation++;
}
else if ((ntidestation > 0) &&
( tidestation_time_d[ntidestation] <= tidestation_time_d[ntidestation - 1]) &&
( verbose >= 5) )
{
fprintf(stderr, "\ndbg5 Tide time error in program <%s>\n", program_name);
fprintf(stderr,
"dbg5 tide[%d]: %f %f\n",
ntidestation - 1,
tidestation_time_d[ntidestation - 1],
tidestation_tide[ntidestation - 1]);
fprintf(stderr,
"dbg5 tide[%d]: %f %f\n",
ntidestation,
tidestation_time_d[ntidestation],
tidestation_tide[ntidestation]);
}
}
strncpy(line, "\0", sizeof(line));
}
fclose(tfp);
/* now get time and tide model values at the tide station location
first open temporary file of lat lon time*/
pid = getpid();
sprintf(lltfile, "tmp_mbotps_llt_%d.txt", pid);
sprintf(otpsfile, "tmp_mbotps_llttd_%d.txt", pid);
if ((tfp = fopen(lltfile, "w")) == NULL)
{
error = MB_ERROR_OPEN_FAIL;
fprintf(stderr,
"\nUnable to open temporary lat-lon-time file <%s> for writing\n",
lltfile);
fprintf(stderr, "\nProgram <%s> Terminated\n", program_name);
exit(MB_FAILURE);
}
else {
for (i = 0; i < ntidestation; i++) {
mb_get_date(verbose, tidestation_time_d[i], time_i);
fprintf(tfp, "%.6f %.6f %4.4d %2.2d %2.2d %2.2d %2.2d %2.2d\n",
tidestation_lat, tidestation_lon,
time_i[0], time_i[1], time_i[2], time_i[3], time_i[4], time_i[5]);
}
fclose(tfp);
}
/* call predict_tide with popen */
sprintf(predict_tide, "%s/predict_tide", otps_location_use);
if ((tfp = popen(predict_tide, "w")) == NULL)
{
error = MB_ERROR_OPEN_FAIL;
fprintf(stderr, "\nUnable to open predict_time program using popen()\n");
fprintf(stderr, "\nProgram <%s> Terminated\n", program_name);
exit(MB_FAILURE);
}
/* send relevant input to predict_tide through its stdin stream */
fprintf(tfp, "%s/DATA/Model_%s\n", otps_location_use, otps_model);
fprintf(tfp, "%s\n", lltfile);
fprintf(tfp, "z\n\nAP\noce\n1\n");
/*fprintf(tfp, "z\nm2,s2,n2,k2,k1,o1,p1,q1\nAP\noce\n1\n");*/
fprintf(tfp, "%s\n", otpsfile);
/* close the process */
pclose(tfp);
/* now read results from predict_tide and rewrite them in a useful form */
if ((tfp = fopen(otpsfile, "r")) == NULL)
{
error = MB_ERROR_OPEN_FAIL;
fprintf(stderr, "\nUnable to open predict_time results temporary file <%s>\n",
otpsfile);
fprintf(stderr, "\nProgram <%s> Terminated\n", program_name);
exit(MB_FAILURE);
}
nline = 0;
ngood = 0;
while ((result = fgets(line, MB_PATH_MAXLINE, tfp)) == line)
{
nline++;
if (nline > 6)
{
nget = sscanf(line,
"%lf %lf %d.%d.%d %d:%d:%d %lf %lf",
&lat, &lon,
&time_i[1], &time_i[2], &time_i[0], &time_i[3], &time_i[4], &time_i[5],
&tide, &depth);
if (nget == 10)
{
tidestation_model[ngood] = tide;
tidestation_correction[ngood] = tidestation_tide[ngood] - tidestation_model[ngood];
ngood++;
}
}
}
fclose(tfp);
if (ngood != ntidestation)
{
error = MB_ERROR_BAD_FORMAT;
fprintf(stderr,
"\nNumber of tide station values does not match number of model values <%d != %d>\n",
ntidestation,
ngood);
fprintf(stderr, "\nProgram <%s> Terminated\n", program_name);
exit(MB_FAILURE);
}
/* get start end min max of tide station data */
tidestation_d_min = 0.0;
tidestation_d_max = 0.0;
tidestation_m_min = 0.0;
tidestation_m_max = 0.0;
tidestation_c_min = 0.0;
tidestation_c_max = 0.0;
for (i = 0; i < ntidestation; i++) {
if (i == 0) {
tidestation_d_min = tidestation_tide[i];
tidestation_d_max = tidestation_tide[i];
tidestation_m_min = tidestation_model[i];
tidestation_m_max = tidestation_model[i];
tidestation_c_min = tidestation_correction[i];
tidestation_c_max = tidestation_correction[i];
tidestation_stime_d = tidestation_time_d[i];
} else {
tidestation_d_min = MIN(tidestation_tide[i], tidestation_d_min);
tidestation_d_max = MAX(tidestation_tide[i], tidestation_d_max);
tidestation_m_min = MIN(tidestation_model[i], tidestation_m_min);
tidestation_m_max = MAX(tidestation_model[i], tidestation_m_max);
tidestation_c_min = MIN(tidestation_correction[i], tidestation_c_min);
tidestation_c_max = MAX(tidestation_correction[i], tidestation_c_max);
tidestation_etime_d = tidestation_time_d[i];
}
}
mb_get_date(verbose, tidestation_stime_d, tidestation_stime_i);
mb_get_date(verbose, tidestation_etime_d, tidestation_etime_i);
/* output info on tide station data */
if (( verbose > 0) && mbotps_mode & MBOTPS_MODE_TIDESTATION)
{
fprintf(stderr, "\nTide station data file: %s\n", tidestation_file);
fprintf(stderr, " Tide station longitude: %f\n", tidestation_lon);
fprintf(stderr, " Tide station latitude: %f\n", tidestation_lat);
fprintf(stderr, " Tide station format: %d\n", tidestation_format);
fprintf(stderr, " Tide station data summary:\n");
fprintf(stderr, " Number of samples: %d\n", ntidestation);
fprintf(stderr,
" Start time: %4.4d/%2.2d/%2.2d %2.2d:%2.2d:%2.2d.%6.6d\n",
tidestation_stime_i[0],
tidestation_stime_i[1],
tidestation_stime_i[2],
tidestation_stime_i[3],
tidestation_stime_i[4],
tidestation_stime_i[5],
tidestation_stime_i[6]);
fprintf(stderr,
" End time: %4.4d/%2.2d/%2.2d %2.2d:%2.2d:%2.2d.%6.6d\n",
tidestation_etime_i[0],
tidestation_etime_i[1],
tidestation_etime_i[2],
tidestation_etime_i[3],
tidestation_etime_i[4],
tidestation_etime_i[5],
tidestation_etime_i[6]);
fprintf(stderr, " Minimum values: %7.3f %7.3f %7.3f\n",
tidestation_d_min, tidestation_m_min, tidestation_c_min);
fprintf(stderr, " Maximum values: %7.3f %7.3f %7.3f\n",
tidestation_d_max, tidestation_m_max, tidestation_c_max);
}
/* remove the temporary files */
unlink(lltfile);
unlink(otpsfile);
}
/* -------------------------------------------------------------------------
* calculate tide model for a single position and time range
* -----------------------------------------------------------------------*/
if (!(mbotps_mode & MBOTPS_MODE_NAVIGATION))
{
/* first open temporary file of lat lon time */
pid = getpid();
sprintf(lltfile, "tmp_mbotps_llt_%d.txt", pid);
sprintf(otpsfile, "tmp_mbotps_llttd_%d.txt", pid);
if ((tfp = fopen(lltfile, "w")) == NULL)
{
error = MB_ERROR_OPEN_FAIL;
fprintf(stderr,
"\nUnable to open temporary lat-lon-time file <%s> for writing\n",
lltfile);
fprintf(stderr, "\nProgram <%s> Terminated\n", program_name);
exit(MB_FAILURE);
}
/* make sure longitude is positive */
if (tidelon < 0.0)
tidelon += 360.0;
/* loop over the time of interest generating the lat-lon-time values */
mb_get_time(verbose, btime_i, &btime_d);
mb_get_time(verbose, etime_i, &etime_d);
ntime = 1 + (int)floor((etime_d - btime_d) / interval);
for (i = 0; i < ntime; i++)
{
time_d = btime_d + i * interval;
mb_get_date(verbose, time_d, time_i);
fprintf(tfp,
"%.6f %.6f %4.4d %2.2d %2.2d %2.2d %2.2d %2.2d\n",
tidelat,
tidelon,
time_i[0],
time_i[1],
time_i[2],
time_i[3],
time_i[4],
time_i[5]);
}
/* close the llt file */
fclose(tfp);
/* call predict_tide with popen */
sprintf(predict_tide, "%s/predict_tide", otps_location_use);
if ((tfp = popen(predict_tide, "w")) == NULL)
{
error = MB_ERROR_OPEN_FAIL;
fprintf(stderr, "\nUnable to open predict_time program using popen()\n");
fprintf(stderr, "\nProgram <%s> Terminated\n", program_name);
exit(MB_FAILURE);
}
/* send relevant input to predict_tide through its stdin stream */
fprintf(tfp, "%s/DATA/Model_%s\n", otps_location_use, otps_model);
fprintf(tfp, "%s\n", lltfile);
fprintf(tfp, "z\n\nAP\noce\n1\n");
/*fprintf(tfp, "z\nm2,s2,n2,k2,k1,o1,p1,q1\nAP\noce\n1\n");*/
fprintf(tfp, "%s\n", otpsfile);
/* close the process */
pclose(tfp);
/* now read results from predict_tide and rewrite them in a useful form */
if ((tfp = fopen(otpsfile, "r")) == NULL)
{
error = MB_ERROR_OPEN_FAIL;
fprintf(stderr, "\nUnable to open predict_time results temporary file <%s>\n",
otpsfile);
fprintf(stderr, "\nProgram <%s> Terminated\n", program_name);
exit(MB_FAILURE);
}
if ((ofp = fopen(tide_file, "w")) == NULL)
{
error = MB_ERROR_OPEN_FAIL;
fprintf(stderr, "\nUnable to open tide output file <%s>\n", tide_file);
fprintf(stderr, "\nProgram <%s> Terminated\n", program_name);
exit(MB_FAILURE);
}
fprintf(ofp, "# Tide model generated by program %s\n", program_name);
fprintf(ofp, "# MB-System Version: %s\n", MB_VERSION);
fprintf(ofp, "# Tide model generated by program %s\n", program_name);
fprintf(ofp, "# which in turn calls OTPS program predict_tide obtained from:\n");
fprintf(ofp, "# http://www.coas.oregonstate.edu/research/po/research/tide/\n");
fprintf(ofp, "#\n");
fprintf(ofp, "# OTPSnc tide model: \n");
fprintf(ofp, "# %s\n", otps_model);
if (tideformat == 2)
{
fprintf(ofp, "# Output format:\n");
fprintf(ofp, "# year month day hour minute second tide\n");
fprintf(ofp, "# where tide is in meters\n");
}
else
{
fprintf(ofp, "# Output format:\n");
fprintf(ofp, "# time_d tide\n");
fprintf(ofp, "# where time_d is in seconds since January 1, 1970\n");
fprintf(ofp, "# and tide is in meters\n");
}
right_now = time((time_t *)0);
strcpy(date, ctime(&right_now));
date[strlen(date) - 1] = '\0';
if ((user_ptr = getenv("USER")) == NULL)
user_ptr = getenv("LOGNAME");
if (user_ptr != NULL)
strcpy(user, user_ptr);
else
strcpy(user, "unknown");
gethostname(host, MBP_FILENAMESIZE);
fprintf(ofp, "# Run by user <%s> on cpu <%s> at <%s>\n", user, host, date);
/* loop over tide model values, writing them out in the specified format */
nline = 0;
ngood = 0;
while ((result = fgets(line, MB_PATH_MAXLINE, tfp)) == line)
{
nline++;
if (( nline == 2) || ( nline == 3) )
{
fprintf(ofp, "#%s", line);
}
else if (nline > 6)
{
nget = sscanf(line,
"%lf %lf %d.%d.%d %d:%d:%d %lf %lf",
&lat,
&lon,
&time_i[1],
&time_i[2],
&time_i[0],
&time_i[3],
&time_i[4],
&time_i[5],
&tide,
&depth);
if (nget == 10)
{
ngood++;
/* if tide station data have been loaded, interpolate the
* correction value to apply to the tide model */
if (mbotps_mode & MBOTPS_MODE_TIDESTATION && (ntidestation > 0))
{
intstat = mb_linear_interp(verbose,
tidestation_time_d - 1,
tidestation_correction - 1,
ntidestation,
time_d,
&correction,
&itime,
&error);
if (intstat == MB_SUCCESS)
tide += correction;
/*fprintf(stderr,"TIDE STATION CORRECTION: intstat:%d itime:%dof%d time_d:%f correction:%f
tide:%f\n", */
/* intstat, itime, ntidestation, time_d, correction, tide); */
}
/* write out the tide model */
if (tideformat == 2)
{
fprintf(ofp,
"%4.4d %2.2d %2.2d %2.2d %2.2d %2.2d %9.4f\n",
time_i[0],
time_i[1],
time_i[2],
time_i[3],
time_i[4],
time_i[5],
tide);
}
else
{
mb_get_time(verbose, time_i, &time_d);
fprintf(ofp, "%.3f %9.4f\n", time_d, tide);
}
}
}
}
fclose(tfp);
fclose(ofp);
/* remove the temporary files */
unlink(lltfile);
unlink(otpsfile);
/* some helpful output */
fprintf(stderr, "\nResults are really in %s\n", tide_file);
} /* end single position mode */
/* -------------------------------------------------------------------------
* else get tides along the navigation contained in a set of swath files
* -----------------------------------------------------------------------*/
else if (mbotps_mode & MBOTPS_MODE_NAVIGATION)
{
/*fprintf(stderr,"Doing tide correction for swath navigation\n"); */
/* 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, dfile, &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)
{
/* Figure out if the file needs a tide model - don't generate a new tide
model if one was made previously and is up to date AND the
appropriate request has been made */
proceed = MB_YES;
sprintf(tide_file, "%s.tde", file);
if (skip_existing == MB_YES)
{
if (( (fstat =
stat(file,
&file_status)) == 0) && ( (file_status.st_mode & S_IFMT) != S_IFDIR) )
{
input_modtime = file_status.st_mtime;
input_size = file_status.st_size;
}
else
{
input_modtime = 0;
input_size = 0;
}
if (( (fstat =
stat(tide_file,
&file_status)) == 0) && ( (file_status.st_mode & S_IFMT) != S_IFDIR) )
{
output_modtime = file_status.st_mtime;
output_size = file_status.st_size;
}
else
{
output_modtime = 0;
output_size = 0;
}
if (( output_modtime > input_modtime) && ( input_size > 0) && ( output_size > 0) )
proceed = MB_NO;
}
/* skip the file */
if (proceed == MB_NO)
{
/* some helpful output */
fprintf(stderr,
"\n---------------------------------------\n\nProcessing tides for %s\n\n",
file);
fprintf(stderr, "Skipped - tide model file is up to date\n\n");
}
/* generate the tide model */
else
{
/* some helpful output */
fprintf(stderr,
"\n---------------------------------------\n\nProcessing tides for %s\n\n",
file);
/* note tide station correction */
if (mbotps_mode & MBOTPS_MODE_TIDESTATION && (ntidestation > 0)) {
fprintf(stderr, "Applying tide station correction\n\n");
}
/* first open temporary file of lat lon time */
pid = getpid();
strcpy(swath_file, file);
sprintf(lltfile, "tmp_mbotps_llt_%d.txt", pid);
sprintf(otpsfile, "tmp_mbotps_llttd_%d.txt", pid);
if ((tfp = fopen(lltfile, "w")) == NULL)
{
error = MB_ERROR_OPEN_FAIL;
fprintf(stderr,
"\nUnable to open temporary lat-lon-time file <%s> for writing\n",
lltfile);
fprintf(stderr, "\nProgram <%s> Terminated\n", program_name);
exit(MB_FAILURE);
}
/* read fnv file if possible */
mb_get_fnv(verbose, file, &format, &error);
/* 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);
}
/* read and use data */
nread = 0;
while (error <= MB_ERROR_NO_ERROR)
{
/* reset error */
error = MB_ERROR_NO_ERROR;
output = MB_NO;
/* read next data record */
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);
/* 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 error: %d\n", error);
fprintf(stderr, "dbg2 status: %d\n", status);
}
/* deal with nav and time from survey data only - not nav, sidescan, or
subbottom */
if (( error <= MB_ERROR_NO_ERROR) && ( kind == MB_DATA_DATA) )
{
/* flag positions and times for output at specified interval */
if (( nread == 0) || ( time_d - savetime_d >= interval) )
{
savetime_d = time_d;
output = MB_YES;
}
lasttime_d = time_d;
lastlon = navlon;
lastlat = navlat;
/* increment counter */
nread++;
}
/* output position and time if flagged or end of file */
if (( output == MB_YES) || ( error == MB_ERROR_EOF) )
{
if (lastlon < 0.0)
lastlon += 360.0;
mb_get_date(verbose, lasttime_d, time_i);
fprintf(tfp,
"%.6f %.6f %4.4d %2.2d %2.2d %2.2d %2.2d %2.2d\n",
lastlat,
lastlon,
time_i[0],
time_i[1],
time_i[2],
time_i[3],
time_i[4],
time_i[5]);
}
}
/* close the swath file */
status = mb_close(verbose, &mbio_ptr, &error);
/* output read statistics */
fprintf(stderr, "%d records read from %s\n", nread, file);
/* close the llt file */
fclose(tfp);
/* call predict_tide with popen */
sprintf(predict_tide, "%s/predict_tide", otps_location_use);
if ((tfp = popen(predict_tide, "w")) == NULL)
{
error = MB_ERROR_OPEN_FAIL;
fprintf(stderr, "\nUnable to open predict_time program using popen()\n");
fprintf(stderr, "\nProgram <%s> Terminated\n", program_name);
exit(MB_FAILURE);
}
/* send relevant input to predict_tide through its stdin stream */
fprintf(tfp, "%s/DATA/Model_%s\n", otps_location_use, otps_model);
fprintf(tfp, "%s\n", lltfile);
fprintf(tfp, "z\n\nAP\noce\n1\n");
/*fprintf(tfp, "z\nm2,s2,n2,k2,k1,o1,p1,q1\nAP\noce\n1\n");*/
fprintf(tfp, "%s\n", otpsfile);
/* close the process */
pclose(tfp);
/* now read results from predict_tide and rewrite them in a useful form */
if ((tfp = fopen(otpsfile, "r")) == NULL)
{
error = MB_ERROR_OPEN_FAIL;
fprintf(stderr,
"\nUnable to open predict_time results temporary file <%s>\n",
otpsfile);
fprintf(stderr, "\nProgram <%s> Terminated\n", program_name);
exit(MB_FAILURE);
}
if ((ofp = fopen(tide_file, "w")) == NULL)
{
error = MB_ERROR_OPEN_FAIL;
fprintf(stderr, "\nUnable to open tide output file <%s>\n", tide_file);
fprintf(stderr, "\nProgram <%s> Terminated\n", program_name);
exit(MB_FAILURE);
}
fprintf(ofp, "# Tide model generated by program %s\n", program_name);
fprintf(ofp, "# MB-System Version: %s\n", MB_VERSION);
fprintf(ofp, "# Tide model generated by program %s\n", program_name);
fprintf(ofp, "# which in turn calls OTPS program predict_tide obtained from:\n");
fprintf(ofp, "# http://www.coas.oregonstate.edu/research/po/research/tide/\n");
right_now = time((time_t *)0);
strcpy(date, ctime(&right_now));
date[strlen(date) - 1] = '\0';
if ((user_ptr = getenv("USER")) == NULL)
user_ptr = getenv("LOGNAME");
if (user_ptr != NULL)
strcpy(user, user_ptr);
else
strcpy(user, "unknown");
gethostname(host, MBP_FILENAMESIZE);
fprintf(ofp, "# Run by user <%s> on cpu <%s> at <%s>\n", user, host, date);
/* loop over tide model values, writing them out in the specified format */
nline = 0;
ngood = 0;
while ((result = fgets(line, MB_PATH_MAXLINE, tfp)) == line)
{
nline++;
if (( nline == 2) || ( nline == 3) )
{
fprintf(ofp, "#%s", line);
}
else if (nline > 6)
{
nget = sscanf(line,
"%lf %lf %d.%d.%d %d:%d:%d %lf %lf",
&lat,
&lon,
&time_i[1],
&time_i[2],
&time_i[0],
&time_i[3],
&time_i[4],
&time_i[5],
&tide,
&depth);
if (nget == 10)
{
ngood++;
/* if tide station data have been loaded, interpolate the
* correction value to apply to the tide model */
if (mbotps_mode & MBOTPS_MODE_TIDESTATION && (ntidestation > 0))
{
intstat = mb_linear_interp(verbose,
tidestation_time_d - 1,
tidestation_correction - 1,
ntidestation,
time_d,
&correction,
&itime,
&error);
if (intstat == MB_SUCCESS)
tide += correction;
// fprintf(stderr,"TIDE STATION CORRECTION: intstat:%d itime:%dof%d time_d:%f correction:%f tide:%f\n",
// intstat, itime, ntidestation, time_d, correction, tide);
}
/* write out the tide model */
if (tideformat == 2)
{
fprintf(ofp,
"%4.4d %2.2d %2.2d %2.2d %2.2d %2.2d %9.4f\n",
time_i[0],
time_i[1],
time_i[2],
time_i[3],
time_i[4],
time_i[5],
tide);
}
else
{
mb_get_time(verbose, time_i, &time_d);
fprintf(ofp, "%.3f %9.4f\n", time_d, tide);
}
}
}
}
fclose(tfp);
fclose(ofp);
/* remove the temporary files */
unlink(lltfile);
unlink(otpsfile);
/* some helpful output */
fprintf(stderr, "\nResults are really in %s\n", tide_file);
/* set mbprocess usage of tide file */
if (( mbprocess_update == MB_YES) && ( ngood > 0) )
{
status = mb_pr_update_tide(verbose,
swath_file,
MBP_TIDE_ON,
tide_file,
tideformat,
&error);
fprintf(stderr, "MBprocess set to apply tide correction to %s\n", swath_file);
}
}
/* figure out whether and what to read next */
if (read_datalist == MB_YES)
{
if ((status =
mb_datalist_read(verbose, datalist, file, dfile, &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);
} /* main */
/*--------------------------------------------------------------------*/
int mbr_rt_em12darw(int verbose, void *mbio_ptr, void *store_ptr, int *error) {
char *function_name = "mbr_rt_em12darw";
int status = MB_SUCCESS;
struct mb_io_struct *mb_io_ptr;
struct mbf_em12darw_struct *data;
struct mbsys_simrad_struct *store;
struct mbsys_simrad_survey_struct *ping;
char line[MBF_EM12DARW_RECORD_LENGTH];
int index;
char *datacomment;
int time_j[5];
int time_i[7];
int kind;
int i;
/* print input debug statements */
if (verbose >= 2) {
fprintf(stderr, "\ndbg2 MBIO function <%s> called\n", function_name);
fprintf(stderr, "dbg2 Input arguments:\n");
fprintf(stderr, "dbg2 verbose: %d\n", verbose);
fprintf(stderr, "dbg2 mbio_ptr: %p\n", (void *)mbio_ptr);
fprintf(stderr, "dbg2 store_ptr: %p\n", (void *)store_ptr);
}
/* get pointer to mbio descriptor */
mb_io_ptr = (struct mb_io_struct *)mbio_ptr;
/* get pointer to raw data structure */
data = (struct mbf_em12darw_struct *)mb_io_ptr->raw_data;
datacomment = (char *)&line[80];
store = (struct mbsys_simrad_struct *)store_ptr;
/* set file position */
mb_io_ptr->file_pos = mb_io_ptr->file_bytes;
/* read next record from file */
if ((status = fread(line, 1, MBF_EM12DARW_RECORD_LENGTH, mb_io_ptr->mbfp)) == MBF_EM12DARW_RECORD_LENGTH) {
mb_io_ptr->file_bytes += status;
status = MB_SUCCESS;
*error = MB_ERROR_NO_ERROR;
}
else {
mb_io_ptr->file_bytes += status;
status = MB_FAILURE;
*error = MB_ERROR_EOF;
}
/* get data type */
kind = MB_DATA_NONE;
if (status == MB_SUCCESS) {
mb_get_binary_short(MB_NO, &line[0], &(data->func));
}
/* deal with comment */
if (status == MB_SUCCESS && data->func == 100) {
kind = MB_DATA_COMMENT;
strncpy(store->comment, datacomment, MBSYS_SIMRAD_COMMENT_LENGTH);
}
/* deal with data */
else if (status == MB_SUCCESS && data->func == 150) {
kind = MB_DATA_DATA;
index = 2;
mb_get_binary_short(MB_NO, &line[index], &(data->year));
index += 2;
mb_get_binary_short(MB_NO, &line[index], &(data->jday));
index += 2;
mb_get_binary_short(MB_NO, &line[index], &(data->minute));
index += 2;
mb_get_binary_short(MB_NO, &line[index], &(data->secs));
index += 8;
mb_get_binary_double(MB_NO, &line[index], &(data->latitude));
index += 8;
mb_get_binary_double(MB_NO, &line[index], &(data->longitude));
index += 8;
mb_get_binary_short(MB_NO, &line[index], &(data->corflag));
index += 4;
mb_get_binary_float(MB_NO, &line[index], &(data->utm_merd));
index += 4;
mb_get_binary_short(MB_NO, &line[index], &(data->utm_zone));
index += 2;
mb_get_binary_short(MB_NO, &line[index], &(data->posq));
index += 2;
mb_get_binary_int(MB_NO, &line[index], &(data->pingno));
index += 4;
mb_get_binary_short(MB_NO, &line[index], &(data->mode));
index += 4;
mb_get_binary_float(MB_NO, &line[index], &(data->depthl));
index += 4;
mb_get_binary_float(MB_NO, &line[index], &(data->speed));
index += 4;
mb_get_binary_float(MB_NO, &line[index], &(data->gyro));
index += 4;
mb_get_binary_float(MB_NO, &line[index], &(data->roll));
index += 4;
mb_get_binary_float(MB_NO, &line[index], &(data->pitch));
index += 4;
mb_get_binary_float(MB_NO, &line[index], &(data->heave));
index += 4;
mb_get_binary_float(MB_NO, &line[index], &(data->sndval));
index += 4;
for (i = 0; i < MBF_EM12DARW_BEAMS; i++) {
mb_get_binary_short(MB_NO, &line[index], &(data->depth[i]));
index += 2;
}
for (i = 0; i < MBF_EM12DARW_BEAMS; i++) {
mb_get_binary_short(MB_NO, &line[index], &(data->distacr[i]));
index += 2;
}
for (i = 0; i < MBF_EM12DARW_BEAMS; i++) {
mb_get_binary_short(MB_NO, &line[index], &(data->distalo[i]));
index += 2;
}
for (i = 0; i < MBF_EM12DARW_BEAMS; i++) {
mb_get_binary_short(MB_NO, &line[index], &(data->range[i]));
index += 2;
}
for (i = 0; i < MBF_EM12DARW_BEAMS; i++) {
mb_get_binary_short(MB_NO, &line[index], &(data->refl[i]));
index += 2;
}
for (i = 0; i < MBF_EM12DARW_BEAMS; i++) {
mb_get_binary_short(MB_NO, &line[index], &(data->beamq[i]));
index += 2;
}
/* print debug statements */
if (verbose >= 4) {
fprintf(stderr, "\ndbg4 Data read by MBIO function <%s>\n", function_name);
fprintf(stderr, "dbg4 Read values:\n");
fprintf(stderr, "dbg4 kind: %d\n", kind);
fprintf(stderr, "dbg4 error: %d\n", *error);
fprintf(stderr, "dbg4 year: %d\n", data->year);
fprintf(stderr, "dbg4 jday: %d\n", data->jday);
fprintf(stderr, "dbg4 minute: %d\n", data->minute);
fprintf(stderr, "dbg4 secs: %d\n", data->secs);
fprintf(stderr, "dbg4 latitude: %f\n", data->latitude);
fprintf(stderr, "dbg4 longitude: %f\n", data->longitude);
fprintf(stderr, "dbg4 corflag: %d\n", data->corflag);
fprintf(stderr, "dbg4 utm_merd: %f\n", data->utm_merd);
fprintf(stderr, "dbg4 utm_zone: %d\n", data->utm_zone);
fprintf(stderr, "dbg4 posq: %d\n", data->posq);
fprintf(stderr, "dbg4 pingno: %d\n", data->pingno);
fprintf(stderr, "dbg4 mode: %d\n", data->mode);
fprintf(stderr, "dbg4 depthl: %f\n", data->depthl);
fprintf(stderr, "dbg4 speed: %f\n", data->speed);
fprintf(stderr, "dbg4 gyro: %f\n", data->gyro);
fprintf(stderr, "dbg4 roll: %f\n", data->roll);
fprintf(stderr, "dbg4 pitch: %f\n", data->pitch);
fprintf(stderr, "dbg4 heave: %f\n", data->heave);
fprintf(stderr, "dbg4 sndval: %f\n", data->sndval);
for (i = 0; i < MBF_EM12DARW_BEAMS; i++)
fprintf(stderr, "dbg4 beam:%d depth:%d distacr:%d distalo:%d range:%d refl:%d beamq:%d\n", i,
data->depth[i], data->distacr[i], data->distalo[i], data->range[i], data->refl[i], data->beamq[i]);
}
}
/* else unintelligible */
else if (status == MB_SUCCESS) {
kind = MB_DATA_NONE;
status = MB_FAILURE;
*error = MB_ERROR_UNINTELLIGIBLE;
}
/* set kind and error in mb_io_ptr */
mb_io_ptr->new_kind = kind;
mb_io_ptr->new_error = *error;
/* translate values to em12 data storage structure */
if (status == MB_SUCCESS && store != NULL) {
/* type of data record */
store->kind = kind;
store->sonar = MBSYS_SIMRAD_EM12S;
/* time */
mb_fix_y2k(verbose, (int)data->year, &time_j[0]);
time_j[1] = data->jday;
time_j[2] = data->minute;
time_j[3] = data->secs / 100;
time_j[4] = 0.0001 * (100 * time_j[3] - data->secs);
mb_get_itime(verbose, time_j, time_i);
store->year = data->year;
store->month = time_i[1];
store->day = time_i[2];
store->hour = time_i[3];
store->minute = time_i[4];
store->second = time_i[5];
store->centisecond = 0.0001 * time_i[6];
store->pos_year = store->year;
store->pos_month = store->month;
store->pos_day = store->day;
store->pos_hour = store->hour;
store->pos_minute = store->minute;
store->pos_second = store->second;
store->pos_centisecond = store->centisecond;
/* navigation */
if (data->corflag == 0) {
store->pos_latitude = data->latitude;
store->pos_longitude = data->longitude;
store->utm_northing = 0.0;
store->utm_easting = 0.0;
}
else {
store->pos_latitude = 0.0;
store->pos_longitude = 0.0;
store->utm_northing = data->latitude;
store->utm_easting = data->longitude;
}
store->utm_zone = data->utm_zone;
store->utm_zone_lon = data->utm_merd;
store->utm_system = data->corflag;
store->pos_quality = data->posq;
store->speed = data->speed;
store->line_heading = 10 * data->gyro;
/* allocate secondary data structure for
survey data if needed */
if (kind == MB_DATA_DATA && store->ping == NULL) {
status = mbsys_simrad_survey_alloc(verbose, mbio_ptr, store_ptr, error);
}
/* deal with putting survey data into
secondary data structure */
if (status == MB_SUCCESS && kind == MB_DATA_DATA) {
/* get data structure pointer */
ping = (struct mbsys_simrad_survey_struct *)store->ping;
/* copy data */
ping->longitude = data->longitude;
ping->latitude = data->latitude;
ping->swath_id = EM_SWATH_CENTER;
ping->ping_number = data->pingno;
ping->beams_bath = MBF_EM12DARW_BEAMS;
ping->bath_mode = 0;
ping->bath_res = data->mode;
ping->bath_quality = 0;
ping->keel_depth = data->depthl;
ping->heading = (int)10 * data->gyro;
ping->roll = (int)100 * data->roll;
ping->pitch = (int)100 * data->pitch;
ping->xducer_pitch = (int)100 * data->pitch;
ping->ping_heave = (int)100 * data->heave;
ping->sound_vel = (int)10 * data->sndval;
ping->pixels_ss = 0;
ping->ss_mode = 0;
for (i = 0; i < ping->beams_bath; i++) {
if (data->depth[i] > 0) {
ping->bath[i] = data->depth[i];
ping->beamflag[i] = MB_FLAG_NONE;
}
else if (data->depth[i] < 0) {
ping->bath[i] = -data->depth[i];
ping->beamflag[i] = MB_FLAG_FLAG + MB_FLAG_MANUAL;
}
else {
ping->bath[i] = data->depth[i];
ping->beamflag[i] = MB_FLAG_NULL;
}
ping->bath_acrosstrack[i] = data->distacr[i];
ping->bath_alongtrack[i] = data->distalo[i];
ping->tt[i] = data->range[i];
ping->amp[i] = (mb_s_char)data->refl[i];
ping->quality[i] = (mb_u_char)data->beamq[i];
ping->heave[i] = (mb_s_char)0;
ping->beam_frequency[i] = 0;
ping->beam_samples[i] = 0;
ping->beam_center_sample[i] = 0;
}
}
else if (status == MB_SUCCESS && kind == MB_DATA_COMMENT) {
/* comment */
strncpy(store->comment, datacomment, MBSYS_SIMRAD_COMMENT_LENGTH);
}
}
/* print output debug statements */
if (verbose >= 2) {
fprintf(stderr, "\ndbg2 MBIO function <%s> completed\n", function_name);
fprintf(stderr, "dbg2 Return values:\n");
fprintf(stderr, "dbg2 error: %d\n", *error);
fprintf(stderr, "dbg2 Return status:\n");
fprintf(stderr, "dbg2 status: %d\n", status);
}
return (status);
}
/*--------------------------------------------------------------------*/
int mbsys_sb2100_extract(int verbose, void *mbio_ptr, void *store_ptr,
int *kind, int time_i[7], double *time_d,
double *navlon, double *navlat,
double *speed, double *heading,
int *nbath, int *namp, int *nss,
char *beamflag, double *bath, double *amp,
double *bathacrosstrack, double *bathalongtrack,
double *ss, double *ssacrosstrack, double *ssalongtrack,
char *comment, int *error)
{
char *function_name = "mbsys_sb2100_extract";
int status = MB_SUCCESS;
struct mb_io_struct *mb_io_ptr;
struct mbsys_sb2100_struct *store;
int time_j[5];
double gain_db;
double gain_factor;
int center_pixel;
int i;
/* print input debug statements */
if (verbose >= 2)
{
fprintf(stderr,"\ndbg2 MBIO function <%s> called\n",function_name);
fprintf(stderr,"dbg2 Revision id: %s\n",rcs_id);
fprintf(stderr,"dbg2 Input arguments:\n");
fprintf(stderr,"dbg2 verbose: %d\n",verbose);
fprintf(stderr,"dbg2 mb_ptr: %p\n",(void *)mbio_ptr);
fprintf(stderr,"dbg2 store_ptr: %p\n",(void *)store_ptr);
}
/* get mbio descriptor */
mb_io_ptr = (struct mb_io_struct *) mbio_ptr;
/* get data structure pointer */
store = (struct mbsys_sb2100_struct *) store_ptr;
/* get data kind */
*kind = store->kind;
/* extract data from structure */
if (*kind == MB_DATA_DATA)
{
/* get time */
time_j[0] = store->year;
time_j[1] = store->jday;
time_j[2] = 60*store->hour + store->minute;
time_j[3] = store->sec;
time_j[4] = 1000 * ((int)store->msec);
mb_get_itime(verbose,time_j,time_i);
mb_get_time(verbose,time_i,time_d);
/* get navigation */
*navlon = store->longitude;
*navlat = store->latitude;
/* get heading */
*heading = store->heading;
/* get speed */
*speed = 0.18553167*store->speed;
/* set beamwidths in mb_io structure */
mb_io_ptr->beamwidth_ltrack = 2.0;
mb_io_ptr->beamwidth_xtrack = 2.0;
/* read beam and pixel values into storage arrays */
*nbath = store->nbeams;
*namp = store->nbeams;
*nss = store->npixels;
center_pixel = store->npixels / 2;
gain_db = store->ping_gain
- store->transmitter_attenuation
+ 10.0 * log10( store->ping_pulse_width / 5.0)
- 30.0;
gain_factor = pow(10.0, (-gain_db / 20.0));
for (i=0;i<*nbath;i++)
{
if (store->beams[i].quality == ' ')
beamflag[i] = MB_FLAG_NONE;
else if (store->beams[i].quality == '\n')
beamflag[i] = MB_FLAG_NONE;
else if (store->beams[i].quality == '0')
beamflag[i] = MB_FLAG_NULL;
else if (store->beams[i].quality == 'Q')
beamflag[i] = MB_FLAG_SONAR + MB_FLAG_FLAG;
else if (store->beams[i].quality == 'E')
beamflag[i] = MB_FLAG_MANUAL + MB_FLAG_FLAG;
else if (store->beams[i].quality == 'F')
beamflag[i] = MB_FLAG_FILTER + MB_FLAG_FLAG;
bath[i] = store->beams[i].depth;
bathacrosstrack[i] = store->beams[i].acrosstrack;
bathalongtrack[i] = store->beams[i].alongtrack;
}
for (i=0;i<*namp;i++)
{
amp[i] = 0.25 * store->beams[i].amplitude - gain_db;
}
for (i=0;i<*nss;i++)
{
if (store->pixels[i].amplitude > 0)
ss[i] = gain_factor * store->pixels[i].amplitude;
else
ss[i] = MB_SIDESCAN_NULL;
ssacrosstrack[i] = store->pixel_size
* (i - center_pixel);
ssalongtrack[i] = store->pixels[i].alongtrack;
}
/* print debug statements */
if (verbose >= 5)
{
fprintf(stderr,"\ndbg4 Data extracted by MBIO function <%s>\n",
function_name);
fprintf(stderr,"dbg4 Extracted values:\n");
fprintf(stderr,"dbg4 kind: %d\n",
*kind);
fprintf(stderr,"dbg4 error: %d\n",
*error);
fprintf(stderr,"dbg4 time_i[0]: %d\n",
time_i[0]);
fprintf(stderr,"dbg4 time_i[1]: %d\n",
time_i[1]);
fprintf(stderr,"dbg4 time_i[2]: %d\n",
time_i[2]);
fprintf(stderr,"dbg4 time_i[3]: %d\n",
time_i[3]);
fprintf(stderr,"dbg4 time_i[4]: %d\n",
time_i[4]);
fprintf(stderr,"dbg4 time_i[5]: %d\n",
time_i[5]);
fprintf(stderr,"dbg4 time_i[6]: %d\n",
time_i[6]);
fprintf(stderr,"dbg4 time_d: %f\n",
*time_d);
fprintf(stderr,"dbg4 longitude: %f\n",
*navlon);
fprintf(stderr,"dbg4 latitude: %f\n",
*navlat);
fprintf(stderr,"dbg4 speed: %f\n",
*speed);
fprintf(stderr,"dbg4 heading: %f\n",
*heading);
fprintf(stderr,"dbg4 nbath: %d\n",
*nbath);
for (i=0;i<*nbath;i++)
fprintf(stderr,"dbg4 beam:%d flag:%3d bath:%f acrosstrack:%f alongtrack:%f\n",
i,beamflag[i],bath[i],bathacrosstrack[i],bathalongtrack[i]);
fprintf(stderr,"dbg4 namp: %d\n",
*namp);
for (i=0;i<*namp;i++)
fprintf(stderr,"dbg4 beam:%d amp:%f acrosstrack:%f alongtrack:%f\n",
i,amp[i],bathacrosstrack[i],bathalongtrack[i]);
fprintf(stderr,"dbg4 nss: %d\n",
*nss);
for (i=0;i<*nss;i++)
fprintf(stderr,"dbg4 pixel:%d ss:%f acrosstrack:%f alongtrack:%f\n",
i,ss[i],ssacrosstrack[i],ssalongtrack[i]);
}
/* done translating values */
}
/* extract comment from structure */
else if (*kind == MB_DATA_COMMENT)
{
/* copy comment */
strcpy(comment,store->comment);
/* print debug statements */
if (verbose >= 4)
{
fprintf(stderr,"\ndbg4 New ping read by MBIO function <%s>\n",
function_name);
fprintf(stderr,"dbg4 New ping values:\n");
fprintf(stderr,"dbg4 error: %d\n",
*error);
fprintf(stderr,"dbg4 comment: %s\n",
comment);
}
}
/* print output debug statements */
if (verbose >= 2)
{
fprintf(stderr,"\ndbg2 MBIO function <%s> completed\n",function_name);
fprintf(stderr,"dbg2 Revision id: %s\n",rcs_id);
fprintf(stderr,"dbg2 Return values:\n");
fprintf(stderr,"dbg2 kind: %d\n",*kind);
}
if (verbose >= 2 && *error <= MB_ERROR_NO_ERROR
&& *kind == MB_DATA_COMMENT)
{
fprintf(stderr,"dbg2 comment: \ndbg2 %s\n",
comment);
}
else if (verbose >= 2 && *error <= MB_ERROR_NO_ERROR
&& *kind != MB_DATA_COMMENT)
{
fprintf(stderr,"dbg2 time_i[0]: %d\n",time_i[0]);
fprintf(stderr,"dbg2 time_i[1]: %d\n",time_i[1]);
fprintf(stderr,"dbg2 time_i[2]: %d\n",time_i[2]);
fprintf(stderr,"dbg2 time_i[3]: %d\n",time_i[3]);
fprintf(stderr,"dbg2 time_i[4]: %d\n",time_i[4]);
fprintf(stderr,"dbg2 time_i[5]: %d\n",time_i[5]);
fprintf(stderr,"dbg2 time_i[6]: %d\n",time_i[6]);
fprintf(stderr,"dbg2 time_d: %f\n",*time_d);
fprintf(stderr,"dbg2 longitude: %f\n",*navlon);
fprintf(stderr,"dbg2 latitude: %f\n",*navlat);
fprintf(stderr,"dbg2 speed: %f\n",*speed);
fprintf(stderr,"dbg2 heading: %f\n",*heading);
}
if (verbose >= 2 && *error <= MB_ERROR_NO_ERROR
&& *kind == MB_DATA_DATA)
{
fprintf(stderr,"dbg2 nbath: %d\n",
*nbath);
for (i=0;i<*nbath;i++)
fprintf(stderr,"dbg2 beam:%d flag:%3d bath:%f acrosstrack:%f alongtrack:%f\n",
i,beamflag[i],bath[i],
bathacrosstrack[i],bathalongtrack[i]);
fprintf(stderr,"dbg2 namp: %d\n",
*namp);
for (i=0;i<*namp;i++)
fprintf(stderr,"dbg2 beam:%d amp:%f acrosstrack:%f alongtrack:%f\n",
i,amp[i],bathacrosstrack[i],bathalongtrack[i]);
fprintf(stderr,"dbg2 nss: %d\n",
*nss);
for (i=0;i<*nss;i++)
fprintf(stderr,"dbg2 pixel:%d ss:%f acrosstrack:%f alongtrack:%f\n",
i,ss[i],ssacrosstrack[i],ssalongtrack[i]);
}
if (verbose >= 2)
{
fprintf(stderr,"dbg2 error: %d\n",*error);
fprintf(stderr,"dbg2 Return status:\n");
fprintf(stderr,"dbg2 status: %d\n",status);
}
/* return status */
return(status);
}
/*--------------------------------------------------------------------*/
int mbsys_sb2100_extract_nav(int verbose, void *mbio_ptr, void *store_ptr,
int *kind, int time_i[7], double *time_d,
double *navlon, double *navlat,
double *speed, double *heading, double *draft,
double *roll, double *pitch, double *heave,
int *error)
{
char *function_name = "mbsys_sb2100_extract_nav";
int status = MB_SUCCESS;
struct mb_io_struct *mb_io_ptr;
struct mbsys_sb2100_struct *store;
int time_j[5];
/* print input debug statements */
if (verbose >= 2)
{
fprintf(stderr,"\ndbg2 MBIO function <%s> called\n",function_name);
fprintf(stderr,"dbg2 Revision id: %s\n",rcs_id);
fprintf(stderr,"dbg2 Input arguments:\n");
fprintf(stderr,"dbg2 verbose: %d\n",verbose);
fprintf(stderr,"dbg2 mb_ptr: %p\n",(void *)mbio_ptr);
fprintf(stderr,"dbg2 store_ptr: %p\n",(void *)store_ptr);
}
/* get mbio descriptor */
mb_io_ptr = (struct mb_io_struct *) mbio_ptr;
/* get data structure pointer */
store = (struct mbsys_sb2100_struct *) store_ptr;
/* get data kind */
*kind = store->kind;
/* extract data from structure */
if (*kind == MB_DATA_DATA)
{
/* get time */
time_j[0] = store->year;
time_j[1] = store->jday;
time_j[2] = 60*store->hour + store->minute;
time_j[3] = store->sec;
time_j[4] = 1000 * ((int)store->msec);
mb_get_itime(verbose,time_j,time_i);
mb_get_time(verbose,time_i,time_d);
/* get navigation */
*navlon = store->longitude;
*navlat = store->latitude;
/* get heading */
*heading = store->heading;
/* get speed */
*speed = 0.18553167*store->speed;
/* get draft */
*draft = store->ship_draft;
/* get roll pitch and heave */
*roll = store->roll;
*pitch = store->pitch;
*heave = -store->heave;
/* print debug statements */
if (verbose >= 5)
{
fprintf(stderr,"\ndbg4 Data extracted by MBIO function <%s>\n",
function_name);
fprintf(stderr,"dbg4 Extracted values:\n");
fprintf(stderr,"dbg4 kind: %d\n",
*kind);
fprintf(stderr,"dbg4 error: %d\n",
*error);
fprintf(stderr,"dbg4 time_i[0]: %d\n",
time_i[0]);
fprintf(stderr,"dbg4 time_i[1]: %d\n",
time_i[1]);
fprintf(stderr,"dbg4 time_i[2]: %d\n",
time_i[2]);
fprintf(stderr,"dbg4 time_i[3]: %d\n",
time_i[3]);
fprintf(stderr,"dbg4 time_i[4]: %d\n",
time_i[4]);
fprintf(stderr,"dbg4 time_i[5]: %d\n",
time_i[5]);
fprintf(stderr,"dbg4 time_i[6]: %d\n",
time_i[6]);
fprintf(stderr,"dbg4 time_d: %f\n",
*time_d);
fprintf(stderr,"dbg4 longitude: %f\n",
*navlon);
fprintf(stderr,"dbg4 latitude: %f\n",
*navlat);
fprintf(stderr,"dbg4 speed: %f\n",
*speed);
fprintf(stderr,"dbg4 heading: %f\n",
*heading);
fprintf(stderr,"dbg4 draft: %f\n",
*draft);
fprintf(stderr,"dbg4 roll: %f\n",
*roll);
fprintf(stderr,"dbg4 pitch: %f\n",
*pitch);
fprintf(stderr,"dbg4 heave: %f\n",
*heave);
}
/* done translating values */
}
/* deal with comment */
else if (*kind == MB_DATA_COMMENT)
{
/* set status */
*error = MB_ERROR_COMMENT;
status = MB_FAILURE;
}
/* deal with other record type */
else
{
/* set status */
*error = MB_ERROR_OTHER;
status = MB_FAILURE;
}
/* print output debug statements */
if (verbose >= 2)
{
fprintf(stderr,"\ndbg2 MBIO function <%s> completed\n",function_name);
fprintf(stderr,"dbg2 Revision id: %s\n",rcs_id);
fprintf(stderr,"dbg2 Return values:\n");
fprintf(stderr,"dbg2 kind: %d\n",*kind);
}
if (verbose >= 2 && *error <= MB_ERROR_NO_ERROR
&& *kind == MB_DATA_DATA)
{
fprintf(stderr,"dbg2 time_i[0]: %d\n",time_i[0]);
fprintf(stderr,"dbg2 time_i[1]: %d\n",time_i[1]);
fprintf(stderr,"dbg2 time_i[2]: %d\n",time_i[2]);
fprintf(stderr,"dbg2 time_i[3]: %d\n",time_i[3]);
fprintf(stderr,"dbg2 time_i[4]: %d\n",time_i[4]);
fprintf(stderr,"dbg2 time_i[5]: %d\n",time_i[5]);
fprintf(stderr,"dbg2 time_i[6]: %d\n",time_i[6]);
fprintf(stderr,"dbg2 time_d: %f\n",*time_d);
fprintf(stderr,"dbg2 longitude: %f\n",*navlon);
fprintf(stderr,"dbg2 latitude: %f\n",*navlat);
fprintf(stderr,"dbg2 speed: %f\n",*speed);
fprintf(stderr,"dbg2 heading: %f\n",*heading);
fprintf(stderr,"dbg2 draft: %f\n",*draft);
fprintf(stderr,"dbg2 roll: %f\n",*roll);
fprintf(stderr,"dbg2 pitch: %f\n",*pitch);
fprintf(stderr,"dbg2 heave: %f\n",*heave);
}
if (verbose >= 2)
{
fprintf(stderr,"dbg2 error: %d\n",*error);
fprintf(stderr,"dbg2 Return status:\n");
fprintf(stderr,"dbg2 status: %d\n",status);
}
/* return status */
return(status);
}
/*--------------------------------------------------------------------*/
int mbr_rt_segysegy(int verbose, void *mbio_ptr, void *store_ptr, int *error)
{
char *function_name = "mbr_rt_segysegy";
int status = MB_SUCCESS;
struct mb_io_struct *mb_io_ptr;
struct mbsys_singlebeam_struct *store;
struct mb_segyio_struct *mb_segyio_ptr;
struct mb_segytraceheader_struct traceheader;
float *trace;
int time_j[5];
int i;
/* print input debug statements */
if (verbose >= 2)
{
fprintf(stderr,"\ndbg2 MBIO function <%s> called\n",function_name);
fprintf(stderr,"dbg2 Input arguments:\n");
fprintf(stderr,"dbg2 verbose: %d\n",verbose);
fprintf(stderr,"dbg2 mbio_ptr: %lu\n",(size_t)mbio_ptr);
fprintf(stderr,"dbg2 store_ptr: %lu\n",(size_t)store_ptr);
}
/* get pointers to mbio descriptor and data structures */
mb_io_ptr = (struct mb_io_struct *) mbio_ptr;
store = (struct mbsys_singlebeam_struct *) store_ptr;
mb_segyio_ptr = (struct mb_segyio_struct *) (mb_io_ptr->mbfp);
/* read next data from file */
status = mb_segy_read_trace(verbose, (void *) mb_segyio_ptr,
&traceheader, &trace, error);
/* set error and kind in mb_io_ptr */
mb_io_ptr->new_error = *error;
mb_io_ptr->new_kind = MB_DATA_DATA;
/* translate values to data storage structure */
if (status == MB_SUCCESS
&& store != NULL)
{
store->kind = MB_DATA_DATA;
for (i=0;i<8;i++)
store->survey_id[i] = '\0';
time_j[0] = traceheader.year;
time_j[1] = traceheader.day_of_yr;
time_j[2] = 60 * traceheader.hour + traceheader.min;
time_j[3] = traceheader.sec;
time_j[4] = 1000 * traceheader.mils;
mb_get_itime(verbose,time_j,store->time_i);
mb_get_time(verbose,store->time_i,&store->time_d);
store->timezone = 0;
store->longitude = ((double)traceheader.src_long) / 360000.0;
store->latitude = ((double)traceheader.src_lat) / 360000.0;
store->easting = 0.0;
store->northing = 0.0;
store->heading = traceheader.heading;
store->speed = 0.0;
store->nav_type = 9;
store->nav_quality = 9;
store->roll = 0.0;
store->pitch = 0.0;
store->heave = 0.0;
store->sonar_depth = 0.01 * traceheader.src_depth;
store->rov_pressure = 0.0;
store->rov_altitude = 0.01 * traceheader.src_wbd - 0.01 * traceheader.src_depth;
store->flag = MB_FLAG_NONE;
store->tt = traceheader.wbt_secs;
store->bath = 0.01 * traceheader.src_wbd;
store->tide = 0.0;
store->bath_corr = 99;
store->bath_type = 1;
store->mag_tot_1 = 0.0;
store->mag_tot_2 = 0.0;
store->mag_res = 0.0;
store->mag_res_sensor = 0.0;
store->mag_diurnal = 0.0;
store->mag_altitude = 0.0;
store->gravity = 0.0;
store->eotvos = 0.0;
store->free_air = 0.0;
store->seismic_line = mb_segyio_ptr->fileheader.line;
store->seismic_shot = traceheader.shot_num;
store->seismic_cdp = traceheader.rp_num;
for (i=0;i<MBSYS_SINGLEBEAM_MAXLINE;i++)
store->comment[i] = '\0';
}
/* print output debug statements */
if (verbose >= 2)
{
fprintf(stderr,"\ndbg2 MBIO function <%s> completed\n",function_name);
fprintf(stderr,"dbg2 Return values:\n");
fprintf(stderr,"dbg2 error: %d\n",*error);
fprintf(stderr,"dbg2 Return status:\n");
fprintf(stderr,"dbg2 status: %d\n",status);
}
/* return status */
return(status);
}
