]> mj.ucw.cz Git - leo.git/blob - map.c
style_results are freed after use
[leo.git] / map.c
1 /*
2  *      Hic Est Leo -- Global Map Operations
3  *
4  *      (c) 2014--2015 Martin Mares <mj@ucw.cz>
5  */
6
7 #include <ucw/lib.h>
8 #include <ucw/conf.h>
9 #include <ucw/gary.h>
10 #include <ucw/mempool.h>
11 #include <ucw/simple-lists.h>
12
13 #include <stdio.h>
14 #include <math.h>
15
16 #include "leo.h"
17 #include "osm.h"
18 #include "shp.h"
19 #include "map.h"
20 #include "css.h"
21 #include "sym.h"
22 #include "fixed.h"
23
24 double map_min_x, map_min_y;
25 double map_max_x, map_max_y;
26 double page_width, page_height;
27 uns map_clip, map_rotate, map_draw_border;
28 char *map_xml_input;
29 char *map_projection;
30 char *map_style_sheet;
31 char *map_svg_output;
32 clist map_sources;
33
34 static struct cf_section map_style_cf = {
35 #define P(x) PTR_TO(struct data_source_style, x)
36   CF_TYPE(struct data_source_style),
37   CF_ITEMS {
38     CF_STRING("Name", P(name)),
39     CF_END
40   }
41 #undef P
42 };
43
44 static const char * const map_formats[] = {
45   "invalid",
46   "osmxml",
47   "fixed",
48   "shape",
49 };
50
51 static struct cf_section map_source_cf = {
52 #define P(x) PTR_TO(struct data_source, x)
53   CF_TYPE(struct data_source),
54   CF_ITEMS {
55     CF_STRING("File", P(file)),
56     CF_LOOKUP("Format", P(format), map_formats),
57     CF_LIST("StyleSheet", P(styles), &map_style_cf),
58     CF_INT("InlineStyles", P(inline_styles)),
59     CF_END
60   }
61 #undef P
62 };
63
64 static struct cf_section map_cf = {
65   CF_ITEMS {
66     CF_DOUBLE("MinX", &map_min_x),
67     CF_DOUBLE("MinY", &map_min_y),
68     CF_DOUBLE("MaxX", &map_max_x),
69     CF_DOUBLE("MaxY", &map_max_y),
70     CF_DOUBLE("PageWidth", &page_width),
71     CF_DOUBLE("PageHeight", &page_height),
72     CF_UNS("Clip", &map_clip),
73     CF_UNS("Rotate", &map_rotate),
74     CF_UNS("DrawBorder", &map_draw_border),
75     CF_LIST("Source", &map_sources, &map_source_cf),
76     CF_STRING("Projection", &map_projection),
77     CF_STRING("SVGOutput", &map_svg_output),
78     CF_END
79   }
80 };
81
82 static void CONSTRUCTOR map_preinit(void)
83 {
84   cf_declare_section("Map", &map_cf, 0);
85 }
86
87 // Calculated
88 double map_scale;
89 double page_offset_x, page_offset_y;
90 double page_map_width, page_map_height;
91
92 void map_set_scale(void)
93 {
94   double x_range = map_max_x - map_min_x;
95   double y_range = map_max_y - map_min_y;
96   double x_scale = page_width / x_range;
97   double y_scale = page_height / y_range;
98   map_scale = MIN(x_scale, y_scale);
99   page_map_width = x_range * map_scale;
100   page_map_height = y_range * map_scale;
101   page_offset_x = (page_width - page_map_width) / 2;
102   page_offset_y = (page_height - page_map_height) / 2;
103
104   msg(L_INFO, "Setting scale %.3g (orig window [%.6g,%.6g], page window [%.6g,%.6g]+[%.6g,%.6g] on [%.6g,%.6g])",
105     map_scale,
106     x_range, y_range,
107     page_map_width, page_map_height,
108     page_offset_x, page_offset_y,
109     page_width, page_height);
110
111   double pmin_x = INFINITY, pmax_x = -INFINITY;
112   double pmin_y = INFINITY, pmax_y = -INFINITY;
113   double rmin_x = INFINITY, rmax_x = -INFINITY;
114   double rmin_y = INFINITY, rmax_y = -INFINITY;
115   CLIST_FOR_EACH(struct data_source *, ds, map_sources)
116     {
117       if (ds->format == DATA_SOURCE_FIXED)
118         continue;
119       CLIST_FOR_EACH(struct osm_node *, n, ds->osm->obj_list[OSM_TYPE_NODE])
120         {
121           pmin_x = MIN(pmin_x, n->x);
122           pmax_x = MAX(pmax_x, n->x);
123           pmin_y = MIN(pmin_y, n->y);
124           pmax_y = MAX(pmax_y, n->y);
125           n->x = (n->x - map_min_x) * map_scale + page_offset_x;
126           n->y = page_height - page_offset_y - (n->y - map_min_y) * map_scale;
127           rmin_x = MIN(rmin_x, n->x);
128           rmax_x = MAX(rmax_x, n->x);
129           rmin_y = MIN(rmin_y, n->y);
130           rmax_y = MAX(rmax_y, n->y);
131         }
132     }
133   msg(L_INFO, "Bounds before scaling: [%.10g,%.10g] x [%.10g,%.10g]", pmin_x, pmax_x, pmin_y, pmax_y);
134   msg(L_INFO, "Bounds after scaling: [%.10g,%.10g] x [%.10g,%.10g]", rmin_x, rmax_x, rmin_y, rmax_y);
135
136   if (debug_dump_after_scaling)
137     {
138       puts("=== Map after scaling ===");
139       CLIST_FOR_EACH(struct data_source *, ds, map_sources)
140         {
141           osm_this = ds->osm;
142           osm_dump();
143         }
144     }
145 }
146
147 bool map_object_visible_p(struct osm_object *o)
148 {
149   double margin = 10;
150
151   switch (o->type)
152     {
153     case OSM_TYPE_NODE:
154       {
155         struct osm_node *n = (struct osm_node *) o;
156         return (n->x >= page_offset_x - margin && n->x <= page_offset_x + page_map_width + margin &&
157                 n->y >= page_offset_y - margin && n->y <= page_offset_y + page_map_height + margin);
158       }
159     case OSM_TYPE_WAY:
160       {
161         struct osm_way *w = (struct osm_way *) o;
162         bool ok = 0;
163         OSM_FOR_EACH_BEGIN(struct osm_object *, n, w->nodes)
164           {
165             ok |= map_object_visible_p(n);
166           }
167         OSM_FOR_EACH_END;
168         return ok;
169       }
170     case OSM_TYPE_RELATION:
171       {
172         struct osm_relation *r = (struct osm_relation *) o;
173         bool ok = 0;
174         OSM_FOR_EACH_BEGIN(struct osm_object *, n, r->members)
175           {
176             ok |= map_object_visible_p(n);
177           }
178         OSM_FOR_EACH_END;
179         return ok;
180       }
181     case OSM_TYPE_MULTIPOLYGON:
182       return map_object_visible_p(&((struct osm_multipolygon *) o)->rel->o);
183     default:
184       ASSERT(0);
185     }
186 }
187
188 void map_load_styles(void)
189 {
190   clist style_cache;
191   clist_init(&style_cache);
192
193   CLIST_FOR_EACH(struct data_source *, ds, map_sources)
194     {
195       CLIST_FOR_EACH(struct data_source_style *, ss, ds->styles)
196         {
197           CLIST_FOR_EACH(struct simp_node *, n, style_cache)
198             {
199               struct data_source_style *x = n->p;
200               if (!strcmp(x->name, ss->name))
201                 {
202                   ss->css = x->css;
203                   break;
204                 }
205             }
206           if (!ss->css)
207             {
208               msg(L_DEBUG, "Loading style sheet %s", ss->name);
209               ss->css = css_load(ss->name);
210
211               if (debug_dump_css)
212                 {
213                   printf("=== Stylesheet %s ===", ss->name);
214                   css_dump(ss->css);
215                 }
216
217               simp_append(cf_get_pool(), &style_cache)->p = ss;
218             }
219         }
220     }
221 }
222
223 static void map_load_source(struct data_source *ds)
224 {
225   ds->osm = osm_init();
226
227   bool need_mp = 0;
228   bool need_proj = 0;
229
230   switch (ds->format)
231     {
232     case DATA_SOURCE_OSMXML:
233       msg(L_INFO, "Parsing %s as OSM XML", ds->file);
234       if (!ds->file)
235         die("OSM XML data sources must have a file name");
236       osm_xml_parse(ds->file);
237       need_mp = 1;
238       need_proj = 1;
239       break;
240     case DATA_SOURCE_FIXED:
241       msg(L_INFO, "Adding fixed objects");
242       if (!ds->file)
243         ds->file = "fixed";
244       fixed_add();
245       break;
246     case DATA_SOURCE_SHAPE:
247       msg(L_INFO, "Parsing %s as shape file", ds->file);
248       if (!ds->file)
249         die("Shape data sources must have a file name");
250       shp_parse(ds->file);
251       need_proj = 1;
252       break;
253     default:
254       die("Invalid data source format");
255     }
256
257   osm_stats();
258   if (debug_dump_source)
259     {
260       puts("=== Source data ===");
261       osm_dump();
262     }
263   if (need_mp)
264     osm_make_multipolygons();
265
266   if (need_proj)
267     {
268       msg(L_INFO, "Projecting");
269       osm_project(map_projection);
270       if (debug_dump_after_proj)
271         {
272           puts("=== Map after projection ===");
273           osm_dump();
274         }
275     }
276 }
277
278 void map_load_sources(void)
279 {
280   CLIST_FOR_EACH(struct data_source *, ds, map_sources)
281     map_load_source(ds);
282 }
283
284 static void map_apply_inline_styles(struct osm_object *o, struct style_results *r)
285 {
286   char *name = NULL;
287
288   CLIST_FOR_EACH(struct osm_tag *, t, o->tags)
289     {
290       const char *key = osm_key_decode(t->key);
291       if (!strncmp(key, "style:", 6))
292         {
293           key += 6;
294           layer_t layer = STYLE_LAYER_DEFAULT;
295           char *sep = strstr(key, "::");
296           if (sep)
297             {
298               if (sep[2])
299                 {
300                   // XXX: Only layers defined in the main stylesheet can be modified
301                   layer = style_layer_encode_if_exists(sep+2);
302                   if (!layer)
303                     goto skip;
304                 }
305               int keylen = sep - key;
306               char *t = mp_alloc(r->pool, keylen+1);
307               memcpy(t, key, keylen);
308               t[keylen] = 0;
309               key = t;
310             }
311
312           if (!name)
313             name = mp_printf(r->pool, "Inline style in object #%ju", (uintmax_t) o->id);
314           struct style_prop *p= css_parse_prop(r->pool, name, key, osm_val_decode(t->val));
315           style_set_by_layer(r, layer, p);
316 skip: ;
317         }
318     }
319 }
320
321 void map_apply_styles(struct svg *svg)
322 {
323   struct style_results r;
324   style_init(&r);
325
326   CLIST_FOR_EACH(struct data_source *, ds, map_sources)
327     {
328       msg(L_INFO, "Applying stylesheet on %s", ds->file);
329       for (uns i = OSM_TYPE_NODE; i <= OSM_TYPE_MULTIPOLYGON; i++)
330         CLIST_FOR_EACH(struct osm_object *, o, ds->osm->obj_list[i])
331           {
332             if (debug_dump_styling)
333               {
334                 puts("===============================");
335                 osm_obj_dump(o);
336               }
337             if (!map_object_visible_p(o))
338               {
339                 if (debug_dump_styling)
340                   printf("--> invisible\n");
341                 continue;
342               }
343             style_begin(&r, o);
344             CLIST_FOR_EACH(struct data_source_style *, ss, ds->styles)
345               css_apply(ss->css, &r);
346             if (ds->inline_styles)
347               map_apply_inline_styles(o, &r);
348             if (debug_dump_styling)
349               style_dump(&r);
350             sym_from_style(o, &r, svg);
351             style_end(&r);
352           }
353     }
354
355   style_cleanup(&r);
356 }