/*--------------------------------------------------------------------*/
int mbr_wt_hsurivax(int verbose, void *mbio_ptr, void *store_ptr, int *error) {
char *function_name = "mbr_wt_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_i[7];
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;
store = (struct mbsys_hsds_struct *)store_ptr;
/* print debug statements */
if (verbose >= 5) {
fprintf(stderr, "\ndbg5 Status at beginning of MBIO function <%s>\n", function_name);
if (store != NULL)
fprintf(stderr, "dbg5 store->kind: %d\n", store->kind);
fprintf(stderr, "dbg5 new_kind: %d\n", mb_io_ptr->new_kind);
fprintf(stderr, "dbg5 new_error: %d\n", mb_io_ptr->new_error);
fprintf(stderr, "dbg5 error: %d\n", *error);
fprintf(stderr, "dbg5 status: %d\n", status);
}
/* first set some plausible amounts for some of the
variables in the HSURICEN record */
data->course = 0;
data->pitch = 0;
data->scale = 100; /* this is a unit scale factor */
data->speed_ref = 'B'; /* assume speed is over the ground */
data->quality = 0;
/* second translate values from hydrosweep data storage structure */
if (store != NULL) {
dataplus->kind = store->kind;
if (store->kind == MB_DATA_DATA) {
/* position */
if (store->lon < -180.0)
store->lon = store->lon + 360.0;
if (store->lon > 180.0)
store->lon = store->lon - 360.0;
data->lon = (int)(0.5 + 10000000.0 * store->lon);
data->lat = (int)(0.5 + 10000000.0 * store->lat);
/* time stamp */
time_i[0] = store->year;
time_i[1] = store->month;
time_i[2] = store->day;
time_i[3] = store->hour;
time_i[4] = store->minute;
time_i[5] = store->second;
time_i[6] = 0;
mb_get_jtime(verbose, time_i, time_j);
data->year = time_j[0];
data->day = time_j[1];
data->min = time_j[2];
data->sec = 100 * time_j[3] + 0.0001 * time_j[4];
/* additional navigation and depths */
data->hdg = 10.0 * store->course_true;
data->course = 10.0 * store->course_ground;
data->speed = 196.36363636363 * store->speed;
data->speed_ref = store->speed_reference[0];
data->pitch = 10.0 * store->pitch;
data->scale = 100 * store->depth_scale;
id = MBSYS_HSDS_BEAMS - 1;
for (i = 0; i < MBSYS_HSDS_BEAMS; i++) {
data->dist[i] = store->distance[i];
data->deph[i] = store->depth[i];
}
/* for (i=0;i<MBSYS_HSDS_BEAMS;i++)
{
data->dist[i] = store->distance[id-i];
data->deph[i] = store->depth[id-i];
}*/
}
/* comment */
else if (store->kind == MB_DATA_COMMENT) {
strcpy(datacomment, "cc");
strncat(datacomment, store->comment, MBSYS_HSDS_MAXLINE);
}
}
/* print debug statements */
if (verbose >= 5) {
fprintf(stderr, "\ndbg5 Ready to write data in MBIO function <%s>\n", function_name);
fprintf(stderr, "dbg5 kind: %d\n", dataplus->kind);
fprintf(stderr, "dbg5 error: %d\n", *error);
fprintf(stderr, "dbg5 status: %d\n", status);
}
/* byte swap the data if necessary */
#ifndef BYTESWAPPED
if (dataplus->kind == MB_DATA_DATA) {
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
/* write next record to file */
if (dataplus->kind == MB_DATA_DATA || dataplus->kind == MB_DATA_COMMENT) {
if ((status = fwrite(data, 1, mb_io_ptr->data_structure_size, mb_io_ptr->mbfp)) == mb_io_ptr->data_structure_size) {
status = MB_SUCCESS;
*error = MB_ERROR_NO_ERROR;
}
else {
status = MB_FAILURE;
*error = MB_ERROR_WRITE_FAIL;
}
}
else {
status = MB_SUCCESS;
*error = MB_ERROR_NO_ERROR;
if (verbose >= 5)
fprintf(stderr, "\ndbg5 No data written in MBIO function <%s>\n", function_name);
}
/* 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) {
char program_name[] = "mbminirovnav";
char help_message[] = " MBminirov reads USBL tracking and CTD day files from the MBARI MiniROV\n"
"\tand produces a single ROV navigation file in one of the standard MBARI\n"
"\tformats handles preprocessing of swath sonar data as part of setting up\n"
"\tan MB-System processing structure for a dataset.\n";
char usage_message[] = "mbminirovnav\n"
"\t--help\n\n"
"\t--input=fileroot\n"
"\t--input-ctd-file=file\n"
"\t--input-dvl-file=file\n"
"\t--input-nav-file=file\n"
"\t--input-rov-file=file\n"
"\t--interpolate-position\n"
"\t--interval=seconds\n"
"\t--output=file\n"
"\t--rov-dive-start=yyyymmddhhmmss\n"
"\t--rov-dive-end=yyyymmddhhmmss\n"
"\t--utm-zone=zone_id/NorS\n"
"\t--verbose\n\n";
extern char *optarg;
int option_index;
int errflg = 0;
int c;
int help = MB_NO;
/* ROV dive time start and end */
int rov_dive_start_time_set = MB_NO;
double rov_dive_start_time_d;
int rov_dive_start_time_i[7];
int rov_dive_end_time_set = MB_NO;
double rov_dive_end_time_d;
int rov_dive_end_time_i[7];
int interpolate_position = MB_NO;
/* MBIO status variables */
int status = MB_SUCCESS;
int verbose = 0;
int error = MB_ERROR_NO_ERROR;
char *message;
int num_nav_alloc = 0;
int num_nav = 0;
double *nav_time_d = NULL;
double *nav_lon = NULL;
double *nav_lat = NULL;
int num_ctd_alloc = 0;
int num_ctd = 0;
double *ctd_time_d = NULL;
double *ctd_depth = NULL;
int num_rov_alloc = 0;
int num_rov = 0;
double *rov_time_d = NULL;
double *rov_heading = NULL;
double *rov_roll = NULL;
double *rov_pitch = NULL;
int num_dvl_alloc = 0;
int num_dvl = 0;
double *dvl_time_d = NULL;
double *dvl_altitude = NULL;
double *dvl_stime = NULL;
double *dvl_vx = NULL;
double *dvl_vy = NULL;
double *dvl_vz = NULL;
double *dvl_status = NULL;
double time_d;
double rawlat, rawlon, dummydouble, ldegrees, lminutes;
double reference_lon = 0.0;
double reference_lat = 0.0;
int utm_zone_set = MB_NO;
int utm_zone = 0;
mb_path projection_id;
void *pjptr = NULL;
char NorS, EorW;
mb_path dummystring;
double ctd_C, ctd_T, ctd_D, ctd_S;
double ctd_O2uM, ctd_O2raw, ctd_DGH_T, ctd_C2_T, ctd_C2_C;
double rov_x, rov_y, rov_z, rov_yaw, rov_magna_amps;
double rov_F1, rov_F2, rov_F3, rov_F4, rov_F5;
double rov_Heading, rov_Pitch, rov_Roll;
double dvl_Altitude, dvl_Stime, dvl_Vx, dvl_Vy, dvl_Vz, dvl_Status;
double start_time_d = 0.0;
double end_time_d = 0.0;
double interval = 1.0;
int onav_time_i[7], onav_time_j[5];
int onav_year, onav_jday, onav_timetag;
double num_output;
double onav_time_d;
double onav_lon;
double onav_lat;
double onav_easting;
double onav_northing;
double onav_depth;
double onav_pressure;
double onav_heading;
double onav_altitude;
double onav_pitch;
double onav_roll;
int onav_position_flag;
int onav_pressure_flag;
int onav_heading_flag;
int onav_altitude_flag;
int onav_attitude_flag;
char buffer[MB_PATH_MAXLINE], *result;
int nrecord;
int nchar, nget, nscan;
int ioutput;
size_t size;
FILE *fp;
int jnav = 0;
int jctd = 0;
int jdvl = 0;
int jrov = 0;
int interp_status = MB_SUCCESS;
int interp_error = MB_ERROR_NO_ERROR;
int proj_status = 0;
/* command line option definitions */
/* mbminirovnav
* --verbose
* --help
*
* --input-nav=file
* --input-ctd=file
* --output=file
*/
static struct option options[] = {{"help", no_argument, NULL, 0},
{"input", required_argument, NULL, 0},
{"input-nav-file", required_argument, NULL, 0},
{"input-ctd-file", required_argument, NULL, 0},
{"input-dvl-file", required_argument, NULL, 0},
{"input-rov-file", required_argument, NULL, 0},
{"interpolate-position", no_argument, NULL, 0},
{"interval", required_argument, NULL, 0},
{"output", required_argument, NULL, 0},
{"rov-dive-start", required_argument, NULL, 0},
{"rov-dive-end", required_argument, NULL, 0},
{"utm-zone", required_argument, NULL, 0},
{"verbose", no_argument, NULL, 0},
{NULL, 0, NULL, 0}};
/* files */
mb_path input_root = "";
mb_path input_nav_file = "";
mb_path input_ctd_file = "";
mb_path input_dvl_file = "";
mb_path input_rov_file = "";
mb_path output_file = "";
/* process argument list */
while ((c = getopt_long(argc, argv, "", options, &option_index)) != -1)
switch (c) {
/* long options all return c=0 */
case 0:
/* verbose */
if (strcmp("verbose", options[option_index].name) == 0) {
verbose++;
}
/* help */
else if (strcmp("help", options[option_index].name) == 0) {
help = MB_YES;
}
/*-------------------------------------------------------
* Define input and output files */
/* input=file */
else if (strcmp("input", options[option_index].name) == 0) {
strcpy(input_root, optarg);
sprintf(input_nav_file, "NAV_%s000000.txt", input_root);
sprintf(input_ctd_file, "CTD_%s000000.txt", input_root);
sprintf(input_dvl_file, "DVL_%s000000.txt", input_root);
sprintf(input_rov_file, "ROV_%s000000.txt", input_root);
sprintf(output_file, "MiniROV_nav_%s.mb165", input_root);
}
/* input-ctd=file */
else if (strcmp("input-ctd-file", options[option_index].name) == 0) {
strcpy(input_ctd_file, optarg);
}
/* input-dvl=file */
else if (strcmp("input-dvl-file", options[option_index].name) == 0) {
strcpy(input_dvl_file, optarg);
}
/* input-nav=file */
else if (strcmp("input-nav-file", options[option_index].name) == 0) {
strcpy(input_nav_file, optarg);
}
/* input-rov=file */
else if (strcmp("input-rov-file", options[option_index].name) == 0) {
strcpy(input_rov_file, optarg);
}
/* output=file */
else if (strcmp("output", options[option_index].name) == 0) {
strcpy(output_file, optarg);
}
/* interval */
else if (strcmp("interval", options[option_index].name) == 0) {
nscan = sscanf(optarg, "%lf", &interval);
if (interval <= 0.0) {
fprintf(stderr,"Program %s command error: %s %s\n\toutput interval reset to 1.0 seconds\n",
program_name, options[option_index].name, optarg);
}
}
/* start rov dive time */
else if (strcmp("rov-dive-start", options[option_index].name) == 0) {
nscan = sscanf(optarg, "%d/%d/%d/%d/%d/%d", &rov_dive_start_time_i[0],
&rov_dive_start_time_i[1], &rov_dive_start_time_i[2],
&rov_dive_start_time_i[3], &rov_dive_start_time_i[4],
&rov_dive_start_time_i[5]);
if (nscan == 6) {
rov_dive_start_time_i[6] = 0;
mb_get_time(verbose, rov_dive_start_time_i, &rov_dive_start_time_d);
rov_dive_start_time_set = MB_YES;
}
else {
fprintf(stderr,"Program %s command error: %s %s\n",
program_name, options[option_index].name, optarg);
}
}
/* end rov dive time */
else if (strcmp("rov-dive-end", options[option_index].name) == 0) {
nscan = sscanf(optarg, "%d/%d/%d/%d/%d/%d", &rov_dive_end_time_i[0],
&rov_dive_end_time_i[1], &rov_dive_end_time_i[2],
&rov_dive_end_time_i[3], &rov_dive_end_time_i[4],
&rov_dive_end_time_i[5]);
if (nscan == 6) {
rov_dive_end_time_i[6] = 0;
mb_get_time(verbose, rov_dive_end_time_i, &rov_dive_end_time_d);
rov_dive_end_time_set = MB_YES;
}
else {
fprintf(stderr,"Program %s command error: %s %s\n",
program_name, options[option_index].name, optarg);
}
}
/* utm zone */
else if (strcmp("utm-zone", options[option_index].name) == 0) {
nscan = sscanf(optarg, "%d/%c", &utm_zone, &NorS);
if (nscan < 2)
nscan = sscanf(optarg, "%d%c", &utm_zone, &NorS);
if (nscan == 2) {
utm_zone_set = MB_YES;
if (NorS == 'N' || NorS == 'n')
sprintf(projection_id, "UTM%2.2dN", utm_zone);
else if (NorS == 'S' || NorS == 's')
sprintf(projection_id, "UTM%2.2dS", utm_zone);
else
sprintf(projection_id, "UTM%2.2dN", utm_zone);
}
else {
fprintf(stderr,"Program %s command error: %s %s\n",
program_name, options[option_index].name, optarg);
}
}
/* interpolate position over gaps in USBL fixes (rather than repeat position values) */
else if (strcmp("interpolate-position", options[option_index].name) == 0) {
interpolate_position = MB_YES;
}
/*----------------------------------------------------------------*/
break;
case '?':
errflg++;
break;
}
/* 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, "Source File Version %s\n", version_id);
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 Version %s\n", version_id);
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 input_root: %s\n", input_root);
fprintf(stderr, "dbg2 input_nav_file: %s\n", input_nav_file);
fprintf(stderr, "dbg2 input_ctd_file: %s\n", input_ctd_file);
fprintf(stderr, "dbg2 input_dvl_file: %s\n", input_dvl_file);
fprintf(stderr, "dbg2 input_rov_file: %s\n", input_rov_file);
fprintf(stderr, "dbg2 output_file: %s\n", output_file);
fprintf(stderr, "dbg2 output time interval: %f\n", interval);
fprintf(stderr, "dbg2 rov_dive_start_time_set: %d\n", rov_dive_start_time_set);
if (rov_dive_start_time_set == MB_YES)
fprintf(stderr, "dbg2 rov_dive_start_time_i: %4.4d/%2.2d/%2.2d %2.2d:%2.2d:%2.2d.%6.6d\n",
rov_dive_start_time_i[0], rov_dive_start_time_i[1], rov_dive_start_time_i[2],
rov_dive_start_time_i[3], rov_dive_start_time_i[4], rov_dive_start_time_i[5],
rov_dive_start_time_i[6]);
fprintf(stderr, "dbg2 rov_dive_end_time_set: %d\n", rov_dive_end_time_set);
if (rov_dive_end_time_set == MB_YES)
fprintf(stderr, "dbg2 rov_dive_end_time_i: %4.4d/%2.2d/%2.2d %2.2d:%2.2d:%2.2d.%6.6d\n",
rov_dive_end_time_i[0], rov_dive_end_time_i[1], rov_dive_end_time_i[2],
rov_dive_end_time_i[3], rov_dive_end_time_i[4], rov_dive_end_time_i[5],
rov_dive_end_time_i[6]);
fprintf(stderr, "dbg2 utm_zone_set: %d\n", utm_zone_set);
if (utm_zone_set == MB_YES) {
fprintf(stderr, "dbg2 utm_zone: %d\n", utm_zone);
fprintf(stderr, "dbg2 projection_id: %s\n", projection_id);
}
fprintf(stderr, "dbg2 interpolate_position: %d\n", interpolate_position);
}
/* print starting verbose */
else if (verbose > 0) {
fprintf(stderr, "\nProgram <%s>\n", program_name);
fprintf(stderr, "Version %s\n", version_id);
fprintf(stderr, "MB-system Version %s\n", MB_VERSION);
fprintf(stderr, "Control Parameters:\n");
fprintf(stderr, " verbose: %d\n", verbose);
fprintf(stderr, " help: %d\n", help);
fprintf(stderr, " input_root: %s\n", input_root);
fprintf(stderr, " input_nav_file: %s\n", input_nav_file);
fprintf(stderr, " input_ctd_file: %s\n", input_ctd_file);
fprintf(stderr, " input_dvl_file: %s\n", input_dvl_file);
fprintf(stderr, " input_rov_file: %s\n", input_rov_file);
fprintf(stderr, " output_file: %s\n", output_file);
fprintf(stderr, " output time interval: %f\n", interval);
fprintf(stderr, " rov_dive_start_time_set: %d\n", rov_dive_start_time_set);
if (rov_dive_start_time_set == MB_YES)
fprintf(stderr, " rov_dive_start_time_i: %4.4d/%2.2d/%2.2d %2.2d:%2.2d:%2.2d.%6.6d\n",
rov_dive_start_time_i[0], rov_dive_start_time_i[1], rov_dive_start_time_i[2],
rov_dive_start_time_i[3], rov_dive_start_time_i[4], rov_dive_start_time_i[5],
rov_dive_start_time_i[6]);
fprintf(stderr, " rov_dive_end_time_set: %d\n", rov_dive_end_time_set);
if (rov_dive_end_time_set == MB_YES)
fprintf(stderr, " rov_dive_end_time_i: %4.4d/%2.2d/%2.2d %2.2d:%2.2d:%2.2d.%6.6d\n",
rov_dive_end_time_i[0], rov_dive_end_time_i[1], rov_dive_end_time_i[2],
rov_dive_end_time_i[3], rov_dive_end_time_i[4], rov_dive_end_time_i[5],
rov_dive_end_time_i[6]);
fprintf(stderr, " utm_zone_set: %d\n", utm_zone_set);
if (utm_zone_set == MB_YES) {
fprintf(stderr, " utm_zone: %d\n", utm_zone);
fprintf(stderr, " projection_id: %s\n", projection_id);
}
fprintf(stderr, " interpolate_position: %d\n", interpolate_position);
}
/* 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);
}
/*-------------------------------------------------------------------*/
/* load input nav data */
/* count the records */
error = MB_ERROR_NO_ERROR;
nrecord = 0;
nchar = MB_PATH_MAXLINE - 1;
if ((fp = fopen(input_nav_file, "r")) != NULL) {
/* loop over reading the records */
while ((result = fgets(buffer, nchar, fp)) == buffer)
if (buffer[0] != '#' && strlen(buffer) > 5)
nrecord++;
/* close the file */
fclose(fp);
fp = NULL;
}
else {
error = MB_ERROR_OPEN_FAIL;
status = MB_FAILURE;
}
/* allocate memory if necessary */
if (status == MB_SUCCESS && num_nav_alloc < nrecord) {
size = nrecord * sizeof(double);
status = mb_mallocd(verbose, __FILE__, __LINE__, size, (void **)&nav_time_d, &error);
if (status == MB_SUCCESS)
status = mb_mallocd(verbose, __FILE__, __LINE__, size, (void **)&nav_lon, &error);
if (status == MB_SUCCESS)
status = mb_mallocd(verbose, __FILE__, __LINE__, size, (void **)&nav_lat, &error);
if (status == MB_SUCCESS)
num_nav_alloc = nrecord;
}
/* read the records */
if (status == MB_SUCCESS) {
nrecord = 0;
if ((fp = fopen(input_nav_file, "r")) == NULL) {
error = MB_ERROR_OPEN_FAIL;
status = MB_FAILURE;
}
else {
/* loop over reading the records - handle the different formats */
while ((result = fgets(buffer, nchar, fp)) == buffer) {
nget = sscanf(buffer, "%lf,$GPGLL,%lf,%c,%lf,%c,%lf,%s",
&time_d, &rawlat, &NorS, &rawlon, &EorW, &dummydouble, dummystring);
if (nget == 7) {
if (start_time_d <= 0.0)
start_time_d = time_d;
if (time_d > 0.0 && time_d < start_time_d)
start_time_d = time_d;
if (time_d > end_time_d)
end_time_d = time_d;
nav_time_d[num_nav] = time_d;
ldegrees = floor(rawlat / 100.0);
lminutes = rawlat - ldegrees * 100;
nav_lat[num_nav] = ldegrees + (lminutes / 60.0);
if (NorS == 'S')
nav_lat[num_nav] *= -1;
ldegrees = floor(rawlon / 100.0);
lminutes = rawlon - ldegrees * 100;
nav_lon[num_nav] = ldegrees + (lminutes / 60.0);
if (EorW == 'W')
nav_lon[num_nav] *= -1;
if (interpolate_position == MB_NO
|| num_nav <= 1
|| nav_lon[num_nav] != nav_lon[num_nav-1]
|| nav_lat[num_nav] != nav_lat[num_nav-1]) {
reference_lon += nav_lon[num_nav];
reference_lat += nav_lat[num_nav];
if (num_nav < num_nav_alloc)
num_nav++;
}
}
}
/* close the file */
fclose(fp);
/* calculate average longitude for UTM zone calcuation */
if (num_nav > 0) {
reference_lon /= num_nav;
reference_lat /= num_nav;
}
if (reference_lon < 180.0)
reference_lon += 360.0;
if (reference_lon >= 180.0)
reference_lon -= 360.0;
}
}
/*-------------------------------------------------------------------*/
/* load input ctd data */
/* count the records */
error = MB_ERROR_NO_ERROR;
nrecord = 0;
nchar = MB_PATH_MAXLINE - 1;
if ((fp = fopen(input_ctd_file, "r")) != NULL) {
/* loop over reading the records */
while ((result = fgets(buffer, nchar, fp)) == buffer)
if (buffer[0] != '#' && strlen(buffer) > 5)
nrecord++;
/* close the file */
fclose(fp);
fp = NULL;
}
else {
error = MB_ERROR_OPEN_FAIL;
status = MB_FAILURE;
}
/* allocate memory if necessary */
if (status == MB_SUCCESS && num_ctd_alloc < nrecord) {
size = nrecord * sizeof(double);
status = mb_mallocd(verbose, __FILE__, __LINE__, size, (void **)&ctd_time_d, &error);
if (status == MB_SUCCESS)
status = mb_mallocd(verbose, __FILE__, __LINE__, size, (void **)&ctd_depth, &error);
if (status == MB_SUCCESS)
num_ctd_alloc = nrecord;
}
/* read the records */
if (status == MB_SUCCESS) {
nrecord = 0;
if ((fp = fopen(input_ctd_file, "r")) == NULL) {
error = MB_ERROR_OPEN_FAIL;
status = MB_FAILURE;
}
else {
/* loop over reading the records - handle the different formats */
while ((result = fgets(buffer, nchar, fp)) == buffer) {
nget = sscanf(buffer, "%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf",
&time_d, &ctd_C, &ctd_T, &ctd_D, &ctd_S,
&ctd_O2uM, &ctd_O2raw, &ctd_DGH_T, &ctd_C2_T, &ctd_C2_C);
if (nget == 10) {
if (start_time_d <= 0.0)
start_time_d = time_d;
if (time_d > 0.0 && time_d < start_time_d)
start_time_d = time_d;
if (time_d > end_time_d)
end_time_d = time_d;
ctd_time_d[num_ctd] = time_d;
ctd_depth[num_ctd] = ctd_D;
if (num_ctd < num_ctd_alloc)
num_ctd++;
}
}
/* close the file */
fclose(fp);
}
}
/*-------------------------------------------------------------------*/
/* load input rov data */
/* count the records */
error = MB_ERROR_NO_ERROR;
nrecord = 0;
nchar = MB_PATH_MAXLINE - 1;
if ((fp = fopen(input_rov_file, "r")) != NULL) {
/* loop over reading the records */
while ((result = fgets(buffer, nchar, fp)) == buffer)
if (buffer[0] != '#' && strlen(buffer) > 5)
nrecord++;
/* close the file */
fclose(fp);
fp = NULL;
}
else {
error = MB_ERROR_OPEN_FAIL;
status = MB_FAILURE;
}
/* allocate memory if necessary */
if (status == MB_SUCCESS && num_rov_alloc < nrecord) {
size = nrecord * sizeof(double);
status = mb_mallocd(verbose, __FILE__, __LINE__, size, (void **)&rov_time_d, &error);
if (status == MB_SUCCESS)
status = mb_mallocd(verbose, __FILE__, __LINE__, size, (void **)&rov_heading, &error);
if (status == MB_SUCCESS)
status = mb_mallocd(verbose, __FILE__, __LINE__, size, (void **)&rov_roll, &error);
if (status == MB_SUCCESS)
status = mb_mallocd(verbose, __FILE__, __LINE__, size, (void **)&rov_pitch, &error);
if (status == MB_SUCCESS)
num_rov_alloc = nrecord;
}
/* read the records */
if (status == MB_SUCCESS) {
nrecord = 0;
if ((fp = fopen(input_rov_file, "r")) == NULL) {
error = MB_ERROR_OPEN_FAIL;
status = MB_FAILURE;
}
else {
/* loop over reading the records - handle the different formats */
while ((result = fgets(buffer, nchar, fp)) == buffer) {
nget = sscanf(buffer, "%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf",
&time_d, &rov_x, &rov_y, &rov_z, &rov_yaw, &rov_magna_amps,
&rov_F1, &rov_F2, &rov_F3, &rov_F4, &rov_F5,
&rov_Heading, &rov_Pitch, &rov_Roll);
if (nget == 14) {
if (start_time_d <= 0.0)
start_time_d = time_d;
if (time_d > 0.0 && time_d < start_time_d)
start_time_d = time_d;
if (time_d > end_time_d)
end_time_d = time_d;
rov_time_d[num_rov] = time_d;
rov_heading[num_rov] = rov_Heading;
rov_roll[num_rov] = rov_Roll;
rov_pitch[num_rov] = rov_Pitch;
if (num_rov < num_rov_alloc)
num_rov++;
}
}
/* close the file */
fclose(fp);
}
}
/*-------------------------------------------------------------------*/
/* load input dvl data */
/* count the records */
error = MB_ERROR_NO_ERROR;
nrecord = 0;
nchar = MB_PATH_MAXLINE - 1;
if ((fp = fopen(input_dvl_file, "r")) != NULL) {
/* loop over reading the records */
while ((result = fgets(buffer, nchar, fp)) == buffer)
if (buffer[0] != '#' && strlen(buffer) > 5)
nrecord++;
/* close the file */
fclose(fp);
fp = NULL;
}
else {
error = MB_ERROR_OPEN_FAIL;
status = MB_FAILURE;
}
/* allocate memory if necessary */
if (status == MB_SUCCESS && num_dvl_alloc < nrecord) {
size = nrecord * sizeof(double);
status = mb_mallocd(verbose, __FILE__, __LINE__, size, (void **)&dvl_time_d, &error);
if (status == MB_SUCCESS)
status = mb_mallocd(verbose, __FILE__, __LINE__, size, (void **)&dvl_altitude, &error);
if (status == MB_SUCCESS)
status = mb_mallocd(verbose, __FILE__, __LINE__, size, (void **)&dvl_stime, &error);
if (status == MB_SUCCESS)
status = mb_mallocd(verbose, __FILE__, __LINE__, size, (void **)&dvl_vx, &error);
if (status == MB_SUCCESS)
status = mb_mallocd(verbose, __FILE__, __LINE__, size, (void **)&dvl_vy, &error);
if (status == MB_SUCCESS)
status = mb_mallocd(verbose, __FILE__, __LINE__, size, (void **)&dvl_vz, &error);
if (status == MB_SUCCESS)
status = mb_mallocd(verbose, __FILE__, __LINE__, size, (void **)&dvl_status, &error);
if (status == MB_SUCCESS)
num_dvl_alloc = nrecord;
}
/* read the records */
if (status == MB_SUCCESS) {
nrecord = 0;
if ((fp = fopen(input_dvl_file, "r")) == NULL) {
error = MB_ERROR_OPEN_FAIL;
status = MB_FAILURE;
}
else {
/* loop over reading the records - handle the different formats */
while ((result = fgets(buffer, nchar, fp)) == buffer) {
nget = sscanf(buffer, "%lf,%lf,%lf,%lf,%lf,%lf,%lf",
&time_d, &dvl_Altitude, &dvl_Stime, &dvl_Vx, &dvl_Vy, &dvl_Vz, &dvl_Status);
if (nget == 7) {
if (start_time_d <= 0.0)
start_time_d = time_d;
if (time_d > 0.0 && time_d < start_time_d)
start_time_d = time_d;
if (time_d > end_time_d)
end_time_d = time_d;
dvl_time_d[num_dvl] = time_d;
dvl_altitude[num_dvl] = dvl_Altitude;
dvl_stime[num_dvl] = dvl_Stime;
dvl_vx[num_dvl] = dvl_Vx;
dvl_vy[num_dvl] = dvl_Vy;
dvl_vz[num_dvl] = dvl_Vz;
dvl_status[num_dvl] = dvl_Status;
if (num_dvl < num_dvl_alloc)
num_dvl++;
}
}
/* close the file */
fclose(fp);
}
}
/*-------------------------------------------------------------------*/
fprintf(stderr,"\nProgram %s\n", program_name);
fprintf(stderr,"Input data loaded:\n\tNavigation: %d\n\tCTD: %d\n\tAttitude:%d\n\tDVL: %d\n\n",
num_nav, num_ctd, num_rov, num_dvl);
/* get time range of output based on max bounds of any input data
or use the specified time interval */
if (rov_dive_start_time_set == MB_YES) {
start_time_d = rov_dive_start_time_d;
}
if (rov_dive_end_time_set == MB_YES) {
end_time_d = rov_dive_end_time_d;
}
start_time_d = floor(start_time_d);
num_output = (int)(ceil((end_time_d - start_time_d) / interval));
/* get UTM projection for easting and northing fields */
if (utm_zone_set == MB_YES) {
if (utm_zone < 0)
sprintf(projection_id, "UTM%2.2dS", abs(utm_zone));
else
sprintf(projection_id, "UTM%2.2dN", utm_zone);
}
else {
utm_zone = (int)(((reference_lon + 183.0) / 6.0) + 0.5);
if (reference_lat >= 0.0)
sprintf(projection_id, "UTM%2.2dN", utm_zone);
else
sprintf(projection_id, "UTM%2.2dS", utm_zone);
}
proj_status = mb_proj_init(verbose, projection_id, &(pjptr), &error);
/* write the MiniROV navigation data */
if (status == MB_SUCCESS) {
if ((fp = fopen(output_file, "w")) == NULL) {
error = MB_ERROR_OPEN_FAIL;
status = MB_FAILURE;
}
else {
/* loop over 1 second intervals from start time to end time */
for (ioutput=0;ioutput<num_output;ioutput++) {
/* set the output time */
onav_time_d = start_time_d + ioutput * interval;
mb_get_date(verbose, onav_time_d, onav_time_i);
onav_year = onav_time_i[0];
onav_timetag = 10000 * onav_time_i[3] + 100 * onav_time_i[4] + onav_time_i[5];
mb_get_jtime(verbose, onav_time_i, onav_time_j);
onav_jday = onav_time_j[1];
/* interpolate values onto the target time */
interp_status = mb_linear_interp_longitude(verbose, nav_time_d - 1, nav_lon - 1, num_nav, onav_time_d, &onav_lon, &jnav, &interp_error);
interp_status = mb_linear_interp_latitude(verbose, nav_time_d - 1, nav_lat - 1, num_nav, onav_time_d, &onav_lat, &jnav, &interp_error);
interp_status = mb_linear_interp(verbose, ctd_time_d - 1, ctd_depth - 1, num_ctd, onav_time_d, &onav_depth, &jctd, &interp_error);
interp_status = mb_linear_interp(verbose, dvl_time_d - 1, dvl_altitude - 1, num_dvl, onav_time_d, &onav_altitude, &jdvl, &interp_error);
interp_status = mb_linear_interp_heading(verbose, rov_time_d - 1, rov_heading - 1, num_rov, onav_time_d, &onav_heading, &jrov, &interp_error);
interp_status = mb_linear_interp(verbose, rov_time_d - 1, rov_roll - 1, num_rov, onav_time_d, &onav_roll, &jrov, &interp_error);
interp_status = mb_linear_interp(verbose, rov_time_d - 1, rov_pitch - 1, num_rov, onav_time_d, &onav_pitch, &jrov, &interp_error);
if (onav_lon != 0.0 && onav_lat != 0.0)
onav_position_flag = MB_YES;
else
onav_position_flag = MB_NO;
if (onav_lon != 0.0 && onav_lat != 0.0)
onav_pressure_flag = MB_YES;
else
onav_pressure_flag = MB_NO;
if (onav_lon != 0.0 && onav_lat != 0.0)
onav_heading_flag = MB_YES;
else
onav_heading_flag = MB_NO;
if (onav_lon != 0.0 && onav_lat != 0.0)
onav_altitude_flag = MB_YES;
else
onav_altitude_flag = MB_NO;
if (onav_lon != 0.0 && onav_lat != 0.0)
onav_attitude_flag = MB_YES;
else
onav_attitude_flag = MB_NO;
/* get UTM eastings and northings */
mb_proj_forward(verbose, pjptr, onav_lon, onav_lat, &onav_easting, &onav_northing, &error);
/* get pressure from CTD depth */
onav_pressure = onav_depth * (1.0052405 * (1 + 5.28E-3 * sin(DTR * onav_lat) * sin(DTR * onav_lat)));
/* print output debug statements */
if (verbose >= 4) {
fprintf(stderr, "\ndbg4 Data to be written in MBIO function <%s>\n", program_name);
fprintf(stderr, "dbg4 Values,read:\n");
fprintf(stderr, "dbg4 onav_time_d: %f\n", onav_time_d);
fprintf(stderr, "dbg4 onav_lat: %f\n", onav_lat);
fprintf(stderr, "dbg4 onav_lon: %f\n", onav_lon);
fprintf(stderr, "dbg4 onav_easting: %f\n", onav_easting);
fprintf(stderr, "dbg4 onav_northing: %f\n", onav_northing);
fprintf(stderr, "dbg4 onav_depth: %f\n", onav_depth);
fprintf(stderr, "dbg4 onav_pressure: %f\n", onav_pressure);
fprintf(stderr, "dbg4 onav_heading: %f\n", onav_heading);
fprintf(stderr, "dbg4 onav_altitude: %f\n", onav_altitude);
fprintf(stderr, "dbg4 onav_pitch: %f\n", onav_pitch);
fprintf(stderr, "dbg4 onav_roll: %f\n", onav_roll);
fprintf(stderr, "dbg4 onav_position_flag: %d\n", onav_position_flag);
fprintf(stderr, "dbg4 onav_pressure_flag: %d\n", onav_pressure_flag);
fprintf(stderr, "dbg4 onav_heading_flag: %d\n", onav_heading_flag);
fprintf(stderr, "dbg4 onav_altitude_flag: %d\n", onav_altitude_flag);
fprintf(stderr, "dbg4 onav_attitude_flag: %d\n", onav_attitude_flag);
fprintf(stderr, "dbg4 error: %d\n", error);
fprintf(stderr, "dbg4 status: %d\n", status);
}
/* write the record */
fprintf(fp, "%4.4d,%3.3d,%6.6d,%9.0f,%10.6f,%11.6f,%7.0f,%7.0f,%7.2f,%5.1f,%6.2f,%4.1f,%4.1f,%d,%d,%d,%d,%d\n",
onav_year, onav_jday, onav_timetag, onav_time_d,
onav_lat, onav_lon, onav_easting, onav_northing,
onav_pressure, onav_heading, onav_altitude, onav_pitch, onav_roll,
onav_position_flag, onav_pressure_flag, onav_heading_flag,
onav_altitude_flag, onav_attitude_flag);
}
/* close the file */
fclose(fp);
}
}
/*-------------------------------------------------------------------*/
proj_status = mb_proj_free(verbose, &(pjptr), &error);
mb_freed(verbose, __FILE__, __LINE__, (void **)&nav_time_d, &error);
mb_freed(verbose, __FILE__, __LINE__, (void **)&nav_lon, &error);
mb_freed(verbose, __FILE__, __LINE__, (void **)&nav_lat, &error);
mb_freed(verbose, __FILE__, __LINE__, (void **)&ctd_time_d, &error);
mb_freed(verbose, __FILE__, __LINE__, (void **)&ctd_depth, &error);
mb_freed(verbose, __FILE__, __LINE__, (void **)&rov_time_d, &error);
mb_freed(verbose, __FILE__, __LINE__, (void **)&rov_heading, &error);
mb_freed(verbose, __FILE__, __LINE__, (void **)&rov_roll, &error);
mb_freed(verbose, __FILE__, __LINE__, (void **)&rov_pitch, &error);
mb_freed(verbose, __FILE__, __LINE__, (void **)&dvl_time_d, &error);
mb_freed(verbose, __FILE__, __LINE__, (void **)&dvl_altitude, &error);
mb_freed(verbose, __FILE__, __LINE__, (void **)&dvl_stime, &error);
mb_freed(verbose, __FILE__, __LINE__, (void **)&dvl_vx, &error);
mb_freed(verbose, __FILE__, __LINE__, (void **)&dvl_vy, &error);
mb_freed(verbose, __FILE__, __LINE__, (void **)&dvl_vz, &error);
mb_freed(verbose, __FILE__, __LINE__, (void **)&dvl_status, &error);
exit(0);
/*-------------------------------------------------------------------*/
}
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 mbr_wt_em12darw(int verbose, void *mbio_ptr, void *store_ptr, int *error) {
char *function_name = "mbr_wt_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_i[7];
int time_j[5];
int year;
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;
/* print debug statements */
if (verbose >= 5) {
fprintf(stderr, "\ndbg5 Status at beginning of MBIO function <%s>\n", function_name);
fprintf(stderr, "dbg5 store->kind: %d\n", store->kind);
fprintf(stderr, "dbg5 error: %d\n", *error);
fprintf(stderr, "dbg5 status: %d\n", status);
}
/* translate values from em12 data storage structure */
if (store->kind == MB_DATA_DATA) {
/* record type */
data->func = 150;
/* time */
time_i[0] = store->year;
time_i[1] = store->month;
time_i[2] = store->day;
time_i[3] = store->hour;
time_i[4] = store->minute;
time_i[5] = store->second;
time_i[6] = store->centisecond;
mb_get_jtime(verbose, time_i, time_j);
mb_unfix_y2k(verbose, time_j[0], &year);
data->year = (short)year;
data->jday = time_j[1];
data->minute = time_j[2];
data->secs = 100 * time_j[3] + 0.0001 * time_j[4];
/* navigation */
data->utm_zone = store->utm_zone;
data->utm_merd = store->utm_zone_lon;
data->corflag = store->utm_system;
data->posq = store->pos_quality;
data->speed = store->speed;
if (data->corflag == 0) {
data->latitude = store->pos_latitude;
data->longitude = store->pos_longitude;
}
else {
data->latitude = store->utm_northing;
data->longitude = store->utm_easting;
}
/* deal with survey data
in secondary data structure */
if (store->ping != NULL) {
/* get data structure pointer */
ping = (struct mbsys_simrad_survey_struct *)store->ping;
/* copy survey data */
data->latitude = ping->latitude;
data->longitude = ping->longitude;
data->pingno = ping->ping_number;
data->mode = ping->bath_res;
data->depthl = ping->keel_depth;
data->gyro = 0.1 * ping->heading;
data->roll = 0.01 * ping->roll;
data->pitch = 0.01 * ping->pitch;
data->heave = 0.01 * ping->ping_heave;
data->sndval = 0.1 * ping->sound_vel;
for (i = 0; i < ping->beams_bath; i++) {
if (ping->beamflag[i] == MB_FLAG_NULL)
data->depth[i] = 0;
else if (!mb_beam_ok(ping->beamflag[i]))
data->depth[i] = -ping->bath[i];
else
data->depth[i] = ping->bath[i];
data->distacr[i] = ping->bath_acrosstrack[i];
data->distalo[i] = ping->bath_alongtrack[i];
data->range[i] = ping->tt[i];
data->refl[i] = (short int)ping->amp[i];
data->beamq[i] = (short int)ping->quality[i];
}
}
}
/* comment */
else if (store->kind == MB_DATA_COMMENT) {
data->func = 100;
strncpy(datacomment, store->comment, MBSYS_SIMRAD_COMMENT_LENGTH);
}
/* print debug statements */
if (verbose >= 5) {
fprintf(stderr, "\ndbg5 Ready to write data in MBIO function <%s>\n", function_name);
fprintf(stderr, "dbg5 store->kind: %d\n", store->kind);
fprintf(stderr, "dbg5 error: %d\n", *error);
fprintf(stderr, "dbg5 status: %d\n", status);
}
/* print debug statements */
if (verbose >= 4 && status == MB_SUCCESS) {
fprintf(stderr, "\ndbg4 Data to be written by MBIO function <%s>\n", function_name);
fprintf(stderr, "dbg4 Status values:\n");
fprintf(stderr, "dbg4 store->kind:%d\n", store->kind);
fprintf(stderr, "dbg4 error: %d\n", *error);
fprintf(stderr, "dbg4 status: %d\n", status);
if (store->kind == MB_DATA_DATA) {
fprintf(stderr, "dbg4 Survey values:\n");
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 if (store->kind == MB_DATA_COMMENT) {
fprintf(stderr, "dbg4 Comment:\n");
fprintf(stderr, "dbg4 comment: %s\n", datacomment);
}
}
/* deal with comment */
if (status == MB_SUCCESS && store->kind == MB_DATA_COMMENT) {
index = 0;
for (i = 0; i < MBF_EM12DARW_RECORD_LENGTH; i++)
line[i] = 0;
mb_put_binary_short(MB_NO, data->func, &line[0]);
index += 2;
strncpy(datacomment, store->comment, MBSYS_SIMRAD_COMMENT_LENGTH);
}
/* deal with data */
else if (status == MB_SUCCESS && store->kind == MB_DATA_DATA) {
index = 0;
mb_put_binary_short(MB_NO, data->func, &line[0]);
index += 2;
mb_put_binary_short(MB_NO, data->year, &line[index]);
index += 2;
mb_put_binary_short(MB_NO, data->jday, &line[index]);
index += 2;
mb_put_binary_short(MB_NO, data->minute, &line[index]);
index += 2;
mb_put_binary_short(MB_NO, data->secs, &line[index]);
index += 8;
mb_put_binary_double(MB_NO, data->latitude, &line[index]);
index += 8;
mb_put_binary_double(MB_NO, data->longitude, &line[index]);
index += 8;
mb_put_binary_short(MB_NO, data->corflag, &line[index]);
index += 4;
mb_put_binary_float(MB_NO, data->utm_merd, &line[index]);
index += 4;
mb_put_binary_short(MB_NO, data->utm_zone, &line[index]);
index += 2;
mb_put_binary_short(MB_NO, data->posq, &line[index]);
index += 2;
mb_put_binary_int(MB_NO, data->pingno, &line[index]);
index += 4;
mb_put_binary_short(MB_NO, data->mode, &line[index]);
index += 4;
mb_put_binary_float(MB_NO, data->depthl, &line[index]);
index += 4;
mb_put_binary_float(MB_NO, data->speed, &line[index]);
index += 4;
mb_put_binary_float(MB_NO, data->gyro, &line[index]);
index += 4;
mb_put_binary_float(MB_NO, data->roll, &line[index]);
index += 4;
mb_put_binary_float(MB_NO, data->pitch, &line[index]);
index += 4;
mb_put_binary_float(MB_NO, data->heave, &line[index]);
index += 4;
mb_put_binary_float(MB_NO, data->sndval, &line[index]);
index += 4;
for (i = 0; i < MBF_EM12DARW_BEAMS; i++) {
mb_put_binary_short(MB_NO, data->depth[i], &line[index]);
index += 2;
}
for (i = 0; i < MBF_EM12DARW_BEAMS; i++) {
mb_put_binary_short(MB_NO, data->distacr[i], &line[index]);
index += 2;
}
for (i = 0; i < MBF_EM12DARW_BEAMS; i++) {
mb_put_binary_short(MB_NO, data->distalo[i], &line[index]);
index += 2;
}
for (i = 0; i < MBF_EM12DARW_BEAMS; i++) {
mb_put_binary_short(MB_NO, data->range[i], &line[index]);
index += 2;
}
for (i = 0; i < MBF_EM12DARW_BEAMS; i++) {
mb_put_binary_short(MB_NO, data->refl[i], &line[index]);
index += 2;
}
for (i = 0; i < MBF_EM12DARW_BEAMS; i++) {
mb_put_binary_short(MB_NO, data->beamq[i], &line[index]);
index += 2;
}
}
/* write next record to file */
if (store->kind == MB_DATA_DATA || store->kind == MB_DATA_COMMENT) {
if ((status = fwrite(line, 1, MBF_EM12DARW_RECORD_LENGTH, mb_io_ptr->mbfp)) == MBF_EM12DARW_RECORD_LENGTH) {
status = MB_SUCCESS;
*error = MB_ERROR_NO_ERROR;
}
else {
status = MB_FAILURE;
*error = MB_ERROR_WRITE_FAIL;
}
}
else {
status = MB_SUCCESS;
*error = MB_ERROR_NO_ERROR;
if (verbose >= 5)
fprintf(stderr, "\ndbg5 No data written in MBIO function <%s>\n", function_name);
}
/* 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 main (int argc, char **argv)
{
char program_name[] = "MBauvloglist";
char help_message[] = "MBauvloglist lists table data from an MBARI AUV mission log file.";
char usage_message[] = "MBauvloglist -Ifile [-Fprintformat -Llonflip -Olist -H -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 = NULL;
/* MBIO read control parameters */
int pings;
int format;
int lonflip;
double bounds[4];
int btime_i[7];
int etime_i[7];
double speedmin;
double timegap;
/* auv log data */
FILE *fp;
char file[MB_PATH_MAXLINE];
struct field
{
int type;
int size;
int index;
char name[MB_PATH_MAXLINE];
char format[MB_PATH_MAXLINE];
char description[MB_PATH_MAXLINE];
char units[MB_PATH_MAXLINE];
double scale;
};
struct printfield
{
char name[MB_PATH_MAXLINE];
int index;
int formatset;
char format[MB_PATH_MAXLINE];
};
int nfields = 0;
struct field fields[NFIELDSMAX];
int nprintfields = 0;
struct printfield printfields[NFIELDSMAX];
int nrecord;
int recordsize;
int printheader = MB_NO;
int angles_in_degrees = MB_NO;
/* navigation, heading, attitude data for merging in fnv format */
int nav_merge = MB_NO;
mb_path nav_file;
int nav_num = 0;
int nav_alloc = 0;
double *nav_time_d = NULL;
double *nav_navlon = NULL;
double *nav_navlat = NULL;
double *nav_heading = NULL;
double *nav_speed = NULL;
double *nav_sensordepth = NULL;
double *nav_roll = NULL;
double *nav_pitch = NULL;
double *nav_heave = NULL;
/* output control */
int output_mode = OUTPUT_MODE_TAB;
double time_d = 0.0;
int time_i[7];
int time_j[5];
char buffer[MB_PATH_MAXLINE];
char type[MB_PATH_MAXLINE];
char printformat[MB_PATH_MAXLINE];
char *result;
int nscan;
double dvalue;
double sec;
int ivalue;
int index;
int jinterp = 0;
int nchar;
int nget;
int nav_ok;
int interp_status;
int i, j;
/* get current default values */
status = mb_defaults(verbose,&format,&pings,&lonflip,bounds,
btime_i,etime_i,&speedmin,&timegap);
/* set file to null */
file[0] = '\0';
nav_file[0] = '\0';
strcpy(printformat, "default");
/* process argument list */
while ((c = getopt(argc, argv, "F:f:I:i:L:l:M:m:N:n:O:o:PpSsVvWwHh")) != -1)
switch (c)
{
case 'H':
case 'h':
help++;
break;
case 'V':
case 'v':
verbose++;
break;
case 'F':
case 'f':
sscanf (optarg,"%s", printformat);
flag++;
break;
case 'I':
case 'i':
sscanf (optarg,"%s", file);
flag++;
break;
case 'L':
case 'l':
sscanf (optarg,"%d", &lonflip);
flag++;
break;
case 'M':
case 'm':
sscanf (optarg,"%d", &output_mode);
flag++;
break;
case 'N':
case 'n':
sscanf (optarg,"%s", nav_file);
nav_merge = MB_YES;
flag++;
break;
case 'O':
case 'o':
nscan = sscanf (optarg,"%s", printfields[nprintfields].name);
if (strlen(printformat) > 0 && strcmp(printformat, "default") != 0)
{
printfields[nprintfields].formatset = MB_YES;
strcpy(printfields[nprintfields].format,printformat);
}
else
{
printfields[nprintfields].formatset = MB_NO;
strcpy(printfields[nprintfields].format,"");
}
printfields[nprintfields].index = -1;
nprintfields++;
flag++;
break;
case 'P':
case 'p':
printheader = MB_YES;
flag++;
break;
case 'S':
case 's':
angles_in_degrees = MB_YES;
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,"Version %s\n",rcs_id);
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 Version %s\n",rcs_id);
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 lonflip: %d\n",lonflip);
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 file: %s\n",file);
fprintf(stderr,"dbg2 nav_file: %s\n",nav_file);
fprintf(stderr,"dbg2 output_mode: %d\n",output_mode);
fprintf(stderr,"dbg2 printheader: %d\n",printheader);
fprintf(stderr,"dbg2 angles_in_degrees:%d\n",angles_in_degrees);
fprintf(stderr,"dbg2 nprintfields: %d\n",nprintfields);
for (i=0;i<nprintfields;i++)
fprintf(stderr,"dbg2 printfields[%d]: %s %d %s\n",
i,printfields[i].name,
printfields[i].formatset,
printfields[i].format);
}
/* 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);
}
/* if nav merging to be done get nav */
if (nav_merge == MB_YES && strlen(nav_file) > 0)
{
/* count the data points in the nav file */
nav_num = 0;
nchar = MB_PATH_MAXLINE-1;
if ((fp = fopen(nav_file, "r")) == NULL)
{
error = MB_ERROR_OPEN_FAIL;
fprintf(stderr,"\nUnable to Open Navigation File <%s> for reading\n",nav_file);
fprintf(stderr,"\nProgram <%s> Terminated\n",
program_name);
exit(error);
}
while ((result = fgets(buffer,nchar,fp)) == buffer)
nav_num++;
fclose(fp);
/* allocate arrays for nav */
if (nav_num > 0)
{
nav_alloc = nav_num;
status = mb_mallocd(verbose,__FILE__,__LINE__,nav_alloc*sizeof(double),(void **)&nav_time_d,&error);
status = mb_mallocd(verbose,__FILE__,__LINE__,nav_alloc*sizeof(double),(void **)&nav_navlon,&error);
status = mb_mallocd(verbose,__FILE__,__LINE__,nav_alloc*sizeof(double),(void **)&nav_navlat,&error);
status = mb_mallocd(verbose,__FILE__,__LINE__,nav_alloc*sizeof(double),(void **)&nav_heading,&error);
status = mb_mallocd(verbose,__FILE__,__LINE__,nav_alloc*sizeof(double),(void **)&nav_speed,&error);
status = mb_mallocd(verbose,__FILE__,__LINE__,nav_alloc*sizeof(double),(void **)&nav_sensordepth,&error);
status = mb_mallocd(verbose,__FILE__,__LINE__,nav_alloc*sizeof(double),(void **)&nav_roll,&error);
status = mb_mallocd(verbose,__FILE__,__LINE__,nav_alloc*sizeof(double),(void **)&nav_pitch,&error);
status = mb_mallocd(verbose,__FILE__,__LINE__,nav_alloc*sizeof(double),(void **)&nav_heave,&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 the data points in the nav file */
nav_num = 0;
if ((fp = fopen(nav_file, "r")) == NULL)
{
error = MB_ERROR_OPEN_FAIL;
fprintf(stderr,"\nUnable to Open navigation File <%s> for reading\n",nav_file);
fprintf(stderr,"\nProgram <%s> Terminated\n",
program_name);
exit(error);
}
while ((result = fgets(buffer,nchar,fp)) == buffer)
{
nget = sscanf(buffer,"%d %d %d %d %d %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf",
&time_i[0],&time_i[1],&time_i[2],
&time_i[3],&time_i[4],&sec,
&nav_time_d[nav_num],
&nav_navlon[nav_num],&nav_navlat[nav_num],
&nav_heading[nav_num],&nav_speed[nav_num],&nav_sensordepth[nav_num],
&nav_roll[nav_num],&nav_pitch[nav_num],&nav_heave[nav_num]);
if (nget >= 9)
nav_ok = MB_YES;
else
nav_ok = MB_NO;
if (nav_num > 0 && nav_time_d[nav_num] <= nav_time_d[nav_num-1])
nav_ok = MB_NO;
if (nav_ok == MB_YES)
nav_num++;
}
fclose(fp);
}
fprintf(stderr,"%d %d records read from nav file %s\n",nav_alloc,nav_num,nav_file);
/* open the input file */
if ((fp = fopen(file, "r")) == NULL)
{
error = MB_ERROR_OPEN_FAIL;
status = MB_FAILURE;
fprintf(stderr,"\nUnable to open log file <%s> for reading\n",file);
exit(status);
}
nfields = 0;
recordsize = 0;
while ((result = fgets(buffer,MB_PATH_MAXLINE,fp)) == buffer
&& strncmp(buffer, "# begin",7) != 0)
{
nscan = sscanf(buffer, "# %s %s %s",
type,
fields[nfields].name,
fields[nfields].format);
if (nscan == 2)
{
if (printheader == MB_YES)
fprintf(stdout,"# csv %s\n", fields[nfields].name);
}
else if (nscan == 3)
{
if (printheader == MB_YES)
fprintf(stdout,"%s",buffer);
result = (char *) strchr(buffer, ',');
strcpy(fields[nfields].description, &(result[1]));
result = (char *) strchr(fields[nfields].description, ',');
result[0] = 0;
result = (char *) strrchr(buffer, ',');
strcpy(fields[nfields].units, &(result[1]));
fields[nfields].index = recordsize;
if (strcmp(type, "double") == 0)
{
fields[nfields].type = TYPE_DOUBLE;
fields[nfields].size = 8;
if (angles_in_degrees == MB_YES
&&(strcmp(fields[nfields].name, "mLatK") == 0
|| strcmp(fields[nfields].name, "mLonK") == 0
|| strcmp(fields[nfields].name, "mLatK") == 0
|| strcmp(fields[nfields].name, "mRollK") == 0
|| strcmp(fields[nfields].name, "mPitchK") == 0
|| strcmp(fields[nfields].name, "mHeadK") == 0
|| strcmp(fields[nfields].name, "mYawK") == 0
|| strcmp(fields[nfields].name, "mLonCB") == 0
|| strcmp(fields[nfields].name, "mLatCB") == 0
|| strcmp(fields[nfields].name, "mRollCB") == 0
|| strcmp(fields[nfields].name, "mPitchCB") == 0
|| strcmp(fields[nfields].name, "mHeadCB") == 0
|| strcmp(fields[nfields].name, "mYawCB") == 0))
fields[nfields].scale = RTD;
else
fields[nfields].scale = 1.0;
recordsize += 8;
}
else if (strcmp(type, "integer") == 0)
{
fields[nfields].type = TYPE_INTEGER;
fields[nfields].size = 4;
fields[nfields].scale = 1.0;
recordsize += 4;
}
else if (strcmp(type, "timeTag") == 0)
{
fields[nfields].type = TYPE_TIMETAG;
fields[nfields].size = 8;
fields[nfields].scale = 1.0;
recordsize += 8;
}
else if (strcmp(type, "angle") == 0)
{
fields[nfields].type = TYPE_ANGLE;
fields[nfields].size = 8;
if (angles_in_degrees == MB_YES
&&(strcmp(fields[nfields].name, "mRollCB") == 0
|| strcmp(fields[nfields].name, "mOmega_xCB") == 0
|| strcmp(fields[nfields].name, "mPitchCB") == 0
|| strcmp(fields[nfields].name, "mOmega_yCB") == 0
|| strcmp(fields[nfields].name, "mYawCB") == 0
|| strcmp(fields[nfields].name, "mOmega_zCB") == 0))
fields[nfields].scale = RTD;
else
fields[nfields].scale = 1.0;
recordsize += 8;
}
nfields++;
}
}
/* end here if asked only to print header */
if (nprintfields == 0 && printheader == MB_YES)
exit(error);
/* by default print everything */
if (nprintfields == 0)
{
nprintfields = nfields;
for (i=0;i<nfields;i++)
{
strcpy(printfields[i].name, fields[i].name);
printfields[i].index = i;
printfields[i].formatset = MB_NO;
strcpy(printfields[i].format, fields[i].format);
}
}
/* check the fields to be printed */
for (i=0;i<nprintfields;i++)
{
if (strcmp(printfields[i].name,"zero") == 0)
{
printfields[i].index = INDEX_ZERO;
if (printfields[i].formatset == MB_NO)
{
strcpy(printfields[i].format, "%f");
}
}
else if (strcmp(printfields[i].name,"timeTag") == 0)
{
printfields[i].index = INDEX_ZERO;
if (printfields[i].formatset == MB_NO)
{
strcpy(printfields[i].format, "%.8f");
}
}
else if (strcmp(printfields[i].name,"mergeLon") == 0)
{
printfields[i].index = INDEX_MERGE_LON;
if (printfields[i].formatset == MB_NO)
{
strcpy(printfields[i].format, "%.9f");
}
}
else if (strcmp(printfields[i].name,"mergeLat") == 0)
{
printfields[i].index = INDEX_MERGE_LAT;
if (printfields[i].formatset == MB_NO)
{
strcpy(printfields[i].format, "%.9f");
}
}
else if (strcmp(printfields[i].name,"mergeHeading") == 0)
{
printfields[i].index = INDEX_MERGE_HEADING;
if (printfields[i].formatset == MB_NO)
{
strcpy(printfields[i].format, "%.3f");
}
}
else if (strcmp(printfields[i].name,"mergeSpeed") == 0)
{
printfields[i].index = INDEX_MERGE_SPEED;
if (printfields[i].formatset == MB_NO)
{
strcpy(printfields[i].format, "%.3f");
}
}
else if (strcmp(printfields[i].name,"mergeDraft") == 0)
{
printfields[i].index = INDEX_MERGE_SENSORDEPTH;
if (printfields[i].formatset == MB_NO)
{
strcpy(printfields[i].format, "%.3f");
}
}
else if (strcmp(printfields[i].name,"mergeSensordepth") == 0)
{
printfields[i].index = INDEX_MERGE_SENSORDEPTH;
if (printfields[i].formatset == MB_NO)
{
strcpy(printfields[i].format, "%.3f");
}
}
else if (strcmp(printfields[i].name,"mergeRoll") == 0)
{
printfields[i].index = INDEX_MERGE_ROLL;
if (printfields[i].formatset == MB_NO)
{
strcpy(printfields[i].format, "%.3f");
}
}
else if (strcmp(printfields[i].name,"mergePitch") == 0)
{
printfields[i].index = INDEX_MERGE_PITCH;
if (printfields[i].formatset == MB_NO)
{
strcpy(printfields[i].format, "%.3f");
}
}
else if (strcmp(printfields[i].name,"mergeHeave") == 0)
{
printfields[i].index = INDEX_MERGE_HEAVE;
if (printfields[i].formatset == MB_NO)
{
strcpy(printfields[i].format, "%.3f");
}
}
else
{
for (j=0;j<nfields;j++)
{
if (strcmp(printfields[i].name, fields[j].name) == 0)
printfields[i].index = j;
}
if (printfields[i].formatset == MB_NO)
{
strcpy(printfields[i].format, fields[printfields[i].index].format);
}
}
}
/* if verbose print list of print field names */
if (verbose > 0)
{
for (i=0;i<nprintfields;i++)
{
if (i == 0)
fprintf(stdout, "# ");
fprintf(stdout, "%s", printfields[i].name);
if (i < nprintfields-1)
fprintf(stdout, " | ");
else
fprintf(stdout, "\n");
}
}
/* read the data records in the auv log file */
nrecord = 0;
while (fread(buffer, recordsize, 1, fp) == 1)
{
for (i=0;i<nprintfields;i++)
{
index = printfields[i].index;
if (index == INDEX_ZERO)
{
dvalue = 0.0;
if (output_mode == OUTPUT_MODE_BINARY)
fwrite(&dvalue, sizeof(double), 1, stdout);
else
fprintf(stdout, printfields[i].format, dvalue);
}
else if (index == INDEX_MERGE_LON)
{
interp_status = mb_linear_interp_longitude(verbose,
nav_time_d-1, nav_navlon-1,
nav_num, time_d, &dvalue, &jinterp,
&error);
if (jinterp < 2 || jinterp > nav_num-2)
dvalue = 0.0;
if (output_mode == OUTPUT_MODE_BINARY)
fwrite(&dvalue, sizeof(double), 1, stdout);
else
fprintf(stdout, printfields[i].format, dvalue);
}
else if (index == INDEX_MERGE_LAT)
{
interp_status = mb_linear_interp_latitude(verbose,
nav_time_d-1, nav_navlat-1,
nav_num, time_d, &dvalue, &jinterp,
&error);
if (jinterp < 2 || jinterp > nav_num-2)
dvalue = 0.0;
if (output_mode == OUTPUT_MODE_BINARY)
fwrite(&dvalue, sizeof(double), 1, stdout);
else
fprintf(stdout, printfields[i].format, dvalue);
}
else if (index == INDEX_MERGE_HEADING)
{
interp_status = mb_linear_interp_heading(verbose,
nav_time_d-1, nav_heading-1,
nav_num, time_d, &dvalue, &jinterp,
&error);
if (jinterp < 2 || jinterp > nav_num-2)
dvalue = 0.0;
if (output_mode == OUTPUT_MODE_BINARY)
fwrite(&dvalue, sizeof(double), 1, stdout);
else
fprintf(stdout, printfields[i].format, dvalue);
}
else if (index == INDEX_MERGE_SPEED)
{
interp_status = mb_linear_interp(verbose,
nav_time_d-1, nav_speed-1,
nav_num, time_d, &dvalue, &jinterp,
&error);
if (jinterp < 2 || jinterp > nav_num-2)
dvalue = 0.0;
if (output_mode == OUTPUT_MODE_BINARY)
fwrite(&dvalue, sizeof(double), 1, stdout);
else
fprintf(stdout, printfields[i].format, dvalue);
}
else if (index == INDEX_MERGE_SENSORDEPTH)
{
interp_status = mb_linear_interp(verbose,
nav_time_d-1, nav_sensordepth-1,
nav_num, time_d, &dvalue, &jinterp,
&error);
if (jinterp < 2 || jinterp > nav_num-2)
dvalue = 0.0;
if (output_mode == OUTPUT_MODE_BINARY)
fwrite(&dvalue, sizeof(double), 1, stdout);
else
fprintf(stdout, printfields[i].format, dvalue);
}
else if (index == INDEX_MERGE_ROLL)
{
interp_status = mb_linear_interp(verbose,
nav_time_d-1, nav_roll-1,
nav_num, time_d, &dvalue, &jinterp,
&error);
if (jinterp < 2 || jinterp > nav_num-2)
dvalue = 0.0;
if (output_mode == OUTPUT_MODE_BINARY)
fwrite(&dvalue, sizeof(double), 1, stdout);
else
fprintf(stdout, printfields[i].format, dvalue);
}
else if (index == INDEX_MERGE_PITCH)
{
interp_status = mb_linear_interp(verbose,
nav_time_d-1, nav_pitch-1,
nav_num, time_d, &dvalue, &jinterp,
&error);
if (jinterp < 2 || jinterp > nav_num-2)
dvalue = 0.0;
if (output_mode == OUTPUT_MODE_BINARY)
fwrite(&dvalue, sizeof(double), 1, stdout);
else
fprintf(stdout, printfields[i].format, dvalue);
}
else if (index == INDEX_MERGE_HEAVE)
{
interp_status = mb_linear_interp(verbose,
nav_time_d-1, nav_heave-1,
nav_num, time_d, &dvalue, &jinterp,
&error);
if (jinterp < 2 || jinterp > nav_num-2)
dvalue = 0.0;
if (output_mode == OUTPUT_MODE_BINARY)
fwrite(&dvalue, sizeof(double), 1, stdout);
else
fprintf(stdout, printfields[i].format, dvalue);
}
else if (fields[index].type == TYPE_DOUBLE)
{
mb_get_binary_double(MB_YES, &buffer[fields[index].index], &dvalue);
dvalue *= fields[index].scale;
if ((strcmp(fields[nfields].name, "mHeadK") == 0
|| strcmp(fields[nfields].name, "mYawK") == 0)
&& angles_in_degrees == MB_YES
&& dvalue < 0.0)
dvalue += 360.0;
if (output_mode == OUTPUT_MODE_BINARY)
fwrite(&dvalue, sizeof(double), 1, stdout);
else
fprintf(stdout, printfields[i].format, dvalue);
}
else if (fields[index].type == TYPE_INTEGER)
{
mb_get_binary_int(MB_YES, &buffer[fields[index].index], &ivalue);
if (output_mode == OUTPUT_MODE_BINARY)
fwrite(&ivalue, sizeof(int), 1, stdout);
else
fprintf(stdout, printfields[i].format, ivalue);
}
else if (fields[index].type == TYPE_TIMETAG)
{
mb_get_binary_double(MB_YES, &buffer[fields[index].index], &dvalue);
time_d = dvalue;
if (strcmp(printfields[i].format, "time_i") == 0)
{
mb_get_date(verbose,time_d,time_i);
if (output_mode == OUTPUT_MODE_BINARY)
{
fwrite(time_i, sizeof(int), 7, stdout);
}
else
{
fprintf(stdout,"%4.4d %2.2d %2.2d %2.2d %2.2d %2.2d.%6.6d",
time_i[0],time_i[1],time_i[2],time_i[3],time_i[4],time_i[5],time_i[6]);
}
}
else if (strcmp(printfields[i].format, "time_j") == 0)
{
mb_get_date(verbose,time_d,time_i);
mb_get_jtime(verbose,time_i,time_j);
if (output_mode == OUTPUT_MODE_BINARY)
{
fwrite(&time_i[0], sizeof(int), 1, stdout);
fwrite(&time_j[1], sizeof(int), 1, stdout);
fwrite(&time_i[3], sizeof(int), 1, stdout);
fwrite(&time_i[4], sizeof(int), 1, stdout);
fwrite(&time_i[5], sizeof(int), 1, stdout);
fwrite(&time_i[6], sizeof(int), 1, stdout);
}
else
{
fprintf(stdout,"%4.4d %3.3d %2.2d %2.2d %2.2d.%6.6d",
time_i[0],time_j[1],time_i[3],time_i[4],time_i[5],time_i[6]);
}
}
else
{
if (output_mode == OUTPUT_MODE_BINARY)
fwrite(&dvalue, sizeof(double), 1, stdout);
else
fprintf(stdout, printfields[i].format, time_d);
}
}
else if (fields[index].type == TYPE_ANGLE)
{
mb_get_binary_double(MB_YES, &buffer[fields[index].index], &dvalue);
dvalue *= fields[index].scale;
if (strcmp(fields[index].name, "mYawCB") == 0
&& angles_in_degrees == MB_YES
&& dvalue < 0.0)
dvalue += 360.0;
if (output_mode == OUTPUT_MODE_BINARY)
fwrite(&dvalue, sizeof(double), 1, stdout);
else
fprintf(stdout, printfields[i].format, dvalue);
}
if (output_mode == OUTPUT_MODE_TAB)
{
if (i < nprintfields - 1)
fprintf(stdout, "\t");
else
fprintf(stdout, "\n");
}
else if (output_mode == OUTPUT_MODE_CSV)
{
if (i < nprintfields - 1)
fprintf(stdout, ",");
else
fprintf(stdout, "\n");
}
}
nrecord++;
}
fclose(fp);
/* deallocate arrays for navigation */
if (nav_alloc > 0)
{
mb_freed(verbose,__FILE__,__LINE__,(void **)&nav_time_d,&error);
mb_freed(verbose,__FILE__,__LINE__,(void **)&nav_navlon,&error);
mb_freed(verbose,__FILE__,__LINE__,(void **)&nav_navlat,&error);
mb_freed(verbose,__FILE__,__LINE__,(void **)&nav_heading,&error);
mb_freed(verbose,__FILE__,__LINE__,(void **)&nav_speed,&error);
mb_freed(verbose,__FILE__,__LINE__,(void **)&nav_sensordepth,&error);
mb_freed(verbose,__FILE__,__LINE__,(void **)&nav_roll,&error);
mb_freed(verbose,__FILE__,__LINE__,(void **)&nav_pitch,&error);
mb_freed(verbose,__FILE__,__LINE__,(void **)&nav_heave,&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[] = "mbctdlist";
char help_message[] = "mbctdlist lists all CTD records within swath data files\nThe -O option specifies how the values are output\nin an mblist-likefashion.\n";
char usage_message[] = "mbctdlist [-A -Ddecimate -Fformat -Gdelimeter -H -Ifile -Llonflip -Ooutput_format -V -Zsegment]";
extern char *optarg;
int errflg = 0;
int c;
int help = 0;
int flag = 0;
/* MBIO status variables */
int status = MB_SUCCESS;
int interp_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;
/* output format list controls */
char list[MAX_OPTIONS];
int n_list;
double distance_total = 0.0;
int time_j[5];
int mblist_next_value = MB_NO;
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;
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];
/* navigation, heading, attitude data */
int survey_count = 0;
int survey_count_tot = 0;
int nnav = 0;
int nnav_alloc = 0;
double *nav_time_d = NULL;
double *nav_lon = NULL;
double *nav_lat = NULL;
double *nav_sonardepth = NULL;
double *nav_heading = NULL;
double *nav_speed = NULL;
double *nav_altitude = NULL;
/* CTD values */
int ctd_count = 0;
int ctd_count_tot = 0;
int nctd;
double ctd_time_d[MB_CTD_MAX];
double ctd_conductivity[MB_CTD_MAX];
double ctd_temperature[MB_CTD_MAX];
double ctd_depth[MB_CTD_MAX];
double ctd_salinity[MB_CTD_MAX];
double ctd_soundspeed[MB_CTD_MAX];
int nsensor;
double sensor_time_d[MB_CTD_MAX];
double sensor1[MB_CTD_MAX];
double sensor2[MB_CTD_MAX];
double sensor3[MB_CTD_MAX];
double sensor4[MB_CTD_MAX];
double sensor5[MB_CTD_MAX];
double sensor6[MB_CTD_MAX];
double sensor7[MB_CTD_MAX];
double sensor8[MB_CTD_MAX];
double conductivity;
double temperature;
double potentialtemperature;
double depth;
double salinity;
double soundspeed;
/* 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;
double seconds;
/* 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 ictd;
int i, j;
/* get current default values */
status = mb_defaults(verbose,&format,&pings,&lonflip,bounds,
btime_i,etime_i,&speedmin,&timegap);
pings = 1;
bounds[0] = -360.0;
bounds[1] = 360.0;
bounds[2] = -90.0;
bounds[3] = 90.0;
ctd_count = 0;
ctd_count_tot = 0;
/* set default input to datalist.mb-1 */
strcpy (read_file, "datalist.mb-1");
/* set up the default list controls
(Time, lon, lat, conductivity, temperature, depth, salinity, sound speed) */
list[0]='T';
list[1]='X';
list[2]='Y';
list[3]='H';
list[4]='C';
list[5]='c';
list[6]='^';
list[7]='c';
list[8]='S';
list[9]='s';
n_list = 10;
sprintf(delimiter, "\t");
decimate = 1;
/* process argument list */
while ((c = getopt(argc, argv, "AaDdF:f:G:g:I:i:L:l:O:o: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 'D':
case 'd':
sscanf (optarg,"%d", &decimate);
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 'L':
case 'l':
sscanf (optarg,"%d", &lonflip);
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];
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,"Version %s\n",rcs_id);
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 Version %s\n",rcs_id);
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 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;
/**************************************************************************************/
/* section 1 - read all data and save nav etc for interpolation onto ctd data */
/* 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)
{
/* 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);
}
/* output info */
if (verbose >= 1)
{
fprintf(stderr, "\nSearching %s for survey records\n", file);
}
/* read and print data */
survey_count = 0;
first = MB_YES;
while (error <= MB_ERROR_NO_ERROR)
{
/* read a 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);
}
/* if survey data save the nav etc */
if (error <= MB_ERROR_NO_ERROR
&& kind == MB_DATA_DATA)
{
/* allocate memory for navigation/attitude arrays if needed */
if (nnav + 1 >= nnav_alloc)
{
nnav_alloc += MBCTDLIST_ALLOC_CHUNK;
status = mb_reallocd(verbose,__FILE__,__LINE__,nnav_alloc*sizeof(double),(void **)&nav_time_d,&error);
status = mb_reallocd(verbose,__FILE__,__LINE__,nnav_alloc*sizeof(double),(void **)&nav_lon,&error);
status = mb_reallocd(verbose,__FILE__,__LINE__,nnav_alloc*sizeof(double),(void **)&nav_lat,&error);
status = mb_reallocd(verbose,__FILE__,__LINE__,nnav_alloc*sizeof(double),(void **)&nav_speed,&error);
status = mb_reallocd(verbose,__FILE__,__LINE__,nnav_alloc*sizeof(double),(void **)&nav_sonardepth,&error);
status = mb_reallocd(verbose,__FILE__,__LINE__,nnav_alloc*sizeof(double),(void **)&nav_heading,&error);
status = mb_reallocd(verbose,__FILE__,__LINE__,nnav_alloc*sizeof(double),(void **)&nav_altitude,&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);
}
}
/* save the nav etc */
if (nnav == 0 || time_d > nav_time_d[nnav-1])
{
nav_time_d[nnav] = time_d;
nav_lon[nnav] = navlon;
nav_lat[nnav] = navlat;
nav_speed[nnav] = speed;
nav_sonardepth[nnav] = sonardepth;
nav_heading[nnav] = heading;
nav_altitude[nnav] = altitude;
nnav++;
}
survey_count++;
survey_count_tot++;
}
}
/* close the swath file */
status = mb_close(verbose,&mbio_ptr,&error);
/* output info */
if (verbose >= 1)
{
fprintf(stderr, "nav extracted from %d survey records\n", survey_count);
}
/* 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 info */
if (verbose >= 1)
{
fprintf(stderr, "\nTotal %d survey records\n", survey_count_tot);
}
/**************************************************************************************/
/* section 2 - read data and output ctd data with time interpolation of nav etc */
/* 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)
{
/* 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 info */
if (verbose >= 1)
{
fprintf(stderr, "\nSearching %s for CTD records\n", file);
}
/* read and print data */
ctd_count = 0;
first = MB_YES;
while (error <= MB_ERROR_NO_ERROR)
{
/* read a 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);
}
/* if ctd then extract data */
if (error <= MB_ERROR_NO_ERROR
&& (kind == MB_DATA_CTD || kind == MB_DATA_SSV))
{
/* extract ctd */
status = mb_ctd(verbose, mbio_ptr, store_ptr,
&kind, &nctd, ctd_time_d,
ctd_conductivity, ctd_temperature,
ctd_depth, ctd_salinity, ctd_soundspeed, &error);
/* extract ancilliary sensor data */
status = mb_ancilliarysensor(verbose, mbio_ptr, store_ptr,
&kind, &nsensor, sensor_time_d,
sensor1, sensor2, sensor3,
sensor4, sensor5, sensor6,
sensor7, sensor8,
&error);
/* loop over the nctd ctd points, outputting each one */
if (error == MB_ERROR_NO_ERROR && nctd > 0)
{
for (ictd=0;ictd<nctd;ictd++)
{
/* get data */
time_d = ctd_time_d[ictd];
mb_get_date(verbose, time_d, time_i);
conductivity = ctd_conductivity[ictd];
temperature = ctd_temperature[ictd];
depth = ctd_depth[ictd];
salinity = ctd_salinity[ictd];
soundspeed = ctd_soundspeed[ictd];
/* get navigation */
j = 0;
speed = 0.0;
interp_status = mb_linear_interp_longitude(verbose,
nav_time_d-1, nav_lon-1,
nnav, time_d, &navlon, &j,
&error);
if (interp_status == MB_SUCCESS)
interp_status = mb_linear_interp_latitude(verbose,
nav_time_d-1, nav_lat-1,
nnav, time_d, &navlat, &j,
&error);
if (interp_status == MB_SUCCESS)
interp_status = mb_linear_interp_heading(verbose,
nav_time_d-1, nav_heading-1,
nnav, time_d, &heading, &j,
&error);
if (interp_status == MB_SUCCESS)
interp_status = mb_linear_interp(verbose,
nav_time_d-1, nav_sonardepth-1,
nnav, time_d, &sonardepth, &j,
&error);
if (interp_status == MB_SUCCESS)
interp_status = mb_linear_interp(verbose,
nav_time_d-1, nav_altitude-1,
nnav, time_d, &altitude, &j,
&error);
if (interp_status == MB_SUCCESS)
interp_status = mb_linear_interp(verbose,
nav_time_d-1, nav_speed-1,
nnav, time_d, &speed, &j,
&error);
/* only output if interpolation of nav etc has worked */
if (interp_status == MB_YES)
{
/* 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 */
ctd_count++;
ctd_count_tot++;
if (nctd % 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 '^': /* use mblist definitions of CcSsTt */
mblist_next_value = MB_YES;
break;
case '1': /* Sensor 1 - volts */
printsimplevalue(verbose, sensor1[ictd], 0, 3, ascii,
&invert_next_value,
&signflip_next_value, &error);
break;
case '2': /* Sensor 2 - volts */
printsimplevalue(verbose, sensor2[ictd], 0, 3, ascii,
&invert_next_value,
&signflip_next_value, &error);
break;
case '3': /* Sensor 3 - volts */
printsimplevalue(verbose, sensor3[ictd], 0, 3, ascii,
&invert_next_value,
&signflip_next_value, &error);
break;
case '4': /* Sensor 4 - volts */
printsimplevalue(verbose, sensor4[ictd], 0, 3, ascii,
&invert_next_value,
&signflip_next_value, &error);
break;
case '5': /* Sensor 5 - volts */
printsimplevalue(verbose, sensor5[ictd], 0, 3, ascii,
&invert_next_value,
&signflip_next_value, &error);
break;
case '6': /* Sensor 6 - volts */
printsimplevalue(verbose, sensor6[ictd], 0, 3, ascii,
&invert_next_value,
&signflip_next_value, &error);
break;
case '7': /* Sensor 7 - volts */
printsimplevalue(verbose, sensor7[ictd], 0, 3, ascii,
&invert_next_value,
&signflip_next_value, &error);
break;
case '8': /* Sensor 8 - volts */
printsimplevalue(verbose, sensor8[ictd], 0, 3, ascii,
&invert_next_value,
&signflip_next_value, &error);
break;
case 'C': /* Conductivity or Sonar altitude (m) */
if (mblist_next_value == MB_NO)
printsimplevalue(verbose, conductivity, 0, 5, ascii,
&invert_next_value,
&signflip_next_value, &error);
else
{
printsimplevalue(verbose, altitude, 0, 3, ascii,
&invert_next_value,
&signflip_next_value, &error);
mblist_next_value = MB_NO;
}
break;
case 'c': /* Temperature or sonar transducer depth (m) */
if (mblist_next_value == MB_NO)
printsimplevalue(verbose, temperature, 0, 5, ascii,
&invert_next_value,
&signflip_next_value, &error);
else
{
printsimplevalue(verbose, sonardepth, 0, 3, ascii,
&invert_next_value,
&signflip_next_value, &error);
mblist_next_value = MB_NO;
}
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);
seconds = time_i[5] + 0.000001 * time_i[6];
if (ascii == MB_YES)
{
printf("%.4d %.3d %.2d %.2d %9.6f",
time_j[0],time_j[1],
time_i[3],time_i[4],
seconds);
}
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);
seconds = time_i[5] + 0.000001 * time_i[6];
if (ascii == MB_YES)
{
printf("%.4d %.3d %.4d %9.6f",
time_j[0],time_j[1],
time_j[2],seconds);
}
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': /* potential temperature (degrees) */
/* approximation taken from http://mason.gmu.edu/~bklinger/seawater.pdf
on 4/25/2012 - to be replaced by a better calculation at some point */
potentialtemperature = temperature
- 0.04 * (1.0 + 0.185 * temperature + 0.35 * (salinity - 35.0)) * (sonardepth / 1000.0)
- 0.0075 * (1.0 - temperature / 30.0) * (sonardepth * sonardepth / 1000000.0);
printsimplevalue(verbose, potentialtemperature, 0, 5, ascii,
&invert_next_value,
&signflip_next_value, &error);
break;
case 'S': /* salinity or speed */
if (mblist_next_value == MB_NO)
printsimplevalue(verbose, salinity, 0, 5, ascii,
&invert_next_value,
&signflip_next_value, &error);
else
{
printsimplevalue(verbose, speed, 5, 2, ascii,
&invert_next_value,
&signflip_next_value, &error);
mblist_next_value = MB_NO;
}
break;
case 's': /* speed made good */
if (mblist_next_value == MB_NO)
printsimplevalue(verbose, soundspeed, 0, 3, ascii,
&invert_next_value,
&signflip_next_value, &error);
else
{
printsimplevalue(verbose, speed_made_good, 5, 2, ascii,
&invert_next_value,
&signflip_next_value, &error);
mblist_next_value = MB_NO;
}
break;
case 'T': /* yyyy/mm/dd/hh/mm/ss time string */
seconds = time_i[5] + 1e-6 * time_i[6];
if (ascii == MB_YES)
printf("%.4d/%.2d/%.2d/%.2d/%.2d/%9.6f",
time_i[0],time_i[1],time_i[2],
time_i[3],time_i[4],seconds);
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 = seconds;
fwrite(&b, sizeof(double), 1, stdout);
}
break;
case 't': /* yyyy mm dd hh mm ss time string */
seconds = time_i[5] + 1e-6 * time_i[6];
if (ascii == MB_YES)
printf("%.4d %.2d %.2d %.2d %.2d %9.6f",
time_i[0],time_i[1],time_i[2],
time_i[3],time_i[4],seconds);
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 = seconds;
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 value */
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, 11, 6, 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 %8.5f%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, 11, 6, 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 %8.5f%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");
}
}
first = MB_NO;
}
}
}
}
/* else if survey data ignore */
else if (error <= MB_ERROR_NO_ERROR
&& kind == MB_DATA_DATA)
{
}
}
/* close the swath file */
status = mb_close(verbose,&mbio_ptr,&error);
/* output info */
if (verbose >= 1)
{
fprintf(stderr, "%d CTD records\n", ctd_count);
}
/* 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 info */
if (verbose >= 1)
{
fprintf(stderr, "\nTotal %d CTD records\n", ctd_count_tot);
}
/* deallocate navigation arrays */
if (nnav > 0)
{
status = mb_freed(verbose,__FILE__,__LINE__,(void **)&nav_time_d,&error);
status = mb_freed(verbose,__FILE__,__LINE__,(void **)&nav_lon,&error);
status = mb_freed(verbose,__FILE__,__LINE__,(void **)&nav_lat,&error);
status = mb_freed(verbose,__FILE__,__LINE__,(void **)&nav_speed,&error);
status = mb_freed(verbose,__FILE__,__LINE__,(void **)&nav_sonardepth,&error);
status = mb_freed(verbose,__FILE__,__LINE__,(void **)&nav_heading,&error);
status = mb_freed(verbose,__FILE__,__LINE__,(void **)&nav_altitude,&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 mbsys_sb2100_insert(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_insert";
int status = MB_SUCCESS;
struct mb_io_struct *mb_io_ptr;
struct mbsys_sb2100_struct *store;
int time_j[5];
int set_pixel_size;
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 mbio_ptr: %p\n",(void *)mbio_ptr);
fprintf(stderr,"dbg2 store_ptr: %p\n",(void *)store_ptr);
fprintf(stderr,"dbg2 kind: %d\n",kind);
}
if (verbose >= 2 && (kind == MB_DATA_DATA || kind == MB_DATA_NAV))
{
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 navlon: %f\n",navlon);
fprintf(stderr,"dbg2 navlat: %f\n",navlat);
fprintf(stderr,"dbg2 speed: %f\n",speed);
fprintf(stderr,"dbg2 heading: %f\n",heading);
}
if (verbose >= 2 && kind == MB_DATA_DATA)
{
fprintf(stderr,"dbg2 nbath: %d\n",nbath);
if (verbose >= 3)
for (i=0;i<nbath;i++)
fprintf(stderr,"dbg3 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);
if (verbose >= 3)
for (i=0;i<namp;i++)
fprintf(stderr,"dbg3 beam:%d amp:%f acrosstrack:%f alongtrack:%f\n",
i,amp[i],bathacrosstrack[i],bathalongtrack[i]);
fprintf(stderr,"dbg2 nss: %d\n",nss);
if (verbose >= 3)
for (i=0;i<nss;i++)
fprintf(stderr,"dbg3 pixel:%d ss:%f acrosstrack:%f alongtrack:%f\n",
i,ss[i],ssacrosstrack[i],ssalongtrack[i]);
}
if (verbose >= 2 && kind == MB_DATA_COMMENT)
{
fprintf(stderr,"dbg2 comment: \ndbg2 %s\n",
comment);
}
/* get mbio descriptor */
mb_io_ptr = (struct mb_io_struct *) mbio_ptr;
/* get data structure pointer */
store = (struct mbsys_sb2100_struct *) store_ptr;
/* set data kind */
store->kind = kind;
/* insert data in structure */
if (store->kind == MB_DATA_DATA)
{
/* get time */
mb_get_jtime(verbose,time_i,time_j);
store->year = time_j[0];
store->jday = time_j[1];
store->hour = time_j[2]/60;
store->minute = time_j[2] - 60*store->hour;
store->sec = time_j[3];
store->msec = (int) (0.001 * time_j[4]);
/* get number of beams and pixels */
store->nbeams = nbath;
store->npixels = nss;
center_pixel = store->npixels / 2;
/* get navigation */
if (navlon < 0.0) navlon = navlon + 360.0;
store->longitude = navlon;
store->latitude = navlat;
/* get heading */
store->heading = heading;
/* get speed */
store->speed = 5.3899155 * speed;
/* put beam and pixel values
into data structure */
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 (mb_beam_check_flag(beamflag[i]))
{
if (mb_beam_check_flag_null(beamflag[i]))
store->beams[i].quality = '0';
else if (mb_beam_check_flag_manual(beamflag[i]))
store->beams[i].quality = 'E';
else if (mb_beam_check_flag_filter(beamflag[i]))
store->beams[i].quality = 'F';
else if (mb_beam_check_flag_sonar(beamflag[i]))
store->beams[i].quality = 'Q';
}
else
store->beams[i].quality = ' ';
store->beams[i].depth = bath[i];
store->beams[i].acrosstrack = bathacrosstrack[i];
store->beams[i].alongtrack = bathalongtrack[i];
}
for (i=0;i<namp;i++)
store->beams[i].amplitude = 4.0 * (amp[i] + gain_db);
if (store->pixel_size <= 0.0)
set_pixel_size = MB_YES;
else
set_pixel_size = MB_NO;
for (i=0;i<nss;i++)
{
if (ss[i] > MB_SIDESCAN_NULL)
store->pixels[i].amplitude = gain_factor * ss[i];
else
store->pixels[i].amplitude = 0;
store->pixels[i].alongtrack = ssalongtrack[i];
if (set_pixel_size == MB_YES
&& ssacrosstrack[i] > 0)
{
store->pixel_size = ssacrosstrack[i]/
(i - center_pixel);
set_pixel_size = MB_NO;
}
}
}
/* insert comment in structure */
else if (store->kind == MB_DATA_COMMENT)
{
strcpy(store->comment,comment);
}
/* print output debug statements */
if (verbose >= 2)
{
fprintf(stderr,"\ndbg2 MBIO function <%s> completed\n",
function_name);
fprintf(stderr,"dbg2 Return value:\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 mbsys_sb2100_insert_nav(int verbose, void *mbio_ptr, void *store_ptr,
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_insert_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 mbio_ptr: %p\n",(void *)mbio_ptr);
fprintf(stderr,"dbg2 store_ptr: %p\n",(void *)store_ptr);
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 navlon: %f\n",navlon);
fprintf(stderr,"dbg2 navlat: %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);
}
/* get mbio descriptor */
mb_io_ptr = (struct mb_io_struct *) mbio_ptr;
/* get data structure pointer */
store = (struct mbsys_sb2100_struct *) store_ptr;
/* insert data in structure */
if (store->kind == MB_DATA_DATA)
{
/* get time */
mb_get_jtime(verbose,time_i,time_j);
store->year = time_j[0];
store->jday = time_j[1];
store->hour = time_j[2]/60;
store->minute = time_j[2] - 60*store->hour;
store->sec = time_j[3];
store->msec = (int) (0.001 * time_j[4]);
/* get navigation */
if (navlon < 0.0) navlon = navlon + 360.0;
store->longitude = navlon;
store->latitude = navlat;
/* get heading */
store->heading = heading;
/* get speed */
store->speed = 5.3899155*speed;
/* get draft */
store->ship_draft = draft;
/* get roll pitch and heave */
store->roll = roll;
store->pitch = pitch;
store->heave = -heave;
}
/* print output debug statements */
if (verbose >= 2)
{
fprintf(stderr,"\ndbg2 MBIO function <%s> completed\n",
function_name);
fprintf(stderr,"dbg2 Return value:\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 mbr_wt_segysegy(int verbose, void *mbio_ptr, void *store_ptr, int *error)
{
char *function_name = "mbr_wt_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];
/* 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 pointer to mbio descriptor */
mb_io_ptr = (struct mb_io_struct *) mbio_ptr;
/* get pointer to raw data structure */
store = (struct mbsys_singlebeam_struct *) store_ptr;
mb_segyio_ptr = (struct mb_segyio_struct *) (mb_io_ptr->mbfp);
traceheader = mb_segyio_ptr->traceheader;
trace = (float *) &mb_segyio_ptr->trace;
/* first translate values from data storage structure */
if (store != NULL)
{
mb_get_jtime(verbose,store->time_i,time_j);
traceheader.year = store->time_i[0];
traceheader.day_of_yr = time_j[1];
traceheader.hour = store->time_i[3];
traceheader.min = store->time_i[4];
traceheader.sec = store->time_i[5];
traceheader.mils = store->time_i[6] / 1000;
traceheader.src_long = store->longitude * 360000.0;
traceheader.src_lat = store->latitude * 360000.0;
traceheader.heading = store->heading;
traceheader.src_depth = 100.0 * store->sonar_depth;
traceheader.wbt_secs = store->tt;
traceheader.src_wbd = 100.0 * store->bath;
traceheader.shot_num = store->seismic_shot;
traceheader.rp_num = store->seismic_cdp;
}
/* write next data to file */
status = mb_segy_write_trace(verbose, (void *) mb_segyio_ptr,
&traceheader, trace, error);
/* 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 mbr_mbarirov_wr_data(int verbose, void *mbio_ptr, void *data_ptr, int *error)
{
char *function_name = "mbr_mbarirov_wr_data";
int status = MB_SUCCESS;
struct mb_io_struct *mb_io_ptr;
struct mbf_mbarirov_struct *data;
char line[MBF_MBARIROV_MAXLINE+1];
int time_j[6],year,jday,timetag;
int len;
int *write_count;
/* 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 data_ptr: %lu\n",(size_t)data_ptr);
}
/* get pointer to mbio descriptor */
mb_io_ptr = (struct mb_io_struct *) mbio_ptr;
/* get pointer to raw data structure */
data = (struct mbf_mbarirov_struct *) data_ptr;
/* get pointer to write counter */
write_count = (int *) &mb_io_ptr->save1;
/* handle the data */
if (data->kind == MB_DATA_COMMENT)
{
line[0] = '#';
strncpy(&line[1],data->comment,MBF_MBARIROV_MAXLINE-2);
len = strlen(line);
if (line[len-1] != '\n')
{
line[len] = '\n';
line[len+1] = '\0';
}
}
else if (data->kind == MB_DATA_DATA)
{
/* get pressure */
data->rov_pressure = data->rov_depth
* (1.0052405
* ( 1 + 5.28E-3
* sin(DTR * data->latitude)
* sin(DTR * data->latitude)));
/* print output debug statements */
if (verbose >= 4)
{
fprintf(stderr,"\ndbg4 Data to be written in MBIO function <%s>\n",
function_name);
fprintf(stderr,"dbg4 Values,read:\n");
fprintf(stderr,"dbg4 time_d: %f\n",data->time_d);
fprintf(stderr,"dbg4 latitude: %f\n",data->latitude);
fprintf(stderr,"dbg4 longitude: %f\n",data->longitude);
fprintf(stderr,"dbg4 easting: %f\n",data->easting);
fprintf(stderr,"dbg4 northing: %f\n",data->northing);
fprintf(stderr,"dbg4 rov_pressure: %f\n",data->rov_pressure);
fprintf(stderr,"dbg4 rov_heading: %f\n",data->rov_heading);
fprintf(stderr,"dbg4 rov_altitude: %f\n",data->rov_altitude);
fprintf(stderr,"dbg4 rov_pitch: %f\n",data->rov_pitch);
fprintf(stderr,"dbg4 rov_roll: %f\n",data->rov_roll);
fprintf(stderr,"dbg4 position_flag:%d\n",data->position_flag);
fprintf(stderr,"dbg4 pressure_flag:%d\n",data->pressure_flag);
fprintf(stderr,"dbg4 heading_flag: %d\n",data->heading_flag);
fprintf(stderr,"dbg4 altitude_flag:%d\n",data->altitude_flag);
fprintf(stderr,"dbg4 attitude_flag:%d\n",data->attitude_flag);
fprintf(stderr,"dbg4 error: %d\n",*error);
fprintf(stderr,"dbg4 status: %d\n",status);
}
mb_get_jtime(verbose,data->time_i,time_j);
year = data->time_i[0];
jday = time_j[1];
timetag = 10000 * data->time_i[3]
+ 100 * data->time_i[4]
+ data->time_i[5];
sprintf(line,
"%4.4d,%3.3d,%6.6d,%9.0f,%10.6f,%11.6f,%7.0f,%7.0f,%7.2f,%5.1f,%6.2f,%4.1f,%4.1f,%d,%d,%d,%d,%d\n",
year,
jday,
timetag,
data->time_d,
data->latitude,
data->longitude,
data->easting,
data->northing,
data->rov_pressure,
data->rov_heading,
data->rov_altitude,
data->rov_pitch,
data->rov_roll,
data->position_flag,
data->pressure_flag,
data->heading_flag,
data->altitude_flag,
data->attitude_flag);
}
/* write file header if needed */
if (*write_count == 0)
{
if (fputs(header,mb_io_ptr->mbfp) == EOF)
{
*error = MB_ERROR_WRITE_FAIL;
status = MB_FAILURE;
}
else
{
*error = MB_ERROR_NO_ERROR;
status = MB_SUCCESS;
}
}
/* write data */
if (fputs(line,mb_io_ptr->mbfp) == EOF)
{
*error = MB_ERROR_WRITE_FAIL;
status = MB_FAILURE;
}
else
{
(*write_count)++;
*error = MB_ERROR_NO_ERROR;
status = MB_SUCCESS;
}
/* print output debug statements */
if (verbose >= 5)
{
fprintf(stderr,"\ndbg5 Data record kind in MBIO function <%s>\n",function_name);
fprintf(stderr,"dbg5 kind: %d\n",data->kind);
}
/* 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);
}
