navit/maptool/osm_relations.c

/**
 * ZANavi, Zoff Android Navigation system.
 * Copyright (C) 2011-2012 Zoff <zoff@zoff.cc>
 *
 * 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.
 */

/**
 * Navit, a modular navigation system.
 * Copyright (C) 2005-2011 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 <stdio.h>
#include <time.h>
#include <string.h>
#include "maptool.h"
#include "attr.h"

struct relations
{
        GHashTable *member_hash[3];
};

struct relations_func
{
        void (*func)(void *func_priv, void *relation_priv, struct item_bin *member, void *member_priv);
        void *func_priv;
};

struct relations_member
{
        osmid memberid;
        void *relation_priv, *member_priv;
        struct relations_func *func;
};

static guint relations_member_hash(gconstpointer key)
{
        const struct relations_member *memb = key;
        return (memb->memberid >> 32) ^ (memb->memberid & 0xffffffff);
}

static gboolean relations_member_equal(gconstpointer a, gconstpointer b)
{
        const struct relations_member *memba = a;
        const struct relations_member *membb = b;
        return (memba->memberid == membb->memberid);
}

struct relations *
relations_new(void)
{
        struct relations *ret=g_new(struct relations, 1);
        int i;

        for (i = 0; i < 3; i++)
        {
                ret->member_hash[i] = g_hash_table_new_full(relations_member_hash, relations_member_equal, NULL, NULL);
        }
        return ret;
}

struct relations_func *
relations_func_new(void(*func)(void *func_priv, void *relation_priv, struct item_bin *member, void *member_priv), void *func_priv)
{
        struct relations_func *relations_func=g_new(struct relations_func, 1);
        relations_func->func = func;
        relations_func->func_priv = func_priv;
        return relations_func;
}

void relations_add_func(struct relations *rel, struct relations_func *func, void *relation_priv, void *member_priv, int type, osmid id)
{
        //fprintf(stderr,"relations_add_func:001\n");

        GHashTable *member_hash = rel->member_hash[type - 1];
        struct relations_member *memb=g_new(struct relations_member, 1);

        memb->memberid = id;
        memb->relation_priv = relation_priv;
        memb->member_priv = member_priv;
        memb->func = func;
        g_hash_table_insert(member_hash, memb, g_list_append(g_hash_table_lookup(member_hash, memb), memb));
}

void relations_process(struct relations *rel, FILE *nodes, FILE *ways, FILE *relations)
{
        char buffer[128];
        struct item_bin *ib = (struct item_bin *) buffer;
        long long *id;
        struct coord *c = (struct coord *) (ib + 1), cn =
        { 0, 0 };
        struct node_item *ni;
        GList *l;

        time_t start_tt, end_tt;
        double diff_tt;
        double diff2_tt;
        long long size_in;
        long long pos_in;
        int _c = 0;
        int _e = 8000000;

        //fprintf(stderr,"relations_process:001\n");

        if (nodes)
        {
                //fprintf(stderr,"relations_process:002 nodes\n");

                long long pos_now = ftello(nodes); // 64bit
                fseeko(nodes, 0, SEEK_END);
                size_in = ftello(nodes); // 64bit
                fseeko(nodes, pos_now, SEEK_SET);
                // reset timer
                diff2_tt = 0;
                _c = 0;
                time(&start_tt);

                item_bin_init(ib, type_point_unkn);
                item_bin_add_coord(ib, &cn, 1);
                item_bin_add_attr_longlong(ib, attr_osm_nodeid, 0);
                id = item_bin_get_attr(ib, attr_osm_nodeid, NULL);
                while ((ni = read_node_item(nodes, 0)))
                {
                        _c++;

                        *id = ni->id;
                        *c = ni->c;
                        l = g_hash_table_lookup(rel->member_hash[0], id);
                        while (l)
                        {
                                struct relations_member *memb = l->data;
                                memb->func->func(memb->func->func_priv, memb->relation_priv, ib, memb->member_priv);
                                l = g_list_next(l);
                        }

                        if (_c > _e)
                        {
                                _c = 0;

                                pos_in = ftello(nodes); // 64bit
                                time(&end_tt);
                                diff_tt = difftime(end_tt,start_tt);
                                char outstring[200];
                                char outstring2[200];
                                char outstring3[200];
                                convert_to_human_time(diff_tt, outstring);
                                convert_to_human_bytes(pos_in, outstring2);
                                convert_to_human_bytes(size_in, outstring3);
                                fprintf(stderr, "-RUNTIME-LOOP-REL-PROC-NODES: %s elapsed (POS:%s of %s)\n", outstring, outstring2, outstring3);
                                if (pos_in > 0)
                                {
                                        double eta_time = (diff_tt / pos_in) * (size_in - pos_in);
                                        convert_to_human_time(eta_time, outstring);
                                        fprintf(stderr, "-RUNTIME-LOOP-REL-PROC-NODES: %s left\n", outstring);
                                }
                        }
                }
        }

        //fprintf(stderr,"relations_process:002.9\n");

        if (ways)
        {
                //fprintf(stderr,"relations_process:003 ways\n");

                long long pos_now = ftello(ways); // 64bit
                fseeko(ways, 0, SEEK_END);
                size_in = ftello(ways); // 64bit
                fseeko(ways, pos_now, SEEK_SET);
                // reset timer
                diff2_tt = 0;
                _c = 0;
                time(&start_tt);

                while ((ib = read_item(ways, 0)))
                {
                        _c++;

                        //fprintf(stderr,"relations_process:003.1\n");

                        id = item_bin_get_attr(ib, attr_osm_wayid, NULL);

                        //fprintf(stderr,"********DUMP relw***********\n");
                        //dump_itembin(ib);
                        //fprintf(stderr,"********DUMP relw***********\n");

                        //char *labelxx=item_bin_get_attr(ib, attr_name, NULL);
                        //fprintf(stderr,"relations_process:003.2 %s\n", labelxx);
                        //labelxx=item_bin_get_attr(ib, attr_label, NULL);
                        //fprintf(stderr,"relations_process:003.3 %s\n", labelxx);

                        if (id)
                        {
                                //fprintf(stderr,"relations_process:004 wayid:"LONGLONG_FMT"\n", id);

                                l = g_hash_table_lookup(rel->member_hash[1], id);
                                while (l)
                                {
                                        //fprintf(stderr,"relations_process:005\n");
                                        struct relations_member *memb = l->data;
                                        //fprintf(stderr,"relations_process:005.1 %d\n", memb->memberid);
                                        memb->func->func(memb->func->func_priv, memb->relation_priv, ib, memb->member_priv);
                                        l = g_list_next(l);
                                }
                        }

                        if (_c > _e)
                        {
                                _c = 0;

                                pos_in = ftello(ways); // 64bit
                                time(&end_tt);
                                diff_tt = difftime(end_tt,start_tt);
                                char outstring[200];
                                char outstring2[200];
                                char outstring3[200];
                                convert_to_human_time(diff_tt, outstring);
                                convert_to_human_bytes(pos_in, outstring2);
                                convert_to_human_bytes(size_in, outstring3);
                                fprintf(stderr, "-RUNTIME-LOOP-REL-PROC-WAYS: %s elapsed (POS:%s of %s)\n", outstring, outstring2, outstring3);
                                if (pos_in > 0)
                                {
                                        double eta_time = (diff_tt / pos_in) * (size_in - pos_in);
                                        convert_to_human_time(eta_time, outstring);
                                        fprintf(stderr, "-RUNTIME-LOOP-REL-PROC-WAYS: %s left\n", outstring);
                                }
                        }
                }
        }
}

1	zoff99	31	/**
2			* ZANavi, Zoff Android Navigation system.
3			* Copyright (C) 2011-2012 Zoff <zoff@zoff.cc>
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			/**
21			* Navit, a modular navigation system.
22			* Copyright (C) 2005-2011 Navit Team
23			*
24			* This program is free software; you can redistribute it and/or
25			* modify it under the terms of the GNU General Public License
26			* version 2 as published by the Free Software Foundation.
27			*
28			* This program is distributed in the hope that it will be useful,
29			* but WITHOUT ANY WARRANTY; without even the implied warranty of
30			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
31			* GNU General Public License for more details.
32			*
33			* You should have received a copy of the GNU General Public License
34			* along with this program; if not, write to the
35			* Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
36			* Boston, MA 02110-1301, USA.
37			*/
38			#include <stdio.h>
39			#include <time.h>
40			#include <string.h>
41			#include "maptool.h"
42			#include "attr.h"
43
44			struct relations
45			{
46			GHashTable *member_hash[3];
47			};
48
49			struct relations_func
50			{
51			void (func)(void func_priv, void relation_priv, struct item_bin member, void *member_priv);
52			void *func_priv;
53			};
54
55			struct relations_member
56			{
57			osmid memberid;
58			void relation_priv, member_priv;
59			struct relations_func *func;
60			};
61
62			static guint relations_member_hash(gconstpointer key)
63			{
64			const struct relations_member *memb = key;
65			return (memb->memberid >> 32) ^ (memb->memberid & 0xffffffff);
66			}
67
68			static gboolean relations_member_equal(gconstpointer a, gconstpointer b)
69			{
70			const struct relations_member *memba = a;
71			const struct relations_member *membb = b;
72			return (memba->memberid == membb->memberid);
73			}
74
75			struct relations *
76			relations_new(void)
77			{
78			struct relations *ret=g_new(struct relations, 1);
79			int i;
80
81			for (i = 0; i < 3; i++)
82			{
83			ret->member_hash[i] = g_hash_table_new_full(relations_member_hash, relations_member_equal, NULL, NULL);
84			}
85			return ret;
86			}
87
88			struct relations_func *
89			relations_func_new(void(func)(void func_priv, void relation_priv, struct item_bin member, void member_priv), void func_priv)
90			{
91			struct relations_func *relations_func=g_new(struct relations_func, 1);
92			relations_func->func = func;
93			relations_func->func_priv = func_priv;
94			return relations_func;
95			}
96
97			void relations_add_func(struct relations rel, struct relations_func func, void relation_priv, void member_priv, int type, osmid id)
98			{
99			//fprintf(stderr,"relations_add_func:001\n");
100
101			GHashTable *member_hash = rel->member_hash[type - 1];
102			struct relations_member *memb=g_new(struct relations_member, 1);
103
104			memb->memberid = id;
105			memb->relation_priv = relation_priv;
106			memb->member_priv = member_priv;
107			memb->func = func;
108			g_hash_table_insert(member_hash, memb, g_list_append(g_hash_table_lookup(member_hash, memb), memb));
109			}
110
111			void relations_process(struct relations rel, FILE nodes, FILE ways, FILE relations)
112			{
113			char buffer[128];
114			struct item_bin ib = (struct item_bin ) buffer;
115			long long *id;
116			struct coord c = (struct coord ) (ib + 1), cn =
117			{ 0, 0 };
118			struct node_item *ni;
119			GList *l;
120
121			time_t start_tt, end_tt;
122			double diff_tt;
123			double diff2_tt;
124			long long size_in;
125			long long pos_in;
126			int _c = 0;
127			int _e = 8000000;
128
129			//fprintf(stderr,"relations_process:001\n");
130
131			if (nodes)
132			{
133			//fprintf(stderr,"relations_process:002 nodes\n");
134
135			long long pos_now = ftello(nodes); // 64bit
136			fseeko(nodes, 0, SEEK_END);
137			size_in = ftello(nodes); // 64bit
138			fseeko(nodes, pos_now, SEEK_SET);
139			// reset timer
140			diff2_tt = 0;
141			_c = 0;
142			time(&start_tt);
143
144			item_bin_init(ib, type_point_unkn);
145			item_bin_add_coord(ib, &cn, 1);
146			item_bin_add_attr_longlong(ib, attr_osm_nodeid, 0);
147			id = item_bin_get_attr(ib, attr_osm_nodeid, NULL);
148			while ((ni = read_node_item(nodes, 0)))
149			{
150			_c++;
151
152			*id = ni->id;
153			*c = ni->c;
154			l = g_hash_table_lookup(rel->member_hash[0], id);
155			while (l)
156			{
157			struct relations_member *memb = l->data;
158			memb->func->func(memb->func->func_priv, memb->relation_priv, ib, memb->member_priv);
159			l = g_list_next(l);
160			}
161
162			if (_c > _e)
163			{
164			_c = 0;
165
166			pos_in = ftello(nodes); // 64bit
167			time(&end_tt);
168			diff_tt = difftime(end_tt,start_tt);
169			char outstring[200];
170			char outstring2[200];
171			char outstring3[200];
172			convert_to_human_time(diff_tt, outstring);
173			convert_to_human_bytes(pos_in, outstring2);
174			convert_to_human_bytes(size_in, outstring3);
175			fprintf(stderr, "-RUNTIME-LOOP-REL-PROC-NODES: %s elapsed (POS:%s of %s)\n", outstring, outstring2, outstring3);
176			if (pos_in > 0)
177			{
178			double eta_time = (diff_tt / pos_in) * (size_in - pos_in);
179			convert_to_human_time(eta_time, outstring);
180			fprintf(stderr, "-RUNTIME-LOOP-REL-PROC-NODES: %s left\n", outstring);
181			}
182			}
183			}
184			}
185
186			//fprintf(stderr,"relations_process:002.9\n");
187
188			if (ways)
189			{
190			//fprintf(stderr,"relations_process:003 ways\n");
191
192			long long pos_now = ftello(ways); // 64bit
193			fseeko(ways, 0, SEEK_END);
194			size_in = ftello(ways); // 64bit
195			fseeko(ways, pos_now, SEEK_SET);
196			// reset timer
197			diff2_tt = 0;
198			_c = 0;
199			time(&start_tt);
200
201			while ((ib = read_item(ways, 0)))
202			{
203			_c++;
204
205			//fprintf(stderr,"relations_process:003.1\n");
206
207			id = item_bin_get_attr(ib, attr_osm_wayid, NULL);
208
209			//fprintf(stderr,"******DUMP relw*********\n");
210			//dump_itembin(ib);
211			//fprintf(stderr,"******DUMP relw*********\n");
212
213			//char *labelxx=item_bin_get_attr(ib, attr_name, NULL);
214			//fprintf(stderr,"relations_process:003.2 %s\n", labelxx);
215			//labelxx=item_bin_get_attr(ib, attr_label, NULL);
216			//fprintf(stderr,"relations_process:003.3 %s\n", labelxx);
217
218			if (id)
219			{
220			//fprintf(stderr,"relations_process:004 wayid:"LONGLONG_FMT"\n", id);
221
222			l = g_hash_table_lookup(rel->member_hash[1], id);
223			while (l)
224			{
225			//fprintf(stderr,"relations_process:005\n");
226			struct relations_member *memb = l->data;
227			//fprintf(stderr,"relations_process:005.1 %d\n", memb->memberid);
228			memb->func->func(memb->func->func_priv, memb->relation_priv, ib, memb->member_priv);
229			l = g_list_next(l);
230			}
231			}
232
233			if (_c > _e)
234			{
235			_c = 0;
236
237			pos_in = ftello(ways); // 64bit
238			time(&end_tt);
239			diff_tt = difftime(end_tt,start_tt);
240			char outstring[200];
241			char outstring2[200];
242			char outstring3[200];
243			convert_to_human_time(diff_tt, outstring);
244			convert_to_human_bytes(pos_in, outstring2);
245			convert_to_human_bytes(size_in, outstring3);
246			fprintf(stderr, "-RUNTIME-LOOP-REL-PROC-WAYS: %s elapsed (POS:%s of %s)\n", outstring, outstring2, outstring3);
247			if (pos_in > 0)
248			{
249			double eta_time = (diff_tt / pos_in) * (size_in - pos_in);
250			convert_to_human_time(eta_time, outstring);
251			fprintf(stderr, "-RUNTIME-LOOP-REL-PROC-WAYS: %s left\n", outstring);
252			}
253			}
254			}
255			}
256			}
257