]> mj.ucw.cz Git - leo.git/blob - sym-text.c
Switched to UCW configure and build system
[leo.git] / sym-text.c
1 /*
2  *      Hic Est Leo -- Text Symbolizer
3  *
4  *      (c) 2014 Martin Mares <mj@ucw.cz>
5  */
6
7 #include <ucw/lib.h>
8 #include <ucw/stkstring.h>
9
10 #include <stdio.h>
11 #include <ft2build.h>
12 #include FT_FREETYPE_H
13 #include <pango/pangoft2.h>
14
15 #include "leo.h"
16 #include "osm.h"
17 #include "sym.h"
18 #include "map.h"
19
20 /*** Fonts ***/
21
22 struct text_font {
23   const char *family;
24   double size;
25   osm_val_t weight;
26   osm_val_t style;
27   PangoFontDescription *pango_font_desc;
28   char key[1];
29 };
30
31 #define HASH_NODE struct text_font
32 #define HASH_PREFIX(x) text_font_##x
33 #define HASH_KEY_ENDSTRING key
34 #define HASH_WANT_LOOKUP
35 #define HASH_LOOKUP_DETECT_NEW
36 #define HASH_USE_POOL sym_mp
37 #include <ucw/hashtable.h>
38
39 static PangoFontMap *pango_font_map;
40 static PangoContext *pango_context;
41
42 static double pt_to_mm(double pt)
43 {
44   return pt / 72 * 25.4;
45 }
46
47 static double mm_to_pt(double mm)
48 {
49   return mm / 25.4 * 72;
50 }
51
52 static double pango_to_mm(double pango)
53 {
54   return pt_to_mm(pango / PANGO_SCALE);
55 }
56
57 static double mm_to_pango(double mm)
58 {
59   return mm_to_pt(mm) * PANGO_SCALE;
60 }
61
62 /*
63  * Pango tries to do pixel-based optimizations in low resolutions.
64  * Work around it by scaling everything up.
65  */
66 #define FONT_HACK_FACTOR 30
67
68 static struct text_font *font_get(struct text_font *req)
69 {
70   char *key = stk_printf("%s:%.6g:%u:%u", req->family, req->size, req->weight, req->style);
71   int is_new = 0;
72   struct text_font *font = text_font_lookup(key, &is_new);
73   if (is_new)
74     {
75       msg(L_DEBUG, "Loading font %s (size %.6g, weight %s, style %s)", req->family, req->size, osm_val_decode(req->weight), osm_val_decode(req->style));
76       font->family = mp_strdup(sym_mp, req->family);
77       font->size = req->size;
78       font->weight = req->weight;
79       font->style = req->style;
80
81       PangoFontDescription *desc;
82       desc = pango_font_description_new();
83       ASSERT(desc);
84       pango_font_description_set_family(desc, font->family);
85       if (font->weight != VALUE_NORMAL)
86         pango_font_description_set_weight(desc, PANGO_WEIGHT_BOLD);
87       if (font->style != VALUE_NORMAL)
88         pango_font_description_set_style(desc, PANGO_STYLE_ITALIC);
89       pango_font_description_set_size(desc, mm_to_pango(font->size));
90       font->pango_font_desc = desc;
91
92 #if 1
93       // FIXME
94       PangoFont *pfont = pango_font_map_load_font(pango_font_map, pango_context, desc);
95       ASSERT(pfont);
96       PangoFontDescription *d2 = pango_font_describe(pfont);
97       ASSERT(d2);
98       msg(L_DEBUG, "Font desc: %s", pango_font_description_to_string(d2));
99
100       PangoFontMetrics *fm = pango_font_get_metrics(pfont, NULL);
101       ASSERT(fm);
102       msg(L_DEBUG, "Font metrics: asc=%.6g desc=%.6g", pango_to_mm(pango_font_metrics_get_ascent(fm)), pango_to_mm(pango_font_metrics_get_descent(fm)));
103 #endif
104     }
105   return font;
106 }
107
108 static void font_init(void)
109 {
110   text_font_init();
111
112   pango_font_map = pango_ft2_font_map_new();
113   ASSERT(pango_font_map);
114   pango_ft2_font_map_set_resolution((PangoFT2FontMap *) pango_font_map, 72 * FONT_HACK_FACTOR, 72 * FONT_HACK_FACTOR);
115   pango_context = pango_font_map_create_context(PANGO_FONT_MAP(pango_font_map));
116   ASSERT(pango_context);
117 }
118
119 static void text_size(struct sym_text *st)
120 {
121   PangoLayout *layout = pango_layout_new(pango_context);
122   pango_layout_set_font_description(layout, st->font->pango_font_desc);
123   pango_layout_set_text(layout, osm_val_decode(st->text), -1);
124   pango_layout_context_changed(layout);
125
126   PangoRectangle ext;
127   pango_layout_get_extents(layout, NULL, &ext);
128   // st->tx = pango_to_mm(ext.x) / FONT_HACK_FACTOR;
129   // st->ty = pango_to_mm(ext.y) / FONT_HACK_FACTOR;
130   st->tw = pango_to_mm(ext.width) / FONT_HACK_FACTOR;
131   st->th = pango_to_mm(pango_layout_get_baseline(layout)) / FONT_HACK_FACTOR;
132   st->td = pango_to_mm(ext.height) / FONT_HACK_FACTOR - st->th;
133
134   g_object_unref(layout);
135 }
136
137 /*** Elimination of duplicate texts ***/
138
139 // FIXME: Get rid of globals
140 #define DUP_TILE_SIZE 10
141 static int dup_tiles_w, dup_tiles_h;
142 static struct sym_text **dup_tiles;
143
144 static void text_dup_init(void)
145 {
146   dup_tiles_w = 1 + page_map_width / DUP_TILE_SIZE;
147   dup_tiles_h = 1 + page_map_height / DUP_TILE_SIZE;
148   dup_tiles = xmalloc_zero(sizeof(struct sym_text *) * dup_tiles_w * dup_tiles_h);
149   msg(L_DEBUG, "Allocated text tiles: %u x %u", dup_tiles_w, dup_tiles_h);
150 }
151
152 static int text_dup_coord(int x, int y)
153 {
154   ASSERT(x >= 0 && x < dup_tiles_w && y >= 0 && y < dup_tiles_h);
155   return x + y * dup_tiles_w;
156 }
157
158 static double text_quad_dist(struct sym_text *a, struct sym_text *b)
159 {
160   double dx = a->x - b->x;
161   double dy = a->y - b->y;
162   return dx*dx + dy*dy;
163 }
164
165 static bool text_dup_detect(struct sym_text *t, struct style_info *si)
166 {
167   // Out-of-frame texts are dropped immediately
168   double x = t->x - page_offset_x;
169   double y = t->y - page_offset_y;
170   if (x < 0 || x >= page_map_width ||
171       y < 0 || y >= page_map_height)
172         return 0;
173
174   int tile_x = x / DUP_TILE_SIZE;
175   int tile_y = y / DUP_TILE_SIZE;
176
177   double radius = 0;
178   style_get_number(si, PROP_TEXT_DUP_THRESHOLD, &radius);
179   if (radius)
180     {
181       // A rather simple-minded algorithm, but believed to be efficient enough.
182       int r_tiles = 1 + radius / DUP_TILE_SIZE;
183       int x_start = MAX(0, tile_x - r_tiles);
184       int x_stop = MIN(dup_tiles_w - 1, tile_x + r_tiles);
185       int y_start = MAX(0, tile_y - r_tiles);
186       int y_stop = MIN(dup_tiles_h - 1, tile_y + r_tiles);
187       for (int x = x_start; x <= x_stop; x++)
188         for (int y = y_start; y <= y_stop; y++)
189           {
190             for (struct sym_text *d = dup_tiles[text_dup_coord(x, y)]; d; d = d->next_in_tile)
191               if (d->text == t->text &&
192                   text_quad_dist(d, t) <= radius*radius &&
193                   d->text_color == t->text_color &&
194                   d->font == t->font)
195                 {
196                   t->next_duplicate = d->next_duplicate;
197                   d->next_duplicate = t;
198                   return 0;
199                 }
200           }
201     }
202
203   int tile_i = text_dup_coord(tile_x, tile_y);
204   t->next_in_tile = dup_tiles[tile_i];
205   dup_tiles[tile_i] = t;
206   return 1;
207 }
208
209 /*** Core of the symbolizer ***/
210
211 static void prepare_text_element(struct sym_text *t, struct svg *svg)
212 {
213   struct text_font *font = t->font;
214   svg_push_element(svg, "text");
215   svg_set_attr_dimen(svg, "x", t->x);
216   svg_set_attr_dimen(svg, "y", t->y);
217   svg_set_attr(svg, "font-family", font->family);
218   svg_set_attr_dimen(svg, "font-size", font->size);
219   if (font->weight != VALUE_NORMAL)
220     svg_set_attr(svg, "font-weight", osm_val_decode(font->weight));
221   if (font->style != VALUE_NORMAL)
222     svg_set_attr(svg, "font-style", osm_val_decode(font->style));
223 }
224
225 static void sym_text_draw(struct symbol *sym, struct svg *svg)
226 {
227   struct sym_text *t = (struct sym_text *) sym;
228
229   if (t->next_duplicate)
230     {
231       // If there is a cluster of duplicate texts, average their positions
232       double sx = 0, sy = 0;
233       uns nn = 0;
234       for (struct sym_text *u = t; u; u = u->next_duplicate)
235         {
236           sx += u->x;
237           sy += u->y;
238           nn++;
239         }
240       t->x = sx / nn;
241       t->y = sy / nn;
242     }
243
244   if (t->opacity != 1)
245     {
246       svg_push_element(svg, "g");
247       svg_set_attr_float(svg, "opacity", t->opacity);
248     }
249
250   if (t->halo_radius)
251     {
252       prepare_text_element(t, svg);
253       svg_set_attr(svg, "fill", "none");
254       svg_set_attr_color(svg, "stroke", t->halo_color);
255       svg_set_attr_dimen(svg, "stroke-width", t->halo_radius);
256       svg_set_attr(svg, "stroke-linecap", "round");
257       svg_set_attr(svg, "stroke-linejoin", "round");
258       if (t->halo_opacity != 1)
259         svg_set_attr_float(svg, "stroke-opacity", t->halo_opacity);
260       svg_push_chars(svg)->name = osm_val_decode(t->text);
261       svg_pop(svg);
262       svg_pop(svg);
263     }
264
265   prepare_text_element(t, svg);
266   svg_set_attr_color(svg, "fill", t->text_color);
267   svg_set_attr(svg, "stroke", "none");
268   svg_push_chars(svg)->name = osm_val_decode(t->text);
269   svg_pop(svg);
270   svg_pop(svg);
271
272 #if 0
273   // Draw bounding box for debugging
274   svg_push_element(svg, "rect");
275   svg_set_attr(svg, "fill", "none");
276   svg_set_attr_color(svg, "stroke", 0x0000ff);
277   svg_set_attr_dimen(svg, "stroke-width", 0.2);
278   svg_set_attr_dimen(svg, "x", t->x);
279   svg_set_attr_dimen(svg, "y", t->y - t->th);
280   svg_set_attr_dimen(svg, "width", t->tw);
281   svg_set_attr_dimen(svg, "height", t->th + t->td);
282   svg_pop(svg);
283
284   svg_push_element(svg, "line");
285   svg_set_attr(svg, "fill", "none");
286   svg_set_attr_color(svg, "stroke", 0x0000ff);
287   svg_set_attr_dimen(svg, "stroke-width", 0.2);
288   svg_set_attr_dimen(svg, "x1", t->x);
289   svg_set_attr_dimen(svg, "y1", t->y);
290   svg_set_attr_dimen(svg, "x2", t->x + t->tw);
291   svg_set_attr_dimen(svg, "y2", t->y);
292   svg_pop(svg);
293 #endif
294
295   if (t->opacity != 1)
296     svg_pop(svg);
297 }
298
299 static osm_val_t get_text(struct osm_object *o, struct style_info *si)
300 {
301   struct style_prop *prop = style_get_and_check(si, PROP_TEXT, (1 << PROP_TYPE_STRING) | (1 << PROP_TYPE_IDENT));
302   if (!prop)
303     return 0;
304
305   if (prop->type == PROP_TYPE_IDENT && prop->val.id == VALUE_AUTO)
306     {
307       static const osm_key_t auto_text_keys[] = {
308         KEY_NAME_CZ,            // FIXME: This should be configurable
309         KEY_NAME,
310         KEY_REF,
311         KEY_OPERATOR,
312         KEY_BRAND,
313         KEY_ADDR_HOUSENUMBER,
314       };
315       for (uns i=0; i < ARRAY_SIZE(auto_text_keys); i++)
316         {
317           osm_val_t val = osm_obj_find_tag(o, auto_text_keys[i]);
318           if (val)
319             return val;
320         }
321       return 0;
322     }
323
324   return osm_obj_find_tag(o, osm_key_encode(osm_val_decode(prop->val.id)));
325 }
326
327 static void get_text_attrs(struct sym_text *st, struct style_info *si)
328 {
329   struct osm_object *o = st->s.o;
330   if (o->type == OSM_TYPE_WAY && osm_way_cyclic_p((struct osm_way *) o))
331     st->text_color = 0xc0c0c0;  // FIXME: This is an ugly hack, do we need it?
332   else
333     st->text_color = 0xffffff;
334   style_get_color(si, PROP_TEXT_COLOR, &st->text_color);
335
336   struct text_font f = {
337     .family = "Helvetica",
338     .size = pt_to_mm(8),
339   };
340   osm_val_t fam = style_get_string(si, PROP_FONT_FAMILY);
341   if (fam)
342     f.family = osm_val_decode(fam);
343   style_get_number(si, PROP_FONT_SIZE, &f.size);
344   f.weight = style_get_ident(si, PROP_FONT_WEIGHT);
345   if (!f.weight)
346     f.weight = VALUE_NORMAL;
347   if (f.weight != VALUE_NORMAL && f.weight != VALUE_BOLD)
348     {
349       osm_obj_warn(o, "Unknown font-weight %s", osm_val_decode(f.weight));
350       f.weight = VALUE_NORMAL;
351     }
352   f.style = style_get_ident(si, PROP_FONT_STYLE);
353   if (!f.style)
354     f.style = VALUE_NORMAL;
355   if (f.style != VALUE_NORMAL && f.style != VALUE_ITALIC)
356     {
357       osm_obj_warn(o, "Unknown font-style %s", osm_val_decode(f.weight));
358       f.style = VALUE_NORMAL;
359     }
360   st->font = font_get(&f);
361
362   st->opacity = 1;
363   style_get_number(si, PROP_TEXT_OPACITY, &st->opacity);
364
365   st->halo_color = st->text_color ^ 0xffffff;
366   style_get_color(si, PROP_TEXT_HALO_COLOR, &st->halo_color);
367   st->halo_radius = 0;
368   style_get_number(si, PROP_TEXT_HALO_RADIUS, &st->halo_radius);
369   st->halo_opacity = 1;
370   style_get_number(si, PROP_TEXT_HALO_OPACITY, &st->halo_opacity);
371
372   double dx = 0, dy = 0;
373   style_get_number(si, PROP_TEXT_OFFSET_X, &dx);
374   style_get_number(si, PROP_TEXT_OFFSET_Y, &dy);
375   style_get_number(si, PROP_TEXT_OFFSET, &dy);
376   st->x += dx;
377   st->y -= dy;
378 }
379
380 static void text_fix_placement(struct sym_text *st)
381 {
382   // Fix texts which do not fit on the paper
383   st->x = MIN(st->x, page_offset_x + page_map_width - st->tw);
384   st->x = MAX(st->x, page_offset_x);
385   st->y = MIN(st->y, page_offset_y + page_map_height - st->th);
386   st->y = MAX(st->y, page_offset_y + st->td);
387 }
388
389 static void sym_text_node(struct osm_object *o, struct style_info *si, osm_val_t text)
390 {
391   struct osm_node *n = (struct osm_node *) o;
392
393   struct sym_text *st = sym_text_new(o);
394   st->text = text;
395   st->x = n->x;
396   st->y = n->y;
397
398   get_text_attrs(st, si);
399   text_size(st);
400
401   osm_val_t ah = style_get_ident(si, PROP_TEXT_ANCHOR_HORIZONTAL);
402   switch (ah)
403     {
404     case VALUE_LEFT:
405       st->x -= st->tw;
406       break;
407     case VALUE_CENTER:
408       st->x -= st->tw / 2;
409       break;
410     case 0:
411     case VALUE_RIGHT:
412       break;
413     default:
414       osm_obj_warn(o, "Unknown text-anchor-horizontal: %s", osm_val_decode(ah));
415     }
416
417   osm_val_t av = style_get_ident(si, PROP_TEXT_ANCHOR_VERTICAL);
418   switch (av)
419     {
420     case VALUE_ABOVE:           // FIXME: What's the difference between above and top?
421     case VALUE_TOP:
422       st->y -= st->td;
423       break;
424     case VALUE_CENTER:
425       st->y -= (st->th + st->td) / 2;
426       // Fall thru
427     case 0:
428     case VALUE_BOTTOM:
429     case VALUE_BELOW:
430       st->y += st->th;
431       break;
432     default:
433       osm_obj_warn(o, "Unknown text-anchor-vertical: %s", osm_val_decode(av));
434     }
435
436   text_fix_placement(st);
437   if (!text_dup_detect(st, si))
438     {
439       msg(L_DEBUG, "Text <%s> dropped as duplicate", osm_val_decode(text));
440       return;
441     }
442
443   sym_plan(&st->s, sym_zindex(o, si, 5));
444 }
445
446 static void sym_text_center(struct osm_object *o, struct style_info *si, osm_val_t text, double x, double y)
447 {
448   struct sym_text *st = sym_text_new(o);
449   st->text = text;
450   st->x = x;
451   st->y = y;
452
453   get_text_attrs(st, si);
454   text_size(st);
455   st->x -= st->tw / 2;
456   st->y += st->th - (st->th + st->td) / 2;
457   text_fix_placement(st);
458   sym_plan(&st->s, sym_zindex(o, si, 4.9));
459 }
460
461 static void sym_text_way(struct osm_object *o, struct style_info *si, osm_val_t text)
462 {
463   double x, y;
464   osm_val_t tp = style_get_ident(si, PROP_TEXT_POSITION);
465
466   switch (tp)
467     {
468     case VALUE_CENTER:
469       if (osm_obj_center(o, &x, &y))
470         sym_text_center(o, si, text, x, y);
471       break;
472     case VALUE_LINE:
473       // FIXME
474     default:
475       osm_obj_warn(o, "Unknown text-position: %s", osm_val_decode(tp));
476     }
477 }
478
479 static void sym_text_mpg(struct osm_object *o, struct style_info *si, osm_val_t text)
480 {
481   double x, y;
482   osm_val_t tp = style_get_ident(si, PROP_TEXT_POSITION);
483
484   switch (tp)
485     {
486     case VALUE_CENTER:
487       if (osm_obj_center(o, &x, &y))
488         sym_text_center(o, si, text, x, y);
489       break;
490     case VALUE_LINE:
491       // FIXME
492     default:
493       osm_obj_warn(o, "Unknown text-position: %s", osm_val_decode(tp));
494     }
495 }
496
497 static void sym_text_gen(struct osm_object *o, struct style_info *si, struct svg *svg UNUSED)
498 {
499   osm_val_t text = get_text(o, si);
500   if (!text)
501     return;
502
503   switch (o->type)
504     {
505     case OSM_TYPE_NODE:
506       sym_text_node(o, si, text);
507       break;
508     case OSM_TYPE_WAY:
509       sym_text_way(o, si, text);
510       break;
511     case OSM_TYPE_MULTIPOLYGON:
512       sym_text_mpg(o, si, text);
513       break;
514     default:
515       osm_obj_warn(o, "Text symbolizer does not support this object type");
516       return;
517     }
518 }
519
520 static void sym_text_init(void)
521 {
522   font_init();
523   text_dup_init();
524 }
525
526 struct symbolizer symbolizer_text = {
527   .name = "text",
528   .draw = sym_text_draw,
529   .gen = sym_text_gen,
530   .init = sym_text_init,
531 };
532
533 struct sym_text *sym_text_new(struct osm_object *o)
534 {
535   return sym_new(SYMBOLIZER_TEXT, o, sizeof(struct sym_text));
536 }
537
538 // FIXME: Hack
539 void scale_text(struct svg *svg, double x, double y, osm_val_t text)
540 {
541   struct sym_text *st = sym_text_new(NULL);
542
543   struct text_font f = {
544     .family = "Times",
545     .weight = VALUE_NORMAL,
546     .style = VALUE_NORMAL,
547     .size = pt_to_mm(10),
548   };
549
550   st->text = text;
551   st->text_color = 0;
552   st->x = x;
553   st->y = y;
554   st->font = font_get(&f);
555   st->opacity = 1;
556   st->halo_color = 0xffffff;
557   st->halo_radius = 0.8;
558   st->halo_opacity = 1;
559   text_size(st);
560   st->x -= st->tw / 2;
561   sym_text_draw(&st->s, svg);
562 }