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