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