예제 #1
0
static void
lowranceusr_parse_routes(void)
{
	char buff[MAXUSRSTRINGSIZE + 1];
	short int num_routes, num_legs;
	int i,j;
	int text_len;
	waypoint *wpt_tmp;

	num_routes = gbfgetint16(file_in);

	if (global_opts.debug_level >= 1)
		printf(MYNAME " parse_routes: Num Routes = %d\n", num_routes);

	for (i=0; i < num_routes; i++)
	{
		rte_head = route_head_alloc();
		route_add_head(rte_head);
		rte_head->rte_num = i+1;

		/* route name */
		text_len = lowranceusr_readstr(&buff[0], MAXUSRSTRINGSIZE, file_in);
		if (text_len)
		{
			buff[text_len] = '\0';
			rte_head->rte_name = xstrdup(buff);
		}
		rte_head->rte_desc = '\0';	/* ???????? */

		/* num Legs */
		num_legs = gbfgetint16(file_in);

		/* route reversed */
		(void) gbfread(&buff[0], 1, 1, file_in);

		/* waypoints */
		for (j=0; j < num_legs; j++)
		{
			wpt_tmp = waypt_new();
			lowranceusr_parse_waypt(wpt_tmp);
			route_add_wpt(rte_head, wpt_tmp);
		}
	}
}
예제 #2
0
static void
data_read(void)
{
	short int NumWaypoints, MajorVersion, MinorVersion, object_num;
	int i;

	MajorVersion = gbfgetint16(file_in);
	reading_version = MajorVersion;
	MinorVersion = gbfgetint16(file_in);
	
	if (global_opts.debug_level >= 1)
		printf(MYNAME " data_read: Major Version %d Minor Version %d\n", MajorVersion, MinorVersion);

	if (MajorVersion < 2) {
		fatal(MYNAME ": input file is from an old version of the USR file and is not supported\n");
	}

	NumWaypoints = gbfgetint16(file_in);

	if (global_opts.debug_level >= 1)
		printf(MYNAME " data_read: Num waypoints %d\n", NumWaypoints);

	for (i = 0; i < NumWaypoints; i++) {
		waypoint *wpt_tmp;

		wpt_tmp = waypt_new();

		/* Object num */
		object_num = gbfgetint16(file_in);
		if (global_opts.debug_level >= 1)
			printf(MYNAME " data_read: object_num = %d\n", object_num);

		/* waypoint */
		lowranceusr_parse_waypt(wpt_tmp);

		waypt_add(wpt_tmp);
	}

	lowranceusr_parse_routes();
	lowranceusr_parse_icons();
	lowranceusr_parse_trails();
}
예제 #3
0
/*
 * Icons are automatically converted to waypoints unless
 * option of ignoreicons is used
 */
static void
lowranceusr_parse_icons(void)
{
	char buff[MAXUSRSTRINGSIZE + 1];
	short int num_icons;
	int i;

	num_icons = gbfgetint16(file_in);

	if (global_opts.debug_level >= 1)
		printf(MYNAME " parse_icons: num Icons = %d\n", num_icons);

	for (i=0; i < num_icons; i++)
	{
		if (ignoreicons)
		{
			/* position coord lat & long */
			(void) gbfread(&buff[0], 4, 2, file_in);
			/* symbol */
			(void) gbfread(&buff[0], 4, 1, file_in);
		}
		else
		{
			waypoint *wpt_tmp;
			wpt_tmp = waypt_new();

			/* position coord lat & long */
			wpt_tmp->latitude = lat_mm_to_deg(gbfgetint32(file_in));
			wpt_tmp->longitude = lon_mm_to_deg(gbfgetint32(file_in));
			wpt_tmp->altitude = 0;
			snprintf(buff, sizeof(buff), "Icon %d", i+1);
			wpt_tmp->shortname = xstrdup(buff);
			/* symbol */
			wpt_tmp->icon_descr = lowranceusr_find_desc_from_icon_number(gbfgetint32(file_in));
			waypt_add(wpt_tmp);
		}
	}

}
예제 #4
0
파일: xol.c 프로젝트: alexbirkett/GPSBabel
static void
xol_shape(const char *args, const char **attrv)
{
	const char **avp = &attrv[0];

        while (*avp) {
		if (strcmp(avp[0], "type") == 0) {
			if (strcmp(avp[1], "waypoint") == 0) {
				wpt = waypt_new();
			}
			else if (strcmp(avp[1], "polyline") == 0) {
				trk = route_head_alloc();
				track_add_head(trk);
			}
		}
		else if (strcmp(avp[0], "name") == 0) {
			if (wpt) wpt->shortname = xstrdup(avp[1]);
			else if (trk) trk->rte_name = xstrdup(avp[1]);
		}
		else if (strcmp(avp[0], "comment") == 0) {
			if (wpt) wpt->notes = xstrdup(avp[1]);
		}
		else if (strcmp(avp[0], "alt") == 0) {
			if (wpt) wpt->altitude = atof(avp[1]);
		}
		else if (strcmp(avp[0], "timestamp") == 0) {
			if (wpt) wpt->creation_time = xml_parse_time(avp[1], &wpt->microseconds);
		}
		else if (strcmp(avp[0], "icon") == 0) {
			if (wpt) {
				wpt->icon_descr = xstrdup(avp[1]);
				wpt->wpt_flags.icon_descr_is_dynamic = 1;
			}
		}

		avp+=2;
	}
}
예제 #5
0
void trk_coord(const char *args, const char **attrv)
{
	int consumed = 0;
	double lat, lon, alt;
	waypoint *trkpt;

	route_head *trk_head = route_head_alloc();
	if (wpt_tmp->shortname) {
		trk_head->rte_name  = xstrdup(wpt_tmp->shortname);
	}
	track_add_head(trk_head);
	
	while (3 == sscanf(args, "%lf,%lf,%lf %n", &lon, &lat, &alt, &consumed)){
		trkpt = waypt_new();	
		trkpt->latitude = lat;
		trkpt->longitude = lon;
		trkpt->altitude = alt;

		track_add_wpt(trk_head, trkpt);

		args += consumed;
	}
}
예제 #6
0
static void
mmo_read_CObjTrack(mmo_data_t *data)
{
#ifdef MMO_DBG
	const char *sobj = "CObjTrack";
#endif
	int tp, ctp;
	route_head *trk;

	DBG((sobj, ":-----------------------------------------------------\n"));
	DBG((sobj, "name = \"%s\" [ visible=%s, id=0x%04X ]\n", 
		data->name, data->visible ? "yes" : "NO", data->objid));

	trk = route_head_alloc();
	trk->rte_name = xstrdup(data->name);
	track_add_head(trk);

	tp = gbfgetint16(fin);
	DBG((sobj, "track has %d point(s)\n", tp));

	for (ctp = 0; ctp < tp; ctp++) {
		waypoint *wpt;
		char unk;
		
		wpt = waypt_new();
		
		wpt->latitude = gbfgetdbl(fin);
		wpt->longitude = gbfgetdbl(fin);
		unk = gbfgetc(fin);
		
		wpt->creation_time = gbfgetint32(fin);
		wpt->altitude = gbfgetflt(fin);

		if (unk != 0) {
			gbuint16 ux;
			ux = gbfgetuint16(fin);
			DBG((sobj, "u16 = %04X (%d)\n", ux, ux));
			if (unk > 1) {
				gbuint16 ux;
				ux = gbfgetuint16(fin);
				DBG((sobj, "u16 = %04X (%d)\n", ux, ux));
			}
		}
		track_add_wpt(trk, wpt);
	}
	
	if (mmo_version > 0) {
		gbuint32 u32;
		
		u32 = gbfgetuint32(fin); 	/* Min. update interval */
		DBG((sobj, "min. update interval = %d\n", u32));
		u32 = gbfgetuint32(fin); 	/* unknown */
//		DBG((sobj, "unknown value = 0x%8X (%d)\n", u32, u32));
		u32 = gbfgetuint32(fin); 	/* unknown */
//		DBG((sobj, "unknown value = 0x%8X (%d)\n", u32, u32));
		u32 = gbfgetuint32(fin); 	/* unknown */
		DBG((sobj, "min. update distance = %d\n", u32));
		u32 = gbfgetuint32(fin); 	/* unknown */
		DBG((sobj, "track partition interval = %d\n", u32 / 60));
		u32 = gbfgetuint32(fin); 	/* unknown */
//		DBG((sobj, "unknown value = 0x%8X (%d)\n", u32, u32));
		u32 = gbfgetuint32(fin); 	/* unknown */
		DBG((sobj, "tick interval = %d\n", u32 / 60));
		trk->line_color.bbggrr = gbfgetuint32(fin); 	/* rgb color */
		trk->line_color.opacity = 255;
		DBG((sobj, "color = 0x%06X\n", trk->line_color.bbggrr));
	}

	if (mmo_version >= 0x12) {
		char u8;
		
		u8 = gbfgetc(fin);
		DBG((sobj, "line width = %d - (since 0x12)\n", u8));
		u8 = gbfgetc(fin);
		DBG((sobj, "line style = %d - (since 0x12)\n", u8));
		u8 = gbfgetc(fin);
		DBG((sobj, "transparency = %d - (since 0x12)\n", u8));
		trk->line_color.opacity = 255 - (u8 * 51);

		if (mmo_version >= 0x16) {
			char u8;
			gbuint16 u16;
			
			u8 = gbfgetc(fin);
//			DBG((sobj, "u8 = 0x%X (since 0x16)\n", u8));
			u16 = gbfgetuint16(fin);
//			DBG((sobj, "u16 = 0x%X (since 0x16)\n", u16));
			u16 = gbfgetuint16(fin);
//			DBG((sobj, "u16 = 0x%X (since 0x16)\n", u16));
		}
	}
	
	if (trk->rte_waypt_ct == 0) {
		track_del_head(trk);
		data->data = NULL;
	}
}
예제 #7
0
static void
mmo_read_CObjWaypoint(mmo_data_t *data)
{
#ifdef MMO_DBG
	const char *sobj = "CObjWaypoint";
#endif
	waypoint *wpt;
	time_t time;
	int rtelinks;
	mmo_data_t **rtelink = NULL;
	char *str;
	char buf[16];
	int i, ux;
	
	DBG((sobj, ":-----------------------------------------------------\n"));
	DBG((sobj, "name = \"%s\" [ visible=%s, id=0x%04X ]\n", 
		data->name, data->visible ? "yes" : "NO", data->objid));

	wpt = waypt_new();
	wpt->shortname = xstrdup(data->name);

	time = data->mtime;
	if (! time) time = data->ctime;
	if (time > 0) wpt->creation_time = time;

	wpt->latitude = gbfgetdbl(fin);
	wpt->longitude = gbfgetdbl(fin);

	DBG((sobj, "coordinates = %f / %f\n", wpt->latitude, wpt->longitude));

	rtelinks = gbfgetuint16(fin);
	if (rtelinks > 0) {

		rtelink = xcalloc(sizeof(*rtelink), rtelinks);
		DBG((sobj, "rtelinks = %d\n", rtelinks));

		for (i = 0; i < rtelinks; i++) {
			mmo_data_t *tmp;
			int objid;			

			DBG((sobj, "read rtelink number %d\n", i + 1));

			objid = gbfgetuint16(fin);
			gbfseek(fin, -2, SEEK_CUR);

			rtelink[i] = tmp = mmo_read_object(wpt);
			
			if ((objid < 0x8000) && (tmp != NULL) && (tmp->type == rtedata)) {
				route_head *rte = tmp->data;

				tmp->left--;
				route_add_wpt(rte, waypt_dupe(wpt));

				DBG((sobj, "\"%s\" Added to route \"%s\"\n", wpt->shortname, rte->rte_name));
			}
		}

	}
	
	str = mmo_readstr();	/* descr + url */
	if (strncmp(str, "_FILE_ ", 7) == 0) {
		char *cx, *cend;
		
		cx = lrtrim(str + 7);
		cend = strchr(cx, '\n');
		if (cend == NULL) cend = cx + strlen(cx);
		
		cx = lrtrim(xstrndup(cx, cend - cx));
		if (*cx) wpt->url = cx;
		else xfree(cx);

		if (*cend++) wpt->notes = xstrdup(cend);
		
		if (wpt->url) DBG((sobj, "url = \"%s\"\n", wpt->url));
	}
	else
		if (*str) wpt->notes = xstrdup(str);
	xfree(str);

	if (wpt->notes) DBG((sobj, "notes = \"%s\"\n", wpt->notes));

	mmo_fillbuf(buf, 12, 1);
	i = le_read32(&buf[8]);		/* icon */
	if (i != -1) {
		char key[16];
		char *name;
		
		snprintf(key, sizeof(key), "%d", i);
		if (avltree_find(icons, key, (void *)&name)) {
			wpt->icon_descr = xstrdup(name);
			wpt->wpt_flags.icon_descr_is_dynamic = 1;
			DBG((sobj, "icon = \"%s\"\n", wpt->icon_descr));
		}
	}

	wpt->proximity = le_read_float(&buf[4]);
	if (wpt->proximity) {
		wpt->wpt_flags.proximity = 1;
		DBG((sobj, "proximity = %f\n", wpt->proximity));
	}

	str = mmo_readstr();	/* name on gps ??? option ??? */
	if (*str) {
		wpt->description = wpt->shortname;
		wpt->shortname = str;
		DBG((sobj, "name on gps = %s\n", str));
	}
	else xfree(str);

	ux = gbfgetuint32(fin);
	DBG((sobj, "proximity type = %d\n", ux));

	if (rtelinks) {
		int i;

		for (i = 0; i < rtelinks; i++) {
			int j;
			route_head *rte = rtelink[i]->data;

			for (j = 0; j < rtelinks; j++) {
				if ((i != j) && (rtelink[i] == rtelink[j])) {
					rtelink[i]->loop = 1;
					break;
				}
			}
			rtelink[i]->done++;
			if ((rtelink[i]->left == 0) && (rtelink[i]->done == rte->rte_waypt_ct)) {
				if (mmo_version <= 0x11) mmo_end_of_route(rtelink[i]);
			}
		}
	}

	if (rtelink) {
		xfree(rtelink);
		waypt_free(wpt);
		data->data = NULL;
	}
	else waypt_add(wpt);
}
예제 #8
0
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);
}
예제 #9
0
static void
format_garmin_xt_proc_atrk(void)
{
	gbuint16	block=0, uu=0;
	gbuint32	Lat=0, Lon=0;
	gbuint32	Tim=0;
	double		LatF = 0, LonF = 0, AltF = 0;
	waypoint	*wpt;
	int		method = 0;
	unsigned char 	buf[3];
	gbint32 	num_trackpoints;

	// get the option for the processing the track name
	if ( opt_trk_header )
	{
		method = atoi(opt_trk_header);
	}

	if (! track) {
		track = route_head_alloc();
		// header option was not set to ignore
		if ( method !=1 )
		{
			track->rte_name = xstrdup("ATRK XT");
		}
		track_add_head(track);
	}

	// We think the word at offset 0xc is the trackpoint count.
	gbfseek(fin, 12, SEEK_SET);
	num_trackpoints = gbfgetuint32(fin);
	
	while (num_trackpoints--) {
		block = gbfgetuint16(fin);
		if (block != 0x0c)
			break;
			
		gbfread(&buf, 3, DATABLOCKSIZE, fin); //1. Lat
		Lat = buf[0] | (buf[1] << 8) | (buf[2] << 16);
		gbfread(&buf, 3, DATABLOCKSIZE, fin); //2. Lon
		Lon = buf[0] | (buf[1] << 8) | (buf[2] << 16);

		uu = gbfgetuint16(fin);
		Tim = gbfgetuint32(fin);

		Tim += 631065600; // adjustment to UnixTime
		LatF = Lat;
		if (LatF>8388608) {LatF -= 16777216;};
		LonF = Lon;
		if (LonF>8388608) {LonF -= 16777216;};
		AltF = (double)uu * GARMIN_XT_ELE - 1500;

		//create new waypoint
		wpt = waypt_new();

		//populate wpt;
		wpt->latitude = LatF*180/16777216;	/* Degrees */
		wpt->longitude = LonF*360/16777216; 	/* Degrees */
		wpt->altitude = AltF; 			/* Meters. */
		wpt->creation_time = Tim;  		/* Unix Time adjusted to Garmin time */

		track_add_wpt(track, wpt);
	}
}
예제 #10
0
static void
nav_start(void *data, const XML_Char *xml_el, const XML_Char **xml_attr)
{
	const char *el;
	const char **attr;

	el = xml_convert_to_char_string(xml_el);
	attr = xml_convert_attrs_to_char_string(xml_attr);
	if (0 == strcmp(el, "CacheDetails")) {
		const char **ap;
		geocache_data *gc_data;
		wpt_tmp = waypt_new();
		gc_data = waypt_alloc_gc_data(wpt_tmp);
		
		for (ap = attr; *ap; ap+=2) {
			if (0 == strcmp(ap[0], "cache_id")) {
				wpt_tmp->shortname = xstrdup(ap[1]);
			} else
			if (0 == strcmp(ap[0], "name")) {
				wpt_tmp->description = xstrdup(ap[1]);
			} else
			if (0 == strcmp(ap[0], "latitude")) {
				sscanf(ap[1], "%lf", 
				&wpt_tmp->latitude);
			} else
			if (0 == strcmp(ap[0], "longitude")) {
				sscanf(ap[1], "%lf", 
				&wpt_tmp->longitude);
			} else
			if (0 == strcmp(ap[0], "longitude")) {
				sscanf(ap[1], "%lf", 
				&wpt_tmp->longitude);
			} else
			if (0 == strcmp(ap[0], "difficulty")) {
				float x;
				sscanf(ap[1], "%f", &x);
				gc_data->diff = x * 10;
			} else
			if (0 == strcmp(ap[0], "terrain")) {
				float x;
				sscanf(ap[1], "%f", &x);
				gc_data->terr = x * 10;
			} else
			if (0 == strcmp(ap[0], "cache_type")) {
				static char buf[512];

	                        gc_data->type = nc_mktype(ap[1]);
				if (!strcmp(ap[1], "normal"))
				    wpt_tmp->icon_descr = "Geocache-regular";
				else if (!strcmp(ap[1], "multi-part"))
				    wpt_tmp->icon_descr = "Geocache-multi";
				else if (!strcmp(ap[1], "moving_travelling"))
				    wpt_tmp->icon_descr = "Geocache-moving";
				else {
				    sprintf(buf, "Geocache-%-.20s", ap[1]);
				    wpt_tmp->icon_descr = xstrdup(buf);
				}
			} else
			if (0 == strcmp(ap[0], "hidden_date")) {
			    struct tm tm;

			    sscanf(ap[1], "%d-%d-%d", 
				&tm.tm_year,
				&tm.tm_mon,
				&tm.tm_mday);
			    tm.tm_mon -= 1;
			    tm.tm_year -= 1900;
			    tm.tm_isdst = 0;
			    tm.tm_hour = 0;
			    tm.tm_min = 0;
			    tm.tm_sec = 0;
			    wpt_tmp->creation_time = mktime(&tm);
			} else
			if (0 == strcmp(ap[0], "retired")) {
				if (!strcmp(ap[1], "yes") && noretired) {
				    xfree(wpt_tmp);
				    return;
				}
			} else
			if (0 == strcmp(ap[0], "cache_size")) {
	                        gc_data->container = nc_mkcont(ap[1]);
			}  else
			if (0 == strcmp(ap[0], "description")) {
				gc_data->desc_long.is_html = 1;
				gc_data->desc_long.utfstring = xstrdup(ap[1]);
			} else
			if (0 == strcmp(ap[0], "comments")) {
				gc_data->desc_short.is_html = 1;
				gc_data->desc_short.utfstring = xstrdup(ap[1]);
			}
		}
		waypt_add(wpt_tmp);
	}

	xml_free_converted_attrs(attr);
	xml_free_converted_string(el);
}
예제 #11
0
static waypoint*
parse_wpt(char *buff)
{
	int col = -1;
	char *c, *cx;
	waypoint *wpt = waypt_new();
	struct tm tm;
	memset(&tm, 0, sizeof(tm));
	int has_time = 0;

	c = strstr(buff, "A ");
	if (c == buff) col++;

	c = csv_lineparse(buff, " ", "", col++);
	while (c != NULL)
	{
		c = lrtrim(c);
		if (*c != '\0')
		{
#if 0
			printf(MYNAME "_read_wpt: col(%d)=%s\n", col, c);
#endif
			switch(col)
			{
				case 0:
					
					cx = c + strlen(c) - 1;		/* trim trailing underscores */
					while ((cx >= c) && (*cx == '_')) *cx-- = '\0';
					if (*c != '\0')
						wpt->shortname = xstrdup(c);
					break;
				case 2:
					human_to_dec(c, &wpt->latitude, NULL, 1);
					break;
				case 3:
					human_to_dec(c, NULL, &wpt->longitude, 2);
					break;
				// Older compegps used a dumb constant.
				// Report are that 2010-era writes a sensible
				// value here.
				/* always "27-MAR-62 00:00:00" */
				case 4:	
					if (strcmp(c, "27-MAR-62")) {
						has_time = 1;
						compegps_parse_date(c, &tm);
					}
					break;
				case 5:
					if (has_time) {
						compegps_parse_time(c, &tm);
						wpt->creation_time = mkgmtime(&tm);
					}
				case 6:
					wpt->altitude = atof(c);
					break;
				case 7:
					wpt->description = xstrdup(c);
					break;
				default:
					if (col > 7)
					{
						wpt->description = xstrappend(wpt->description, " ");
						wpt->description = xstrappend(wpt->description, c);
					}
			}
		}
		c = csv_lineparse(NULL, " ", "", col++);
	}
	fix_datum(&wpt->latitude, &wpt->longitude);
	return wpt;
}
예제 #12
0
static void
geoniche_read_asc(void)
{
    pdbrec_t *pdb_rec;

    /* Process record 0 */
    pdb_rec = file_in->rec_list;
    if (strcmp((char *) pdb_rec->data, Rec0Magic))
	fatal(MYNAME ": Bad record 0, not a GeoNiche file.\n");
    pdb_rec = pdb_rec->next;

    /* Process the rest of the records */
    for (; pdb_rec; pdb_rec = pdb_rec->next)
    {
	waypoint	*wpt;
	char		*vdata;
	int		vlen;
	char		*p;

	int		id;
	int		route_id;
	char		*title;
	char		*category;
	double		lat, lon, alt;
	char		*datestr, *timestr;
	int		icon;
	char		*notes;
	char		gid[6+1];
	struct tm	tm;
	
	memset(&tm, 0, sizeof(tm));

	wpt = waypt_new();
	if (!wpt)
	    fatal(MYNAME ": Couldn't allocate waypoint.\n");
	vdata = (char *) pdb_rec->data;
	vlen = pdb_rec->size;

	/* Field 1: Target */
	p = field(&vdata, &vlen);
	if (!p) fatal(MYNAME ": Premature EOD processing field 1 (target).\n");
	if (strcmp(p, "Route") == 0)
	    fatal(MYNAME ": Route record type is not implemented.\n");
	if (strcmp(p, "Target"))
	    fatal(MYNAME ": Unknown record type '%s'.\n", p);
	xfree(p);

	/* Field 2: Import ID number */
	p = field(&vdata, &vlen);
	if (!p) fatal(MYNAME ": Premature EOD processing field 2 (ID).\n");
	id = atoi(p);
	xfree(p);

	/* Field 3: Title */
	p = field(&vdata, &vlen);
	if (!p) fatal(MYNAME ": Premature EOD processing field 3 (Title).\n");
	title = p;

	/* Field 4: Route ID number */
	p = field(&vdata, &vlen);
	if (!p) fatal(MYNAME ": Premature EOD processing field 4 (Route ID).\n");
	route_id = atoi(p);
	xfree(p);

	/* Field 5: Category */
	p = field(&vdata, &vlen);
	if (!p) fatal(MYNAME ": Premature EOD processing field 5 (Category).\n");
	category = p;

	/* Field 6: Latitude */
	p = field(&vdata, &vlen);
	if (!p) fatal(MYNAME ": Premature EOD processing field 6 (Latitude).\n");
	lat = atof(p);
	xfree(p);

	/* Field 7: Longitude */
	p = field(&vdata, &vlen);
	if (!p) fatal(MYNAME ": Premature EOD processing field 7 (Longitude).\n");
	lon = atof(p);
	xfree(p);

	/* Field 8: Altitude */
	p = field(&vdata, &vlen);
	if (!p) fatal(MYNAME ": Premature EOD processing field 8 (Altitude).\n");
	alt = atof(p);
	xfree(p);

	/* Field 9: Creation date */
	p = field(&vdata, &vlen);
	if (!p) fatal(MYNAME ": Premature EOD processing field 9 (Creation date).\n");
	datestr = p;

	/* Field 10: Creation time */
	p = field(&vdata, &vlen);
	if (!p) fatal(MYNAME ": Premature EOD processing field 10 (Creation time).\n");
	timestr = p;

	/* Field 11: Visited date */
	p = field(&vdata, &vlen);
	if (!p) fatal(MYNAME ": Premature EOD processing field 11 (Visited date).\n");
	xfree(p);

	/* Field 12: Visited time */
	p = field(&vdata, &vlen);
	if (!p) fatal(MYNAME ": Premature EOD processing field 12 (Visited time).\n");
	xfree(p);

	/* Field 13: Icon color (R G B) */
	p = field(&vdata, &vlen);
	if (!p) fatal(MYNAME ": Premature EOD processing field 13 (Icon color).\n");
	xfree(p);

	/* Field 14: icon number */
	p = field(&vdata, &vlen);
	if (!p) fatal(MYNAME ": Premature EOD processing field 14 (Icon number).\n");
	icon = atoi(p);
	xfree(p);

	/* Field 15: unused */
	p = field(&vdata, &vlen);
	if (!p) fatal(MYNAME ": Premature EOD processing field 15 (unused1).\n");
	xfree(p);

	/* Field 16: unused */
	p = field(&vdata, &vlen);
	if (!p) fatal(MYNAME ": Premature EOD processing field 16 (unused2).\n");
	xfree(p);

	/* Field 17: unused */
	p = field(&vdata, &vlen);
	if (!p) fatal(MYNAME ": Premature EOD processing field 17 (unused3).\n");
	xfree(p);

	/* Field 18: Notes */
	p = field(&vdata, &vlen);
	if (!p) fatal(MYNAME ": Premature EOD processing field 18 (Notes).\n");
	notes = p;

	sscanf(datestr, "%d/%d/%d", &tm.tm_mon, &tm.tm_mday, &tm.tm_year);
	tm.tm_mon -= 1;
	tm.tm_year -= 1900;
	sscanf(timestr, "%d:%d:%d", &tm.tm_hour, &tm.tm_min, &tm.tm_sec);
	if (tm.tm_year >= 1970) {
	    wpt->creation_time = mktime(&tm);
	}
	xfree(datestr);
	xfree(timestr);

	id2gid(gid, id);
	wpt->latitude = lat;
	wpt->longitude = lon;
	wpt->altitude = alt;
	wpt->icon_descr = category;
	wpt->wpt_flags.icon_descr_is_dynamic = 1;

	if (gid[0])
	{
	    wpt->shortname = xstrdup(gid);
	    wpt->description = title;
	    wpt->notes = notes;
	}
	else
	{
	    wpt->shortname = xstrdup(title);
	    wpt->description = title;
	    wpt->notes = notes;
	}

	waypt_add(wpt);
    } 
}
예제 #13
0
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);
}
예제 #14
0
static 
int ppdb_read_wpt(route_head *head, int isRoute)
{
	char *data, *str;
	double altfeet;
	struct tm tm;
	
	while (pdb_read_rec(file_in, NULL, NULL, NULL, (void *)&data) >= 0) {
		waypoint *wpt_tmp = waypt_new();
		int line = 0;
		char *tmp = data;

/* Print the whole input record. All input records are printed before processing. */
               if (global_opts.debug_level >= 5)
               {
                       DBG(("\n\
--- BEGIN Input data record -----------------------------------------------\n\
%s\n\
--- END Input data record -------------------------------------------------\n",data));
               }

		while ((str = csv_lineparse(tmp, ",", "\"", line++))) { 
		    tmp = NULL;
		    switch(line)
		    {
			case 1:		/* latitude */
			    wpt_tmp->latitude = ppdb_decode_coord(str);
			    break;
			case 2:		/* longitude */
			    wpt_tmp->longitude = ppdb_decode_coord(str);
			    break;
			case 3:		/* altitude */
			    if (*str != '\0')
			    {
				CHECK_INP(1, sscanf(str, "%lf", &altfeet), "altitude", str);
				if (altfeet != -9999) 
				    wpt_tmp->altitude = FEET_TO_METERS(altfeet);
			    }
			    break;
			case 4:		/* time and date (optional) */ 
			    memset(&tm, 0, sizeof(tm));
			    if (ppdb_decode_tm(str, &tm))
			    {
				tm.tm_year -= 1900;
				tm.tm_mon--;
				wpt_tmp->creation_time = mkgmtime(&tm);
			    }
			    break;
			case 5:		/* name */
			    if (*str != '\0')
				wpt_tmp->shortname = xstrdup(str);
			    break;
			case 6:		/* icon */
			    if (*str != '\0')
				wpt_tmp->icon_descr = xstrdup(str); 
	    			wpt_tmp->wpt_flags.icon_descr_is_dynamic = 1;
			    break;
			case 7:		/* notes */
			    if (*str != '\0')
				wpt_tmp->notes = xstrdup(str);
			    break;
			    
		    }
		}
		
/* Print the whole input record, should a warning be triggered.
 * Use warning() here instead of DBG() to print the data record
 * right after the warning is issued.
 */
               if (warn_ && (global_opts.debug_level > 1) && (global_opts.debug_level < 5))
               {
                       warning("Faulty input data record : %s\n",data);
                       warn_ = 0;
               }

		if (head && isRoute )
		    route_add_wpt(head, wpt_tmp);
		else if (head)
                    track_add_wpt(head, wpt_tmp);
		else
		    waypt_add(wpt_tmp);

	} 
예제 #15
0
static void
lowranceusr_parse_trails(void)
{
	char buff[MAXUSRSTRINGSIZE + 1];
	short int num_trails, num_trail_points, num_section_points;
	int i,j, trk_num, itmp;
	int text_len;
	waypoint *wpt_tmp;
	route_head *trk_tmp;

	/* num trails */
	num_trails = gbfgetint16(file_in);

	if (global_opts.debug_level >= 1)
		printf(MYNAME " parse_trails: num trails = %d\n", num_trails);

	for (i=trk_num=0; i < num_trails; i++)
	{
		trk_head = route_head_alloc();
		trk_head->rte_num = ++trk_num;
		track_add_head(trk_head);

		/* trail name */
		text_len = lowranceusr_readstr(&buff[0], MAXUSRSTRINGSIZE, file_in);

		if (global_opts.debug_level >= 1)
			printf(MYNAME " parse_trails: name text len = %d\n", text_len);

		if (text_len) {
			buff[text_len] = '\0';
			trk_head->rte_name = xstrdup(buff);
		}
		trk_head->rte_desc = '\0';

		if (global_opts.debug_level >= 1)
			printf(MYNAME " parse_trails: trail name = %s\n", trk_head->rte_name);

		/* visible */
		(void) gbfread(&buff[0], 1, 1, file_in);
		/* num trail points */
		num_trail_points = gbfgetint16(file_in);

		if (global_opts.debug_level >= 1)
			printf(MYNAME " parse_trails: num trail points = %d\n", num_trail_points);

		/* max trail size */
		itmp = gbfgetint16(file_in);

		if (global_opts.debug_level >= 1)
			printf(MYNAME " parse_trails: max trail size = %d\n", itmp);

		if (num_trail_points)
		{
			
			while (num_trail_points)
			{
			/* num section points */
			num_section_points = gbfgetint16(file_in);

			if (global_opts.debug_level >= 1)
				printf(MYNAME " parse_trails: num section points = %d\n", num_section_points);

				for (j=0; j < num_section_points; j++, num_trail_points--)
				{
					wpt_tmp = waypt_new();
					wpt_tmp->latitude = lat_mm_to_deg(gbfgetint32(file_in));
					wpt_tmp->longitude = lon_mm_to_deg(gbfgetint32(file_in));
					/* continuous */
					(void) gbfread(&buff[0], 1, 1, file_in);
					if (!buff[0] && seg_break && j)
					{
						trk_tmp = route_head_alloc();
						trk_tmp->rte_num = ++trk_num;
						trk_tmp->rte_name = xstrdup(trk_head->rte_name);
						trk_tmp->rte_desc = '\0';
						track_add_head(trk_tmp);
						trk_head = trk_tmp;
					}
					track_add_wpt(trk_head, wpt_tmp);
			
					if (global_opts.debug_level >= 1)
						printf(MYNAME " parse_trails: Trail pt lat %f lon %f\n", wpt_tmp->latitude, wpt_tmp->longitude);
				}
			}
		}
		/* remove the trail since it's empty */
		else track_del_head(trk_head);
	}
}
예제 #16
0
void wpt_s(const char *args, const char **unused) 
{ 
	wpt_tmp = waypt_new();
	wpt_tmp_queued = 0;
}
예제 #17
0
파일: gtm.c 프로젝트: alexbirkett/GPSBabel
static void
gtm_read(void)
{
	route_head *first_trk_head = NULL;
	route_head *trk_head = NULL;
	route_head *rte_head = NULL;
	waypoint *wpt;
	int real_tr_count = 0;
	char *route_name;
	unsigned int icon;
	int i;

	/* Image information */
	for (i = 0; i != im_count; i++) {
		fread_string_discard(file_in);
		fread_string_discard(file_in);
		fread_discard(file_in, 30);
	}

	/* Waypoints */
	for (i = 0; i != wp_count; i++) {
		wpt = waypt_new();
		wpt->latitude = fread_double(file_in);
		wpt->longitude = fread_double(file_in);
		convert_datum(&wpt->latitude, &wpt->longitude);
		wpt->shortname = fread_fixedstring(file_in, 10);
		wpt->description = fread_string(file_in);
		icon = fread_integer(file_in);
		if (icon < sizeof(icon_descr)/sizeof(char*))
			wpt->icon_descr = icon_descr[icon];
		fread_discard(file_in, 1);
		wpt->creation_time = fread_long(file_in);
		if (wpt->creation_time)
			wpt->creation_time += EPOCH89DIFF;
		fread_discard(file_in, 2);
		wpt->altitude = fread_single(file_in);
		if (wpt->altitude == unknown_alt_gtm)
			wpt->altitude = unknown_alt;
		fread_discard(file_in, 2);
		waypt_add(wpt);
	}

	/* Waypoint Styles */
	if (wp_count) {
		for (i = 0; i != ws_count; i++) {
			fread_discard(file_in, 4);
			fread_string_discard(file_in);
			fread_discard(file_in, 24);
		}
	}

	/* Tracklogs */
	for (i = 0; i != tr_count; i++) {
		wpt = waypt_new();
		wpt->latitude = fread_double(file_in);
		wpt->longitude = fread_double(file_in);
		convert_datum(&wpt->latitude, &wpt->longitude);
		wpt->creation_time = fread_long(file_in);
		if (wpt->creation_time)
			wpt->creation_time += EPOCH89DIFF;
		start_new = fread_byte(file_in);
		wpt->altitude = fread_single(file_in);
		if (wpt->altitude == unknown_alt_gtm)
			wpt->altitude = unknown_alt;
		if (start_new || !trk_head) {
			trk_head = route_head_alloc();
			track_add_head(trk_head);
			real_tr_count++;
			if (!first_trk_head)
				first_trk_head = trk_head;
		}
		track_add_wpt(trk_head, wpt);
	}

	/* Tracklog styles */
	trk_head = first_trk_head;
	for (i = 0; i != ts_count && i != real_tr_count; i++) {
		trk_head->rte_name = fread_string(file_in);
		fread_discard(file_in, 12);
		trk_head = (route_head *)QUEUE_NEXT(&trk_head->Q);
	}

	/* Routes */
	for (i = 0; i != rt_count; i++) {
		wpt = waypt_new();
		wpt->latitude = fread_double(file_in);
		wpt->longitude = fread_double(file_in);
		convert_datum(&wpt->latitude, &wpt->longitude);
		wpt->shortname = fread_fixedstring(file_in, 10);
		wpt->description = fread_string(file_in);
		route_name = fread_string(file_in);
		icon = fread_integer(file_in);
		if (icon < sizeof(icon_descr)/sizeof(char*))
			wpt->icon_descr = icon_descr[icon];
		fread_discard(file_in, 1);
		start_new = fread_byte(file_in);
		fread_discard(file_in, 6);
		wpt->altitude = fread_single(file_in);
		if (wpt->altitude == unknown_alt_gtm)
			wpt->altitude = unknown_alt;
		fread_discard(file_in, 2);

		if (start_new || !rte_head) {
			rte_head = route_head_alloc();
			rte_head->rte_name = route_name;
			route_add_head(rte_head);
		}
		else {
			xfree(route_name);
		}
		route_add_wpt(rte_head, wpt);
	}
}
예제 #18
0
void
gtc_trk_pnt_s(const char *unused, const char **attrv)
{
	wpt_tmp = waypt_new();
}
예제 #19
0
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);
	}
}
예제 #20
0
static void
humminbird_read_track_old(gbfile* fin) {

	humminbird_trk_header_old_t th;
	humminbird_trk_point_old_t* points;
	route_head* trk;
	waypoint* first_wpt;
	int i;
	int max_points = 0;
	gbint32 accum_east;
	gbint32 accum_north;
	double g_lat;
	const int file_len = 8048;
	char namebuf[TRK_NAME_LEN];


	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);

	// These files are always 8048 bytes long. Note that that's the value
	// of the second 16-bit word in the signature.
	max_points = (file_len - (sizeof(th) + sizeof (gbuint32) + TRK_NAME_LEN)) / sizeof(humminbird_trk_point_old_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_old_t));
	if (! gbfread(points, sizeof(humminbird_trk_point_old_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);

	/* The name is not in the header, but at the end of the file.
	   (The last 20 bytes.) */

	gbfseek(fin, file_len-TRK_NAME_LEN, SEEK_SET);
	gbfread(&namebuf, 1, TRK_NAME_LEN, fin);
	trk->rte_name = xstrndup(namebuf, sizeof(namebuf));

	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;
	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].deltaeast  = be_read16(&points[i].deltaeast);
   		points[i].deltanorth = be_read16(&points[i].deltanorth);

//		I've commented this out, don't know if it happens in this
//		format. It happens in the newer version though.

//		/* 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 (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);
}
예제 #21
0
static void
gopal_read(void)
{

	char *buff;
	char *str, *c;
	int column;
	long line;
	double hmsd,speed;
	int fix, hms;
	route_head *route;
	waypoint *wpt, *lastwpt=NULL;
	double long_old,lat_old;
	char tbuffer[64];
	long_old=0;lat_old=0;
	strftime(routename,sizeof(routename),"Tracklog %c",localtime(&tx));
	
	route = route_head_alloc();
	route->rte_name=xstrdup(routename);
	route_add_head(route);

	line=0;
	while ((buff = gbfgetstr(fin)))
	{
		if ((line == 0) && fin->unicode) cet_convert_init(CET_CHARSET_UTF8, 1);

		str = buff = lrtrim(buff);
		if (*buff == '\0') continue;	
		if (gopal_check_line(buff)!=8)continue;
		wpt = waypt_new();
		
		column = -1;
		// the format of gopal is quite simple. Unfortunately the developers forgot the date as the first element...
		//TICK;    TIME;   LONG;     LAT;       HEIGHT; SPEED;  Fix; HDOP;    SAT
		//3801444, 080558, 2.944362, 43.262117, 295.28, 0.12964, 2, 2.900000, 3 
		c = csv_lineparse(str, ",", "", column++);
		while (c != NULL)
		{
			switch(column)
			{
			case  0: /* "-" */	/* unknown fields for the moment */
				//sscanf(c, "%llu", &wpt->microseconds);
				break;
			case  1:				/* Time UTC */	
				sscanf(c,"%lf",&hmsd);
				hms = (int) hmsd;
				tm.tm_sec = hms % 100;
				hms = hms / 100;
				tm.tm_min = hms % 100;
				hms = hms / 100;
				tm.tm_hour = hms % 100;  
				tm.tm_year=trackdate.tm_year;
				tm.tm_mon=trackdate.tm_mon;
				tm.tm_mday=trackdate.tm_mday;
				wpt->creation_time = tx+((((time_t)tm.tm_hour * 60) + tm.tm_min) * 60) + tm.tm_sec;
				if (global_opts.debug_level > 1){
					strftime(tbuffer, sizeof(tbuffer), "%c", gmtime(&wpt->creation_time));
					printf("parsed timestamp: %s\n",tbuffer);	
				}				
				break;
				
			case  2: 				/* longitude */
				sscanf(c, "%lf", &wpt->longitude);
				break;
				
			case  3: 				/* latitude */
				sscanf(c, "%lf", &wpt->latitude);
				break;
			case  4: 				/* altitude */
				sscanf(c, "%lf", &wpt->altitude);
				break;
			case  5: 				/* speed */
				//sscanf(c, "%lf", &wpt->speed);
				wpt->speed=atof(c);
				if (global_opts.debug_level > 1){
					printf("parsed speed: %8.5f\n",wpt->speed);	
				}
				break;
			case  6: 				/* type of fix */
				sscanf(c, "%d", &fix);
				//my device shows only 0 or 2
				//should i guess from no of sats if 2d or 3d?
				switch (fix) {
				case 0: wpt->fix = fix_none;break;
				case 2: wpt->fix = fix_2d;break;
					//case 3: wpt->fix = fix_3d;break;
					//case 4: wpt->fix = fix_dgps;break; /* 2D_diff */
					//case 5: wpt->fix = fix_dgps;break; /* 3D_diff */
				default:
					wpt->fix = fix_unknown;
					break;
				}
				break;
			case  7: 				/* hdop */
				wpt->hdop = atof(c);
				//sscanf(c, "%lf", &wpt->hdop); does not work ???
				//wpt->vdop=0;wpt->hdop=0;
				break;
			case  8: 				/* number of sats */
				sscanf(c, "%d", &wpt->sat);
				break;
				
			}
			c = csv_lineparse(NULL, ",", "", column++);
		}
		line++;
		
		if ((wpt->fix != fix_none)&&(lat_old==0)){ //first-time init
			lat_old=wpt->latitude;
			long_old=wpt->longitude;
			//route_add_wpt(route, wpt);
			lastwpt=wpt;
		}
		//calculate the speed to reach this waypoint from the last. This way I try to sort out invalid waypoints
		speed=0;	
		if (lastwpt !=NULL)
		{
			speed=3.6*radtometers(gcdist(RAD(lastwpt->latitude), RAD(lastwpt->longitude), RAD(wpt->latitude), RAD(wpt->longitude))) / abs(wpt->creation_time - lastwpt->creation_time);	
			//printf("speed line %d %lf \n",line,speed);			
		}
		/* Error handling: in the tracklog of my device sometimes "jump" waypoints ;-) */
		if	((optclean) && 
		(((wpt->longitude==0.0)|| (wpt->latitude==0.0)||(abs(wpt->latitude)>90)||(abs(wpt->longitude)>180))||
		((speed>maxspeed)||(speed<minspeed)))
		)
		{
			if (global_opts.debug_level > 1) fprintf(stderr,"Problem in or around line %5lu: \"%s\" %lf km/h\n",line,buff,speed);
		}
		else
		{
			if (global_opts.debug_level > 1) fprintf(stderr,"valid                line %5lu: \"%s\" %lf km/h\n",line,buff,speed);
			lastwpt=wpt;
			long_old=wpt->longitude;
			lat_old=wpt->latitude;
			route_add_wpt(route,wpt);
			waypt_add(waypt_dupe( wpt));
		}
	}
}
예제 #22
0
static void
geoniche_read_bin(void)
{
    pdbrec_t *pdb_rec;

    /* Process records */
    
    for (pdb_rec = file_in->rec_list; pdb_rec != NULL; pdb_rec = pdb_rec->next)
    {
	char *vdata = (char *) pdb_rec->data;
	struct tm created, visited;
	int icon_nr, selected;
	int latdeg, londeg;
	double lat, lon, altitude;
	waypoint *waypt;
	
	memset(&visited, 0, sizeof(visited));
	memset(&created, 0, sizeof(created));
	
	latdeg = be_read16(vdata + 0);
	lat = be_read32(vdata + 2);
	londeg = be_read16(vdata + 6);
	lon = be_read32(vdata + 8);
	altitude = (float) be_read32(vdata + 12);
	selected = vdata[16];
	created.tm_min = be_read16(vdata + 20);
	created.tm_hour = be_read16(vdata + 22);
	created.tm_mday = be_read16(vdata + 24);
	created.tm_mon = be_read16(vdata + 26);
	created.tm_year = be_read16(vdata + 28);
	visited.tm_min = be_read16(vdata + 34);
	visited.tm_hour = be_read16(vdata + 36);
	visited.tm_mday = be_read16(vdata + 38);
	visited.tm_mon = be_read16(vdata + 40);
	visited.tm_year = be_read16(vdata + 42);

#ifdef GEONICHE_DBG
	printf(MYNAME "-date: %04d/%02d/%02d, %02d:%02d (%04d/%02d/%02d, %02d:%02d)\n", 
	    created.tm_year, created.tm_mon, created.tm_mday, created.tm_hour, created.tm_min,
	    visited.tm_year, visited.tm_mon, visited.tm_mday, visited.tm_hour, visited.tm_min);
#endif
	icon_nr = vdata[62];
	
	latdeg = 89 - latdeg;
	lat = lat * (double) 0.0000006;
	if (latdeg >= 0) 
	    lat = (double) 60.0 - lat;
	else
	    latdeg++;

	lon = lon * (double) 0.0000006;
	while (londeg >= 360) londeg-=360;
	if (londeg > 180)
	{
	    lon = (double) 60.0 - lon;
	    londeg = londeg - 359;
	}

	created.tm_year-=1900;
	created.tm_mon--;

	waypt = waypt_new();
	
	waypt->shortname = xstrdup(vdata + 63);
	waypt->altitude = altitude;
	waypt->creation_time = mkgmtime(&created);
	
	GPS_Math_DegMin_To_Deg(latdeg, lat, &waypt->latitude);
	GPS_Math_DegMin_To_Deg(londeg, lon, &waypt->longitude);
	
	waypt->icon_descr = geoniche_icon_to_descr(icon_nr);
	if (waypt->icon_descr != NULL)
		waypt->wpt_flags.icon_descr_is_dynamic = 1;
	
	waypt_add(waypt);
    }
}
예제 #23
0
static void 
data_read(void)
{
    char *buff;
    char *s;
    char *holder;
    waypoint *wpt_tmp;
    int i;
    int linecount = 0;
    
    while ((buff = gbfgetstr(file_in))) {
        if ((linecount++ == 0) && file_in->unicode) cet_convert_init(CET_CHARSET_UTF8, 1);

	/* skip the line if it contains "sHyperLink" as it is a header (I hope :) */
	if ((strlen(buff)) && (strstr(buff, "sHyperLink") == NULL)) {

	    wpt_tmp = waypt_new();

	    /* data delimited by tabs, not enclosed in quotes.  */
	    s = buff;
	    s = csv_lineparse(s, "\t", "", linecount);
	    
	    i = 0;
	    while (s) {
		switch (i) {
		
		/* Group sID sDescription fLat fLong fEasting fNorthing fAlt iColour iSymbol sHyperLink */
		/*   0    1       2         3    4      5         6       7    8       9       10       */
		
		case 0:
			 /* ignore: group  */
			 break;
		case 1:
		    wpt_tmp->shortname = csv_stringtrim(s, "", 0);
		    break;
		case 2:
			/* Description is not a TopoMapPro format requirement.
			   If we assign "" then .loc/.gpx will generate empty XML tags :(
			*/
			holder = csv_stringtrim(s, "", 0);
			if (strlen(holder))
				wpt_tmp->description = holder;
			else 
				xfree(holder);
		    break;
		case 3:
		    wpt_tmp->latitude = atof(s);
		    break;
		case 4:
		    wpt_tmp->longitude = atof(s);
		    break;
		case 5:
			/* ignore: NZMapGrid Easting  */
			 break;
		case 6:
			/* ignore: NZMapGrid Northing  */
			 break;
		case 7:
			wpt_tmp->altitude = atof(s);
		    break;
		case 8:
		    /* ignore: color  */
		    break;
		case 9:
		    /* ignore: symbol (non standard) */
		    break;
		case 10:
			/* URL is not a TopoMapPro format requirement.
			   You can store file links etc, we will discard anything that is not http
			   (as URLs in TMPro must start "http:") as other GPS formats probably can't 
			   use the TopoMapLinks links.
			   (plus discards length 0 strings (so no empty XML tags))
			*/
			holder = csv_stringtrim(s, "", 0);
			if (strstr(holder, "http:") != NULL)
				wpt_tmp->url = holder;
			else 
				xfree(holder);
			break;
		default:
		    /* whoa! nelly */
		    warning(MYNAME ": Warning: data fields on line %d exceed specification.\n", 
		        linecount);
		    break;
		}
		i++;

		s = csv_lineparse(NULL, "\t", "\"", linecount);
	    }
	    
	    if (i != 11) {
   	        xfree(wpt_tmp);
	        warning(MYNAME ": WARNING - extracted %d fields from line %d. \nData on line ignored.\n", 
	            i, linecount);
	    } else {
   	        waypt_add(wpt_tmp);
   	    }

	} else {
            /* empty line */
	}

    }
}
예제 #24
0
파일: nmn4.c 프로젝트: alexbirkett/GPSBabel
static void
nmn4_read_data(void)
{
	char *buff;
	char *str, *c;
	int column;
	int line = 0;

	char *zip1, *zip2, *city, *street, *number;	
	route_head *route;
	waypoint *wpt;
	
	route = route_head_alloc();
	route_add_head(route);
	
	while ((buff = gbfgetstr(fin)))
	{
		if ((line++ == 0) && fin->unicode) cet_convert_init(CET_CHARSET_UTF8, 1);
		str = buff = lrtrim(buff);
		if (*buff == '\0') continue;
		
		nmn4_check_line(buff);

		/* for a quiet compiler */
		zip1 = zip2 = city = street = number = NULL;
	    
	    	wpt = waypt_new();
	    
	    	column = -1;
	    	c = csv_lineparse(str, "|", "", column++);
	    	while (c != NULL)
	    	{
			switch(column)
			{
		    		case  0: /* "-" */	/* unknown fields for the moment */
		    		case  1: /* "-" */
		    		case  2: /* "-" */
		    		case  3: /* "-" */
		    		case  9: /* "-" */
		    		case 10: /* "-" */
		    		case 13: /* "-" */
		    		case 14: /* "-" */
				case 15: /* "" */
					break;
		    
		    		case  4: 				/* ZIP Code */
					if (*c != '-') 
						zip1 = xstrdup(c);
					else
						zip1 = xstrdup("");
					break;
			
		    		case  5: 				/* City */
					if (*c != '-')
						city = xstrdup(c); 
					else
						city = xstrdup("");
					break;
			
		    		case  6: 				/* ZIP Code -2- */
					if (*c != '-') 
						zip2 = xstrdup(c); 
					else
						zip2 = xstrdup("");	
					break;
					
				case  7: 				/* Street */
					if (*c != '-')
						street = xstrdup(c); 
					else
						street = xstrdup("");
					break;
					
				case  8: 				/* Number */
					if (*c != '-')
						number = xstrdup(c); 
					else
						number = xstrdup("");

				/* 
			    	   This is our final index
				   All stuff for generating names or comments
				   is hold locally.
				   
				   We don't have fields for street, city or zip-code.
				   Instead we construct a description from that.
				*/
			
					if (strcmp(zip1, zip2) == 0) *zip2 = '\0';
					if (*city != '\0')
					{
			    			/* 
						   if any field following city has a value, add a comma to city 
						*/
			    			if ((*street != '\0') || (*number != '\0') || (*zip2 != '\0'))
							city = xstrappend(city, ",");
					}
										
					/* concats all fields to one string and release */
					wpt->description = nmn4_concat(zip1, city, street, number, zip2, NULL);
					break;
			
		    		case 11: 				/* longitude */
					sscanf(c, "%lf", &wpt->longitude);
					break;
			
				case 12: 				/* latitude */
					sscanf(c, "%lf", &wpt->latitude);
					break;
			
			}
			c = csv_lineparse(NULL, "|", "", column++);
		}
		route_add_wpt(route, wpt);
	}
}
예제 #25
0
static void
magpdb_read_data(const char *data, const size_t data_len)
{
	route_head *route;
	char *cin = (char *)data;
	char *cend = cin + data_len;
	
	route = route_head_alloc();
	route_add_head(route);
	
	while (cin < cend)
	{
		char *lend;
		int len;
		
		lend = strchr(cin, '\x0A');
		if (lend == NULL) break;
		
		len = (lend - cin);
		if (len > 0)
		{
			double distance;
				int hour, min;
			*lend = '\0';
			
			if (case_ignore_strncmp(cin, "Wegname=", 8) == 0)	/* This only works with the german release */
			{							/* test-data created with other releases are welcome */
				cin += 8;
				if (*cin != '\0')
					route->rte_name = xstrdup(cin);
			}
			else if (case_ignore_strncmp(cin, "Fahrzeit=", 9) == 0)
			{
			}
			else if (case_ignore_strncmp(cin, "Kosten=", 7) == 0)
			{
			}
			else if (case_ignore_strncmp(cin, "Entfernung=", 11) == 0)
			{
			}
			/* check, if line starts with time and distance */
			else if (3 == sscanf(cin, "%d:%d %lf", &hour, &min, &distance))
			{
				char *buff, *comma;
				
				/* detect time-format settings, 12,0 or 12.0 */
				
				comma = strchr(cin, '.');
				buff = strchr(cin, ',');
				if (comma == NULL)
					comma = buff;
				else 
					if ((buff != NULL) && (buff < comma))
						comma = buff;
				if (comma != NULL)
				{
					char separator = *comma;

					/* now we are looking for a sequence like 0,1 NE (123456,654321) */
				  
					buff = xmalloc(strlen(cin) + 1);		/* safe target space for sscanf( ... */
			
					comma = cin;
					while ((comma = strchr(comma, separator)))
					{
						int i, xlat, xlon;
						waypoint *wpt;
						char *cx;
				
						comma++;
					
						if (isdigit(*comma) == 0) continue;
						if (isdigit(*(comma - 2)) == 0) continue;
					
						if (4 != sscanf(comma, "%d %s (%d,%d)", &i, buff, &xlon, &xlat)) continue;
						if (strchr("NESW", *buff) == NULL) continue;	/* north, east, ... */
					
						cx = comma - 2;				/* go left over delta distance */
						while (isdigit(*cx) != 0) *cx-- = '\0';
						cin = lrtrim(cin);
					
						for (i = 0; i < 2; i++)			/* skip time and distance at start of line */
						{
							cin = strchr(cin, ' ');
							cin = lrtrim(cin);
						}

						wpt = waypt_new();
					
						wpt->latitude = magpdb_to_degree(xlat);
						wpt->longitude = magpdb_to_degree(xlon);
						wpt->description = xstrdup(cin);
					
						cx = strchr(comma, ')');		/* find tailing notes after the coordinates */
						if (cx != NULL)	
						{
							char *tail = lrtrim(++cx);
							if (*tail != '\0')
							{
								wpt->notes = xstrdup(tail);
							}
						}
						/* generate some waypoints from our route-only format */
						if ((*cin != '-') && (case_ignore_strncmp(cin, "bei ", 4) != 0))
							waypt_add(waypt_dupe(wpt));
						
						route_add_wpt(route, wpt);
						break;
					}
					xfree(buff);
				}
			}

		}
		cin = lend + 1;
	}
}
예제 #26
0
파일: psp.c 프로젝트: alexbirkett/GPSBabel
static void
psp_read(void)
{
	char buff[MAXPSPSTRINGSIZE + 1];
	double radians;
	double lat, lon;
	waypoint *wpt_tmp;
	short int pincount;
	short int pindex;
        char gridbyte = 0x00;
	char *tmp;

        /* 32 bytes - file header */
        psp_fread(&buff[0], 1, 32, psp_file_in);

        if (valid_psp_header(buff) != 0) {
            fatal(MYNAME ": input file does not appear to be a valid .PSP file.\n");
        }

	pincount = le_read16(&buff[12]);

	while (pincount--) {
	    wpt_tmp = waypt_new();

            wpt_tmp->altitude = unknown_alt;
            
            /* offset 0x20 - 0x21 pin index */
    	    psp_fread(&pindex, 1, 2, psp_file_in);

            /* offset 0x22 - 0x23 */
    	    psp_fread(&buff[0], 1, 2, psp_file_in);

            /* offset 0x24 */
            /* 1 byte, the grid byte - needed for sign corrections later*/
            psp_fread(&gridbyte, 1, 1, psp_file_in);

            /* 8 bytes - latitude in radians */
	    radians = psp_fread_double(psp_file_in);
            lat = DEG(radians);

            /* 8 bytes - longitude in radians */
	    radians = psp_fread_double(psp_file_in);
            lon = DEG(radians);

            /* since we don't know the origin of this PSP file, we use  */
            /* the grid byte adjust longitude, if necessary, mimicing   */
            /* the behavior of pocketstreets correcting the data.  This */
            /* does not correct the fact that points in eastern US are  */
            /* written with the wrong coordinates by S&T. (MS bug)      */

            decode_psp_coordinates(&lat, &lon, gridbyte);

            wpt_tmp->latitude = lat;
            wpt_tmp->longitude = lon;
           
            /* 1 byte - pin display properties */
            psp_fread(&buff[0], 1, 1, psp_file_in);

	    /* 3 bytes - unknown */
            psp_fread(&buff[0], 1, 3, psp_file_in);

            /* 1 bytes - icon (values: 0x00 - 0x27) */
            psp_fread(&buff[0], 1, 1, psp_file_in);

	    /* 3 bytes - unknown */
    	    psp_fread(&buff[0], 1, 3, psp_file_in);

	    wpt_tmp->shortname = psp_read_str(psp_file_in);
	    wpt_tmp->description = psp_read_str(psp_file_in);
	    tmp = psp_read_str(psp_file_in); /* (address?) */
	    if (tmp) xfree(tmp);

	    waypt_add(wpt_tmp);
	}
}
예제 #27
0
/*
 * Main Function to process Saved tracks file
 */
static void
format_garmin_xt_proc_strk(void)
{
	int 		Count = 0; // Used to obtain number of read bytes
	int		NumberOfTracks = 0, TracksCompleted = 0; // Number of tracks in the file and number of processed tracks
	gbuint16	trackbytes = 0; // Bytes in track
	gbuint8	TrackBlock[STRK_BLOCK_SIZE]; // File Block
	gbuint8 	ii; // temp variable
	double		Lat = 0, Lon = 0; // wpt data
	double		PrevLat = 0, PrevLon = 0, PrevEle = 0; // wpt data
	gbuint32	Time = 0, PrevTime =0; // wpt data
	int		FirstCoo;
	gbuint8	trk_color = 0xff;

	// Skip 12 bytes from the BOF
	gbfseek(fin, 12, SEEK_SET);

	// read # of tracks
	NumberOfTracks = gbfgetuint16(fin);

	// Skip 2 bytes
	gbfseek(fin, 2, SEEK_CUR);

	// Process all tracks one by one
	while ((TracksCompleted < NumberOfTracks) && (!gbfeof( fin ) ) )
	{
		route_head *tmp_track;
		waypoint	*wpt;
		char	*trk_name;
		trk_name = xmalloc(30);

		// Generate Track Header
		trackbytes = format_garmin_xt_rd_st_attrs(trk_name, &trk_color) - 50;

		tmp_track = route_head_alloc();
		// update track color
		tmp_track->line_color.bbggrr = colors[trk_color];
		tmp_track->line_color.opacity = 255;
		// update track name
		tmp_track->rte_name = trk_name;
		track_add_head(tmp_track);

		// This is the 1st coordinate of the track
		FirstCoo = TRUE;
		while (trackbytes>0)
		{
			if (trackbytes>=STRK_BLOCK_SIZE)
			{
				Count = gbfread(&TrackBlock, DATABLOCKSIZE, STRK_BLOCK_SIZE, fin);
				trackbytes -= STRK_BLOCK_SIZE;
			}
			else
			{
				Count = gbfread(&TrackBlock, DATABLOCKSIZE, trackbytes, fin);
				trackbytes = 0;
			}

			// decrypt loaded track block (Count - size of loaded TrackBlock)
			format_garmin_xt_decrypt_trk_blk(Count, TrackBlock);

			// process each track point in the loaded TrackBlock
			for (ii=1; ii <= ((Count-1) / 12); ii++)
			{
				// decompose loaded track block part (track point)
				format_garmin_xt_decomp_trk_blk(ii, TrackBlock, &PrevEle, &Lat, &Lon, &Time);

				// Add point to the track if not the first point
				if (!FirstCoo)
				{
					//create new waypoint
					wpt = waypt_new();

					//populate wpt;
					wpt->latitude = PrevLat;	/* Degrees */
					wpt->longitude = PrevLon; 	/* Degrees */
					wpt->altitude = PrevEle; 			/* Meters. */
					wpt->creation_time = Time;  		/* Unix Time adjusted to Garmin time */

					// add way point to the track
					track_add_wpt(tmp_track, wpt);
				}
				else
				{
					FirstCoo = FALSE;
				}	
				PrevLat = Lat;
				PrevLon = Lon;
				PrevTime = Time;
			}
		}

		// decompose elevation for the last point
		if (Count > 12)
		{
			Count--;
		}
		format_garmin_xt_decomp_last_ele(Count, &PrevEle, TrackBlock);

		//create new waypoint
		wpt = waypt_new();

		//populate wpt;
		wpt->latitude = PrevLat;	/* Degrees */
		wpt->longitude = PrevLon; 	/* Degrees */
		wpt->altitude = PrevEle; 			/* Meters. */
		wpt->creation_time = Time;  		/* Unix Time adjusted to Garmin time */

		// add way point to the track
		track_add_wpt(tmp_track, wpt);

		// update completed tracks counter
		TracksCompleted++;
	}
}