gpx2navit_txt/src/setpath.c

/**
 * Navit, a modular navigation system.
 * Copyright (C) 2005-2008 Navit Team
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA  02110-1301, USA.
 */

#include "gpx2navit_txt.h"

void initPathAttr(pathattr * pattr, g2sattr * attr);
void setEdge(parsedata * pdata, double _x, double _y, double _z,
             double length, double interval, double speed);
void setPathInterval(parsedata * pdata);
void setPathData(pathattr * pattr, g2sattr * attr);
void countUnconverted(parsedata * pdata);
void countPath(parsedata * pdata);
int checkPath(parsedata * pdata);
void setPath( parsedata * pdata);


/**
 * initialize a path attribute
 */
void initPathAttr(pathattr * pattr, g2sattr * attr)
{
    strcpy(pattr->name, attr->name);
    strcpy(pattr->cmt, attr->cmt);
    strcpy(pattr->desc, attr->desc);
    strcpy(pattr->src, attr->src);
    strcpy(pattr->link, attr->link);
    pattr->number = attr->number;
    strcpy(pattr->type, attr->type);
    pattr->length = 0;
    pattr->interval = 0;
    pattr->speed = 0;
    pattr->count = 0;
    pattr->point = NULL;
}


/**
 * set edge data and store it
 */
void setEdge(parsedata * pdata, double _x, double _y, double _z,
             double length, double interval, double speed)
{
    pathattr *pattr = pdata->pattr;
    static int isFirstTrkAsEdge = 1;
    static int isFirstRteAsEdge = 1;
    double x[2], y[2], z[2];
    double _length, _interval, _speed;
    if (!strcmp(pdata->current->name, "trkpt")) {
        if (isFirstTrkAsEdge) {
            isFirstTrkAsEdge = 0;
        }
    } else {
        if (isFirstRteAsEdge) {
            isFirstRteAsEdge = 0;
        }
    }
    _length = pattr->length;
    _interval = pattr->interval;
    _speed = pattr->speed;
    pattr->length = length;
    pattr->interval = interval;
    pattr->speed = speed;
    x[0] = _x;
    y[0] = _y;
    z[0] = _z;
    x[1] = pdata->attr->lon;
    y[1] = pdata->attr->lat;
    z[1] = pdata->attr->ele;
    if (pdata->prop->is3d) {
    } else {
    }
    pattr->length = _length;
    pattr->interval = _interval;
    pattr->speed = _speed;
}

/**
 * sets interval data between two track points
 */
void setPathInterval(parsedata * pdata)
{
    pathattr *pattr = pdata->pattr;
    g2sattr *attr = pdata->attr;
    g2sprop *prop = pdata->prop;
    static char _t[TIMELENGTH];
    double intvl = 0;
    static double _x, _y, _z;
    double leng = 0;
    double spd;
    if (pattr->count == 1) {
        strcpy(_t, attr->time);
    } else {
        /* time interval */
        intvl = getTimeInterval(_t, attr->time);
        pattr->interval = pattr->interval + intvl;
        strcpy(_t, attr->time);
        /* length interval */
        leng = getDistance(_x, _y, attr->lon, attr->lat);
        pattr->length = pattr->length + leng;
        /* interval speed */
        spd = getSpeed(leng, intvl, prop->speed2meter, prop->speed2sec);
        /* sets edge data */
        if (prop->isEdge) {
            setEdge(pdata, _x, _y, _z, leng, intvl, spd);
        }
    }
    _x = attr->lon;
    _y = attr->lat;
    _z = attr->ele;
}

/**
 * sets each track point data in array.
 */
void setPathData(pathattr * pattr, g2sattr * attr)
{
    const int reallocsize = 100;
    if (pattr->count == 0) {
        pattr->point = malloc(sizeof(double) * 3 * reallocsize);
    }
    if ((pattr->count % reallocsize) == 0) {
        pattr->point = realloc(pattr->point,
                               sizeof(double) * 3 * (pattr->count +
                                                     reallocsize));
    }
    pattr->point[pattr->count * 3] = attr->lon;
    pattr->point[pattr->count * 3 + 1] = attr->lat;
    pattr->point[pattr->count * 3 + 2] = attr->ele;
    pattr->count++;
}

/**
 * counts paths that wasn't converted
 */
void countUnconverted(parsedata * pdata)
{
    g2sstats *stats = pdata->prop->stats;
    if (!strcmp(pdata->current->name, "trkseg"))
        stats->trkunconverted++;
    else
        stats->rteunconverted++;
}

/**
 * counts paths 
 */
void countPath(parsedata * pdata)
{
    g2sstats *stats = pdata->prop->stats;
    pathattr *pattr = pdata->pattr;
    if (!strcmp(pdata->current->name, "trkseg")) {
        stats->trkcount++;
        stats->trklength += pattr->length;
        stats->trkpoints += pattr->count;
    } else {
        stats->rtecount++;
        stats->rtelength += pattr->length;
        stats->rtepoints += pattr->count;
    }
}

int checkPath(parsedata * pdata)
{
    pathattr *pattr = pdata->pattr;
    g2sprop *prop = pdata->prop;
    /* check point count. */
    if (pattr->count < prop->minpoints) {
        fprintf
            (stderr,
             "gpx2navit_txt:%s:%i track was not converted because of less then %d points. \n",
             prop->sourcefile, XML_GetCurrentLineNumber(pdata->parser),
             prop->minpoints);
        countUnconverted(pdata);
        return 0;
        /* check path length */
    } else if (pattr->length < prop->minlength * prop->length2meter) {
        fprintf
            (stderr,
             "gpx2navit_txt:%s:%i track was not converted because it is shorter than %dm.\n",
             prop->sourcefile, XML_GetCurrentLineNumber(pdata->parser),
             prop->minlength);
        countUnconverted(pdata);
        return 0;
        /* check path time */
    } else if (pattr->interval < prop->mintime * prop->time2sec) {
        fprintf
            (stderr,
             "gpx2navit_txt:%s:%i track was not converted because it is shorter than %d sed.\n",
             prop->sourcefile, XML_GetCurrentLineNumber(pdata->parser),
             prop->mintime);
        countUnconverted(pdata);
        return 0;
        /* check path speed */
    } else if (pattr->speed == .0) {
        fprintf
            (stderr,
             "gpx2navit_txt:%s:%i track was not converted because no move recorded.\n",
             prop->sourcefile, XML_GetCurrentLineNumber(pdata->parser));
        countUnconverted(pdata);
        return 0;
    }
    return 1;
}

/**
 * saves path data into files.
 */
void setPath( parsedata * pdata)
{
    pathattr *pattr = pdata->pattr;
    g2sprop *prop = pdata->prop;
    int isOk = 0;
    pattr->speed =
        getSpeed(pattr->length, pattr->interval, prop->speed2meter,
                 prop->speed2sec);
    if (prop->isFast) {
        isOk = 1;
    } else {
        isOk = checkPath(pdata);
    }
    if (isOk) {
        double x[pattr->count];
        double y[pattr->count];
        double z[pattr->count];
        int i;
        fprintf(pdata->fp,"type=track label=\"%s\" desc=\"%s\" type=\"%s\"\ length=\"%5.3f\" count=\"%5d\"\n"
                ,pdata->pattr->name,pdata->pattr->desc,
                pdata->pattr->type,pdata->pattr->length,
                pdata->pattr->count);
        
        for (i = 0; i < pattr->count; i++) {
            x[i] = pattr->point[i * 3];
            y[i] = pattr->point[i * 3 + 1];
            z[i] = pattr->point[i * 3 + 2];
            fprintf(pdata->fp,"%3.6f %4.6f\n",x[i],y[i]);
        }
        if (pdata->prop->is3d) {
        } else {
        }
        countPath(pdata);
    }
    free(pattr->point);
}
1	/**
2	* Navit, a modular navigation system.
3	* Copyright (C) 2005-2008 Navit Team
4	*
5	* This program is free software; you can redistribute it and/or
6	* modify it under the terms of the GNU General Public License
7	* version 2 as published by the Free Software Foundation.
8	*
9	* This program is distributed in the hope that it will be useful,
10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12	* GNU General Public License for more details.
13	*
14	* You should have received a copy of the GNU General Public License
15	* along with this program; if not, write to the
16	* Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17	* Boston, MA 02110-1301, USA.
18	*/
19
20	#include "gpx2navit_txt.h"
21
22	void initPathAttr(pathattr * pattr, g2sattr * attr);
23	void setEdge(parsedata * pdata, double _x, double _y, double _z,
24	double length, double interval, double speed);
25	void setPathInterval(parsedata * pdata);
26	void setPathData(pathattr * pattr, g2sattr * attr);
27	void countUnconverted(parsedata * pdata);
28	void countPath(parsedata * pdata);
29	int checkPath(parsedata * pdata);
30	void setPath( parsedata * pdata);
31
32
33
34	/**
35	* initialize a path attribute
36	*/
37	void initPathAttr(pathattr * pattr, g2sattr * attr)
38	{
39	strcpy(pattr->name, attr->name);
40	strcpy(pattr->cmt, attr->cmt);
41	strcpy(pattr->desc, attr->desc);
42	strcpy(pattr->src, attr->src);
43	strcpy(pattr->link, attr->link);
44	pattr->number = attr->number;
45	strcpy(pattr->type, attr->type);
46	pattr->length = 0;
47	pattr->interval = 0;
48	pattr->speed = 0;
49	pattr->count = 0;
50	pattr->point = NULL;
51	}
52
53
54	/**
55	* set edge data and store it
56	*/
57	void setEdge(parsedata * pdata, double _x, double _y, double _z,
58	double length, double interval, double speed)
59	{
60	pathattr *pattr = pdata->pattr;
61	static int isFirstTrkAsEdge = 1;
62	static int isFirstRteAsEdge = 1;
63	double x[2], y[2], z[2];
64	double _length, _interval, _speed;
65	if (!strcmp(pdata->current->name, "trkpt")) {
66	if (isFirstTrkAsEdge) {
67	isFirstTrkAsEdge = 0;
68	}
69	} else {
70	if (isFirstRteAsEdge) {
71	isFirstRteAsEdge = 0;
72	}
73	}
74	_length = pattr->length;
75	_interval = pattr->interval;
76	_speed = pattr->speed;
77	pattr->length = length;
78	pattr->interval = interval;
79	pattr->speed = speed;
80	x[0] = _x;
81	y[0] = _y;
82	z[0] = _z;
83	x[1] = pdata->attr->lon;
84	y[1] = pdata->attr->lat;
85	z[1] = pdata->attr->ele;
86	if (pdata->prop->is3d) {
87	} else {
88	}
89	pattr->length = _length;
90	pattr->interval = _interval;
91	pattr->speed = _speed;
92	}
93
94	/**
95	* sets interval data between two track points
96	*/
97	void setPathInterval(parsedata * pdata)
98	{
99	pathattr *pattr = pdata->pattr;
100	g2sattr *attr = pdata->attr;
101	g2sprop *prop = pdata->prop;
102	static char _t[TIMELENGTH];
103	double intvl = 0;
104	static double _x, _y, _z;
105	double leng = 0;
106	double spd;
107	if (pattr->count == 1) {
108	strcpy(_t, attr->time);
109	} else {
110	/* time interval */
111	intvl = getTimeInterval(_t, attr->time);
112	pattr->interval = pattr->interval + intvl;
113	strcpy(_t, attr->time);
114	/* length interval */
115	leng = getDistance(_x, _y, attr->lon, attr->lat);
116	pattr->length = pattr->length + leng;
117	/* interval speed */
118	spd = getSpeed(leng, intvl, prop->speed2meter, prop->speed2sec);
119	/* sets edge data */
120	if (prop->isEdge) {
121	setEdge(pdata, _x, _y, _z, leng, intvl, spd);
122	}
123	}
124	_x = attr->lon;
125	_y = attr->lat;
126	_z = attr->ele;
127	}
128
129	/**
130	* sets each track point data in array.
131	*/
132	void setPathData(pathattr * pattr, g2sattr * attr)
133	{
134	const int reallocsize = 100;
135	if (pattr->count == 0) {
136	pattr->point = malloc(sizeof(double) * 3 * reallocsize);
137	}
138	if ((pattr->count % reallocsize) == 0) {
139	pattr->point = realloc(pattr->point,
140	sizeof(double) * 3 * (pattr->count +
141	reallocsize));
142	}
143	pattr->point[pattr->count * 3] = attr->lon;
144	pattr->point[pattr->count * 3 + 1] = attr->lat;
145	pattr->point[pattr->count * 3 + 2] = attr->ele;
146	pattr->count++;
147	}
148
149	/**
150	* counts paths that wasn't converted
151	*/
152	void countUnconverted(parsedata * pdata)
153	{
154	g2sstats *stats = pdata->prop->stats;
155	if (!strcmp(pdata->current->name, "trkseg"))
156	stats->trkunconverted++;
157	else
158	stats->rteunconverted++;
159	}
160
161	/**
162	* counts paths
163	*/
164	void countPath(parsedata * pdata)
165	{
166	g2sstats *stats = pdata->prop->stats;
167	pathattr *pattr = pdata->pattr;
168	if (!strcmp(pdata->current->name, "trkseg")) {
169	stats->trkcount++;
170	stats->trklength += pattr->length;
171	stats->trkpoints += pattr->count;
172	} else {
173	stats->rtecount++;
174	stats->rtelength += pattr->length;
175	stats->rtepoints += pattr->count;
176	}
177	}
178
179	int checkPath(parsedata * pdata)
180	{
181	pathattr *pattr = pdata->pattr;
182	g2sprop *prop = pdata->prop;
183	/* check point count. */
184	if (pattr->count < prop->minpoints) {
185	fprintf
186	(stderr,
187	"gpx2navit_txt:%s:%i track was not converted because of less then %d points. \n",
188	prop->sourcefile, XML_GetCurrentLineNumber(pdata->parser),
189	prop->minpoints);
190	countUnconverted(pdata);
191	return 0;
192	/* check path length */
193	} else if (pattr->length < prop->minlength * prop->length2meter) {
194	fprintf
195	(stderr,
196	"gpx2navit_txt:%s:%i track was not converted because it is shorter than %dm.\n",
197	prop->sourcefile, XML_GetCurrentLineNumber(pdata->parser),
198	prop->minlength);
199	countUnconverted(pdata);
200	return 0;
201	/* check path time */
202	} else if (pattr->interval < prop->mintime * prop->time2sec) {
203	fprintf
204	(stderr,
205	"gpx2navit_txt:%s:%i track was not converted because it is shorter than %d sed.\n",
206	prop->sourcefile, XML_GetCurrentLineNumber(pdata->parser),
207	prop->mintime);
208	countUnconverted(pdata);
209	return 0;
210	/* check path speed */
211	} else if (pattr->speed == .0) {
212	fprintf
213	(stderr,
214	"gpx2navit_txt:%s:%i track was not converted because no move recorded.\n",
215	prop->sourcefile, XML_GetCurrentLineNumber(pdata->parser));
216	countUnconverted(pdata);
217	return 0;
218	}
219	return 1;
220	}
221
222	/**
223	* saves path data into files.
224	*/
225	void setPath( parsedata * pdata)
226	{
227	pathattr *pattr = pdata->pattr;
228	g2sprop *prop = pdata->prop;
229	int isOk = 0;
230	pattr->speed =
231	getSpeed(pattr->length, pattr->interval, prop->speed2meter,
232	prop->speed2sec);
233	if (prop->isFast) {
234	isOk = 1;
235	} else {
236	isOk = checkPath(pdata);
237	}
238	if (isOk) {
239	double x[pattr->count];
240	double y[pattr->count];
241	double z[pattr->count];
242	int i;
243	fprintf(pdata->fp,"type=track label=\"%s\" desc=\"%s\" type=\"%s\"\ length=\"%5.3f\" count=\"%5d\"\n"
244	,pdata->pattr->name,pdata->pattr->desc,
245	pdata->pattr->type,pdata->pattr->length,
246	pdata->pattr->count);
247
248	for (i = 0; i < pattr->count; i++) {
249	x[i] = pattr->point[i * 3];
250	y[i] = pattr->point[i * 3 + 1];
251	z[i] = pattr->point[i * 3 + 2];
252	fprintf(pdata->fp,"%3.6f %4.6f\n",x[i],y[i]);
253	}
254	if (pdata->prop->is3d) {
255	} else {
256	}
257	countPath(pdata);
258	}
259	free(pattr->point);
260	}