static void parse_track_waypoint(void) { char *str; int column = -1; waypoint *wpt; bind_fields(trkpt_header); wpt = waypt_new(); while ((str = csv_lineparse(NULL, "\t", "", column++))) { int field_no; double x; if (! *str) continue; field_no = header_fields[trkpt_header][column]; switch(field_no) { case 1: parse_coordinates(str, datum_index, grid_index, &wpt->latitude, &wpt->longitude, MYNAME); break; case 2: parse_date_and_time(str, &wpt->creation_time); break; case 3: if (parse_distance(str, &x, 1, MYNAME)) wpt->altitude = x; break; case 4: if (parse_distance(str, &x, 1, MYNAME)) WAYPT_SET(wpt, depth, x); break; case 5: if (parse_temperature(str, &x)) WAYPT_SET(wpt, temperature, x); break; case 8: if (parse_speed(str, &x, 1, MYNAME)) WAYPT_SET(wpt, speed, x); break; case 9: WAYPT_SET(wpt, course, atoi(str)); break; } } track_add_wpt(current_trk, wpt); }
void vpl_parse_75_sentence(const char *ibuf) { gbuint32 ymd, hms; gbint32 lat_raw, lon_raw; gbint16 alt, speed_raw; gbuint16 hdg_raw; gbuint8 sats, hdop_raw, vdop_raw; waypoint *waypt; struct tm tm; // The files have DOS line endings (CR/LF) but we don't care, because we // don't read to the end. sscanf(ibuf, "75%*2c%8X%8X%4hX%4hX%4hX%*2c%2hhX%2hhX%2hhX%6u%6u", &lat_raw, &lon_raw, &alt, &speed_raw, &hdg_raw, &sats, &hdop_raw, &vdop_raw, &ymd, &hms); tm.tm_sec = hms % 100; hms /= 100; tm.tm_min = hms % 100; hms /= 100; tm.tm_hour = hms % 100; tm.tm_mday = ymd % 100; ymd /= 100; tm.tm_mon = ymd % 100; ymd /= 100; tm.tm_year = ymd % 100 + 100; waypt = waypt_new(); // Lat/Lon are both stored *0xE1000 which we have to divide out // for decimal degrees waypt->latitude = lat_raw / (double) 0xE1000; waypt->longitude = lon_raw / (double) 0xE1000; waypt->altitude = alt; waypt->sat = sats; // Speed comes in (MPH x 0x10) which we have to convert to m/s WAYPT_SET(waypt, speed, (speed_raw / (double) 0x10) * 0.44704); waypt->course = hdg_raw * (double) (360/65535); waypt->hdop = hdop_raw / (double) 8; waypt->vdop = vdop_raw / (double) 8; waypt->creation_time = mkgmtime(&tm); track_add_wpt(track_head, waypt); }
static void humminbird_read_wpt(gbfile* fin) { humminbird_waypt_t w; double guder; int num_icons; waypoint *wpt; char buff[10]; if (! gbfread(&w, 1, sizeof(w), fin)) fatal(MYNAME ": Unexpected end of file!\n"); /* Fix endianness - these are now BE */ w.num = be_read16(&w.num); w.zero = be_read16(&w.zero); w.depth = be_read16(&w.depth); w.time = be_read32(&w.time); w.north = be_read32(&w.north); w.east = be_read32(&w.east); /* All right! Copy the data to the gpsbabel struct... */ wpt = waypt_new(); wpt->shortname = xstrndup(w.name, sizeof(w.name)); wpt->creation_time = w.time; guder = gudermannian_i1924(w.north); wpt->latitude = geocentric_to_geodetic_hwr(guder); wpt->longitude = (double)w.east / EAST_SCALE * 180.0; wpt->altitude = 0.0; /* It's from a fishfinder... */ if (w.depth != 0) WAYPT_SET(wpt,depth,(double)w.depth / 100.0); num_icons = sizeof(humminbird_icons) / sizeof(humminbird_icons[0]); if (w.icon < num_icons) wpt->icon_descr = humminbird_icons[w.icon]; waypt_add(wpt); /* register the point over his internal Humminbird "Number" */ snprintf(buff, sizeof(buff), "%d", w.num); avltree_insert(waypoints, buff, wpt); }
static void parse_wpt_info(const char *buff, waypoint *wpt) /* "w" */ { char *c; int col = -1; double fx; c = csv_lineparse(buff, ",", "", col++); while (c != NULL) { c = lrtrim(c); if (*c != '\0') { #if 0 printf(MYNAME "_read_wpt_info: col(%d)=%s\n", col, c); #endif switch(col) { case 0: wpt->icon_descr = xstrdup(c); wpt->wpt_flags.icon_descr_is_dynamic = 1; break; case 1: break; /* Text postion */ case 2: break; /* Lens zoom level */ case 3: break; /* Text colour */ case 4: break; /* Background colour */ case 5: break; /* Transparent text (0=transparent, 1=no transparent) */ case 6: break; /* ??? */ case 7: break; /* ??? */ case 8: /* radius */ fx = atof(c); if (fx > 0) WAYPT_SET(wpt, proximity, fx); break; } } c = csv_lineparse(NULL, ",", "", col++); } }
static void humminbird_read_track(gbfile* fin) { humminbird_trk_header_t th; humminbird_trk_point_t* points; route_head* trk; waypoint* first_wpt; int i; int max_points = 0; gbint32 accum_east; gbint32 accum_north; double g_lat; if (! gbfread(&th, 1, sizeof(th), fin)) fatal(MYNAME ": Unexpected end of file reading header!\n"); th.trk_num = be_read16(&th.trk_num); th.num_points = be_read16(&th.num_points); th.time = be_read32(&th.time); th.start_east = be_read32(&th.start_east); th.start_north = be_read32(&th.start_north); th.end_east = be_read32(&th.end_east); th.end_north = be_read32(&th.end_north); th.sw_east = be_read32(&th.sw_east); th.sw_north = be_read32(&th.sw_north); th.ne_east = be_read32(&th.ne_east); th.ne_north = be_read32(&th.ne_north); max_points = (131080 - sizeof(gbuint32) - sizeof(th)) / sizeof(humminbird_trk_point_t); if (th.num_points > max_points) fatal(MYNAME ": Too many track points! (%d)\n", th.num_points); /* num_points is actually one too big, because it includes the value in the header. But we want the extra point at the end because the freak-value filter below looks at points[i+1] */ points = xcalloc(th.num_points, sizeof(humminbird_trk_point_t)); if (! gbfread(points, sizeof(humminbird_trk_point_t), th.num_points-1, fin)) fatal(MYNAME ": Unexpected end of file reading points!\n"); accum_east = th.start_east; accum_north = th.start_north; trk = route_head_alloc(); track_add_head(trk); trk->rte_name = xstrndup(th.name, sizeof(th.name)); trk->rte_num = th.trk_num; /* We create one wpt for the info in the header */ first_wpt = waypt_new(); g_lat = gudermannian_i1924(accum_north); first_wpt->latitude = geocentric_to_geodetic_hwr(g_lat); first_wpt->longitude = accum_east/EAST_SCALE * 180.0; first_wpt->altitude = 0.0; /* No depth info in the header. */ track_add_wpt(trk, first_wpt); for(i=0 ; i<th.num_points-1 ; i++) { waypoint *wpt = waypt_new(); gbint16 next_deltaeast, next_deltanorth; double guder; points[i].depth = be_read16(&points[i].depth); points[i].deltaeast = be_read16(&points[i].deltaeast); points[i].deltanorth = be_read16(&points[i].deltanorth); /* Every once in a while the delta values are 32767 followed by -32768. Filter that. */ next_deltaeast = be_read16(&points[i+1].deltaeast); if (points[ i ].deltaeast == 32767 && next_deltaeast == -32768) { points[ i ].deltaeast = -1; points[i+1].deltaeast = 0; /* BE 0 == LE 0 */ } next_deltanorth = be_read16(&points[i+1].deltanorth); if (points[ i ].deltanorth == 32767 && next_deltanorth == -32768) { points[ i ].deltanorth = -1; points[i+1].deltanorth = 0; } accum_east += points[i].deltaeast; accum_north += points[i].deltanorth; guder = gudermannian_i1924(accum_north); wpt->latitude = geocentric_to_geodetic_hwr(guder); wpt->longitude = accum_east/EAST_SCALE * 180.0; wpt->altitude = 0.0; if (points[i].depth != 0) WAYPT_SET(wpt,depth,(double)points[i].depth / 100.0); if (i == th.num_points-2 && th.time != 0) { /* Last point. Add the date from the header. */ /* Unless it's zero. Sometimes happens, possibly if the gps didn't have a lock when the track was saved. */ wpt->creation_time = th.time; } track_add_wpt(trk, wpt); } xfree(points); }
static void parse_waypoint(void) { char *str; int column = -1; waypoint *wpt; garmin_fs_p gmsd = NULL; bind_fields(waypt_header); wpt = waypt_new(); gmsd = garmin_fs_alloc(-1); fs_chain_add(&wpt->fs, (format_specific_data *) gmsd); while ((str = csv_lineparse(NULL, "\t", "", column++))) { int i, dynamic; double d; int field_no = header_fields[waypt_header][column]; switch(field_no) { case 1: wpt->shortname = DUPSTR(str); break; case 2: wpt->notes = DUPSTR(str); break; case 3: for (i = 0; i <= gt_waypt_class_map_line; i++) { if (case_ignore_strcmp(str, gt_waypt_class_names[i]) == 0) { GMSD_SET(wpt_class, i); break; } } break; case 4: parse_coordinates(str, datum_index, grid_index, &wpt->latitude, &wpt->longitude, MYNAME); break; case 5: if (parse_distance(str, &d, 1, MYNAME)) wpt->altitude = d; break; case 6: if (parse_distance(str, &d, 1, MYNAME)) WAYPT_SET(wpt, depth, d); break; case 7: if (parse_distance(str, &d, 1, MYNAME)) WAYPT_SET(wpt, proximity, d); break; case 8: if (parse_temperature(str, &d)) WAYPT_SET(wpt, temperature, d); break; case 9: if (parse_display(str, &i)) GMSD_SET(display, i); break; case 10: break; /* skip color */ case 11: i = gt_find_icon_number_from_desc(str, GDB); GMSD_SET(icon, i); wpt->icon_descr = gt_find_desc_from_icon_number(i, GDB, &dynamic); wpt->wpt_flags.icon_descr_is_dynamic = dynamic; break; case 12: GMSD_SETSTR(facility, str); break; case 13: GMSD_SETSTR(city, str); break; case 14: GMSD_SETSTR(state, str); break; case 15: GMSD_SETSTR(country, str); GMSD_SETSTR(cc, gt_get_icao_cc(str, wpt->shortname)); break; case 16: parse_date_and_time(str, &wpt->creation_time); break; case 17: wpt->url = DUPSTR(str); break; case 18: GMSD_SET(category, parse_categories(str)); break; default: break; } } waypt_add(wpt); }
static void unicsv_parse_one_line(char *ibuf) { char *s; waypoint *wpt = NULL; int column; int utm_zone = -9999; double utm_easting = 0; double utm_northing = 0; char utm_zc = 'N'; char bng_zone[3] = ""; double bng_easting = 0; double bng_northing = 0; double swiss_easting = unicsv_unknown; double swiss_northing = unicsv_unknown; int checked = 0; time_t date = -1, time = -1; int msec = -1; char is_localtime = 0; garmin_fs_t *gmsd; double d; struct tm ymd; int src_datum = unicsv_datum_idx; int ns = 1; int ew = 1; #ifdef UNICSV_GC_READY geocache_data *gc_data = NULL; #endif wpt = waypt_new(); wpt->latitude = unicsv_unknown; wpt->longitude = unicsv_unknown; memset(&ymd, 0, sizeof(ymd)); column = -1; while ((s = csv_lineparse(ibuf, unicsv_fieldsep, "\"", 0))) { if (column > unicsv_fields_tab_ct) break; /* ignore extra fields on line */ ibuf = NULL; column++; checked++; s = lrtrim(s); if (! *s) continue; /* skip empty columns */ switch(unicsv_fields_tab[column]) { case fld_time: case fld_date: case fld_datetime: /* switch column type if it looks like an iso time string */ if (strchr(s, 'T')) unicsv_fields_tab[column] = fld_iso_time; break; default: ; } switch(unicsv_fields_tab[column]) { case fld_latitude: human_to_dec( s, &wpt->latitude, &wpt->longitude, 1 ); wpt->latitude = wpt->latitude * ns; break; case fld_longitude: human_to_dec( s, &wpt->latitude, &wpt->longitude, 2 ); wpt->longitude = wpt->longitude * ew; break; case fld_shortname: wpt->shortname = xstrdup(s); break; case fld_description: wpt->description = xstrdup(s); break; case fld_notes: wpt->notes = xstrdup(s); break; case fld_url: wpt->url = xstrdup(s); break; case fld_altitude: if (parse_distance(s, &d, unicsv_altscale, MYNAME)) { if (fabs(d) < fabs(unknown_alt)) wpt->altitude = d; } break; case fld_utm_zone: utm_zone = atoi(s); break; case fld_utm_easting: utm_easting = atof(s); break; case fld_utm_northing: utm_northing = atof(s); break; case fld_utm_zone_char: utm_zc = toupper(s[0]); break; case fld_utm: parse_coordinates(s, unicsv_datum_idx, grid_utm, &wpt->latitude, &wpt->longitude, MYNAME); /* coordinates from parse_coordinates are in WGS84 don't convert a second time */ src_datum = DATUM_WGS84; break; case fld_bng: parse_coordinates(s, DATUM_OSGB36, grid_bng, &wpt->latitude, &wpt->longitude, MYNAME); /* coordinates from parse_coordinates are in WGS84 don't convert a second time */ src_datum = DATUM_WGS84; break; case fld_bng_zone: strncpy(bng_zone, s, sizeof(bng_zone)); strupper(bng_zone); break; case fld_bng_northing: bng_northing = atof(s); break; case fld_bng_easting: bng_easting = atof(s); break; case fld_swiss: parse_coordinates(s, DATUM_WGS84, grid_swiss, &wpt->latitude, &wpt->longitude, MYNAME); /* coordinates from parse_coordinates are in WGS84 don't convert a second time */ src_datum = DATUM_WGS84; break; case fld_swiss_easting: swiss_easting = atof(s); break; case fld_swiss_northing: swiss_northing = atof(s); break; case fld_hdop: wpt->hdop = atof(s); if (unicsv_detect) unicsv_data_type = trkdata; break; case fld_pdop: wpt->pdop = atof(s); if (unicsv_detect) unicsv_data_type = trkdata; break; case fld_vdop: wpt->vdop = atof(s); if (unicsv_detect) unicsv_data_type = trkdata; break; case fld_sat: wpt->sat = atoi(s); if (unicsv_detect) unicsv_data_type = trkdata; break; case fld_fix: if (unicsv_detect) unicsv_data_type = trkdata; if (case_ignore_strcmp(s, "none") == 0) wpt->fix = fix_none; else if (case_ignore_strcmp(s, "2d") == 0) wpt->fix = fix_2d; else if (case_ignore_strcmp(s, "3d") == 0) wpt->fix = fix_3d; else if (case_ignore_strcmp(s, "dgps") == 0) wpt->fix = fix_dgps; else if (case_ignore_strcmp(s, "pps") == 0) wpt->fix = fix_pps; else wpt->fix = fix_unknown; break; case fld_utc_date: if ((is_localtime < 2) && (date < 0)) { date = unicsv_parse_date(s, NULL); is_localtime = 0; } break; case fld_utc_time: if ((is_localtime < 2) && (time < 0)) { time = unicsv_parse_time(s, &msec, &date); is_localtime = 0; } break; case fld_speed: if (parse_speed(s, &d, 1.0, MYNAME)) { WAYPT_SET(wpt, speed, d); if (unicsv_detect) unicsv_data_type = trkdata; } break; case fld_course: WAYPT_SET(wpt, course, atof(s)); if (unicsv_detect) unicsv_data_type = trkdata; break; case fld_temperature: d = atof(s); if (fabs(d) < 999999) WAYPT_SET(wpt, temperature, d); break; case fld_temperature_f: d = atof(s); if (fabs(d) < 999999) WAYPT_SET(wpt, temperature, FAHRENHEIT_TO_CELSIUS(d)); break; case fld_heartrate: wpt->heartrate = atoi(s); if (unicsv_detect) unicsv_data_type = trkdata; break; case fld_cadence: wpt->cadence = atoi(s); if (unicsv_detect) unicsv_data_type = trkdata; break; case fld_proximity: if (parse_distance(s, &d, unicsv_proximityscale, MYNAME)) WAYPT_SET(wpt, proximity, d); break; case fld_depth: if (parse_distance(s, &d, unicsv_depthscale, MYNAME)) WAYPT_SET(wpt, depth, d); break; case fld_symbol: wpt->icon_descr = xstrdup(s); wpt->wpt_flags.icon_descr_is_dynamic = 1; break; case fld_iso_time: is_localtime = 2; /* fix result */ wpt->creation_time = xml_parse_time(s, &wpt->microseconds); break; case fld_time: if ((is_localtime < 2) && (time < 0)) { time = unicsv_parse_time(s, &msec, &date); is_localtime = 1; } break; case fld_date: if ((is_localtime < 2) && (date < 0)) { date = unicsv_parse_date(s, NULL); is_localtime = 1; } break; case fld_year: ymd.tm_year = atoi(s); break; case fld_month: ymd.tm_mon = atoi(s); break; case fld_day: ymd.tm_mday = atoi(s); break; case fld_hour: ymd.tm_hour = atoi(s); break; case fld_min: ymd.tm_min = atoi(s); break; case fld_sec: ymd.tm_sec = atoi(s); break; case fld_datetime: if ((is_localtime < 2) && (date < 0) && (time < 0)) { time = unicsv_parse_time(s, &msec, &date); is_localtime = 1; } break; case fld_ns: ns = tolower(s[0]) == 'n' ? 1 : -1; wpt->latitude *= ns; break; case fld_ew: ew = tolower(s[0]) == 'e' ? 1 : -1; wpt->longitude *= ew; break; case fld_garmin_city: case fld_garmin_postal_code: case fld_garmin_state: case fld_garmin_country: case fld_garmin_addr: case fld_garmin_phone_nr: case fld_garmin_phone_nr2: case fld_garmin_fax_nr: case fld_garmin_email: case fld_garmin_facility: gmsd = GMSD_FIND(wpt); if (! gmsd) { gmsd = garmin_fs_alloc(-1); fs_chain_add(&wpt->fs, (format_specific_data *) gmsd); } switch(unicsv_fields_tab[column]) { case fld_garmin_city: GMSD_SETSTR(city, s); break; case fld_garmin_postal_code: GMSD_SETSTR(postal_code, s); break; case fld_garmin_state: GMSD_SETSTR(state, s); break; case fld_garmin_country: GMSD_SETSTR(country, s); break; case fld_garmin_addr: GMSD_SETSTR(addr, s); break; case fld_garmin_phone_nr: GMSD_SETSTR(phone_nr, s); break; case fld_garmin_phone_nr2: GMSD_SETSTR(phone_nr2, s); break; case fld_garmin_fax_nr: GMSD_SETSTR(fax_nr, s); break; case fld_garmin_email: GMSD_SETSTR(email, s); break; case fld_garmin_facility: GMSD_SETSTR(facility, s); break; default: break; } break; #ifdef UNICSV_GC_READY case fld_gc_id: case fld_gc_type: case fld_gc_container: case fld_gc_terr: case fld_gc_diff: case fld_gc_is_archived: case fld_gc_is_available: case fld_gc_exported: case fld_gc_last_found: case fld_gc_placer: case fld_gc_placer_id: case fld_gc_hint: gc_data = waypt_alloc_gc_data(wpt); switch(unicsv_fields_tab[column]) { case fld_gc_id: gc_data->id = atoi(s); if (gc_data->id == 0) gc_data->id = unicsv_parse_gc_id(s); break; case fld_gc_type: gc_data->type = gs_mktype(s); break; case fld_gc_container: gc_data->container = gs_mkcont(s); break; case fld_gc_terr: gc_data->terr = atof(s) * 10; break; case fld_gc_diff: gc_data->diff = atof(s) * 10; break; case fld_gc_is_archived: gc_data->is_archived = unicsv_parse_status(s); break; case fld_gc_is_available: gc_data->is_available = unicsv_parse_status(s); break; case fld_gc_exported: { time_t time, date; int msec; time = unicsv_parse_time(s, &msec, &date); if (date || time) gc_data->exported = unicsv_adjust_time(time, &date); } break; case fld_gc_last_found: { time_t time, date; int msec; time = unicsv_parse_time(s, &msec, &date); if (date || time) gc_data->last_found = unicsv_adjust_time(time, &date); } break; case fld_gc_placer: gc_data->placer = xstrdup(s); break; case fld_gc_placer_id: gc_data->placer_id = atoi(s); break; case fld_gc_hint: gc_data->hint = xstrdup(s); break; default: break; } break; #endif case fld_terminator: /* dummy */ checked--; break; } } if (checked == 0) { waypt_free(wpt); return; } if (is_localtime < 2) { /* not fixed */ if ((time >= 0) && (date >= 0)) { time_t t = date + time; if (is_localtime) { struct tm tm; tm = *gmtime(&t); if (opt_utc) wpt->creation_time = mkgmtime(&tm); else wpt->creation_time = mklocaltime(&tm); } else wpt->creation_time = t; } else if (time >= 0) wpt->creation_time = time; else if (date >= 0) wpt->creation_time = date; else if (ymd.tm_year || ymd.tm_mon || ymd.tm_mday) { if (ymd.tm_year < 100) { if (ymd.tm_year <= 70) ymd.tm_year += 2000; else ymd.tm_year += 1900; } ymd.tm_year -= 1900; if (ymd.tm_mon == 0) ymd.tm_mon = 1; if (ymd.tm_mday == 0) ymd.tm_mday = 1; ymd.tm_mon--; if (opt_utc) wpt->creation_time = mkgmtime(&ymd); else wpt->creation_time = mklocaltime(&ymd); } else if (ymd.tm_hour || ymd.tm_min || ymd.tm_sec) { if (opt_utc) wpt->creation_time = mkgmtime(&ymd); else wpt->creation_time = mklocaltime(&ymd); } if (msec >= 0) wpt->microseconds = msec; if (opt_utc) wpt->creation_time += atoi(opt_utc) * SECONDS_PER_HOUR; } /* utm/bng/swiss can be optional */ if ((wpt->latitude == unicsv_unknown) && (wpt->longitude == unicsv_unknown)) { if (utm_zone != -9999) { GPS_Math_UTM_EN_To_Known_Datum(&wpt->latitude, &wpt->longitude, utm_easting, utm_northing, utm_zone, utm_zc, unicsv_datum_idx); } else if (bng_zone[0]) { if (! GPS_Math_UKOSMap_To_WGS84_M( bng_zone, bng_easting, bng_northing, &wpt->latitude, &wpt->longitude)) fatal(MYNAME ": Unable to convert BNG coordinates (%s %.f %.f)!\n", bng_zone, bng_easting, bng_northing); src_datum = DATUM_WGS84; /* don't convert afterwards */ } else if ((swiss_easting != unicsv_unknown) && (swiss_northing != unicsv_unknown)) { GPS_Math_Swiss_EN_To_WGS84(swiss_easting, swiss_northing, &wpt->latitude, &wpt->longitude); src_datum = DATUM_WGS84; /* don't convert afterwards */ } } if ((src_datum != DATUM_WGS84) && (wpt->latitude != unicsv_unknown) && (wpt->longitude != unicsv_unknown)) { double alt; GPS_Math_Known_Datum_To_WGS84_M(wpt->latitude, wpt->longitude, (double) 0.0, &wpt->latitude, &wpt->longitude, &alt, src_datum); } switch(unicsv_data_type) { case rtedata: if (! unicsv_route) { unicsv_route = route_head_alloc(); route_add_head(unicsv_route); } route_add_wpt(unicsv_route, wpt); break; case trkdata: if (! unicsv_track) { unicsv_track = route_head_alloc(); track_add_head(unicsv_track); } track_add_wpt(unicsv_track, wpt); break; default: waypt_add(wpt); } }
static void lowranceusr_parse_waypt(waypoint *wpt_tmp) { char buff[MAXUSRSTRINGSIZE + 1]; int text_len; time_t waypt_time; short waypt_type; wpt_tmp->latitude = lat_mm_to_deg(gbfgetint32(file_in)); wpt_tmp->longitude = lon_mm_to_deg(gbfgetint32(file_in)); wpt_tmp->altitude = FEET_TO_METERS(gbfgetint32(file_in)); if (wpt_tmp->altitude <= UNKNOWN_USR_ALTITUDE) { wpt_tmp->altitude = unknown_alt; } text_len = lowranceusr_readstr(&buff[0], MAXUSRSTRINGSIZE, file_in); if (text_len) { buff[text_len] = '\0'; wpt_tmp->shortname = xstrdup(buff); } if (global_opts.debug_level >= 1) printf(MYNAME " parse_waypt: Waypt name = %s Lat = %f Lon = %f alt = %f\n",wpt_tmp->shortname, wpt_tmp->latitude, wpt_tmp->longitude, wpt_tmp->altitude); text_len = lowranceusr_readstr(&buff[0], MAXUSRSTRINGSIZE, file_in); if (text_len) { buff[text_len] = '\0'; wpt_tmp->description = xstrdup(buff); } /* Time is number of seconds since Jan. 1, 2000 */ waypt_time = gbfgetint32(file_in); if (waypt_time) wpt_tmp->creation_time = base_time_secs + waypt_time; if (global_opts.debug_level >= 2) { printf(MYNAME " parse_waypt: creation time %d\n", (int)wpt_tmp->creation_time); printf(MYNAME " parse_waypt: base_time %d\n", (int)base_time_secs); printf(MYNAME " parse_waypt: waypt time %d\n", (int)waypt_time); } /* Symbol ID */ wpt_tmp->icon_descr = lowranceusr_find_desc_from_icon_number(gbfgetint32(file_in)); if (!wpt_tmp->icon_descr[0]) { char nbuf[10]; snprintf(nbuf, sizeof(nbuf), "%d", le_read32(buff)); wpt_tmp->wpt_flags.icon_descr_is_dynamic = 1; wpt_tmp->icon_descr = xstrdup(nbuf); } /* Waypoint Type (USER, TEMPORARY, POINT_OF_INTEREST) */ waypt_type = gbfgetint16(file_in); if (global_opts.debug_level >= 1) printf(MYNAME " parse_waypt: waypt_type = %d\n",waypt_type); // Version 3 has a depth field here. if (reading_version >= 3) { float depth_feet = gbfgetflt(file_in); if (abs(depth_feet - 99999.0) > .1) WAYPT_SET(wpt_tmp, depth, FEET_TO_METERS(depth_feet)); } }