settings/flex-base.lua

   1 -- Core functions for Nominatim import flex style.
   2 --
   3
   4 local module = {}
   5
   6 local PRE_DELETE = nil
   7 local PRE_EXTRAS = nil
   8 local MAIN_KEYS = nil
   9 local NAMES = nil
  10 local ADDRESS_TAGS = nil
  11 local SAVE_EXTRA_MAINS = false
  12 local POSTCODE_FALLBACK = true
  13
  14
  15 -- The single place table.
  16 place_table = osm2pgsql.define_table{
  17     name = "place",
  18     ids = { type = 'any', id_column = 'osm_id', type_column = 'osm_type' },
  19     columns = {
  20         { column = 'class', type = 'text', not_null = true },
  21         { column = 'type', type = 'text', not_null = true },
  22         { column = 'admin_level', type = 'smallint' },
  23         { column = 'name', type = 'hstore' },
  24         { column = 'address', type = 'hstore' },
  25         { column = 'extratags', type = 'hstore' },
  26         { column = 'geometry', type = 'geometry', projection = 'WGS84', not_null = true },
  27     },
  28     indexes = {}
  29 }
  30
  31 ------------ Geometry functions for relations ---------------------
  32
  33 function module.relation_as_multipolygon(o)
  34     return o:as_multipolygon()
  35 end
  36
  37 function module.relation_as_multiline(o)
  38     return o:as_multilinestring():line_merge()
  39 end
  40
  41
  42 module.RELATION_TYPES = {
  43     multipolygon = module.relation_as_multipolygon,
  44     boundary = module.relation_as_multipolygon,
  45     waterway = module.relation_as_multiline
  46 }
  47
  48 ------------- Place class ------------------------------------------
  49
  50 local Place = {}
  51 Place.__index = Place
  52
  53 function Place.new(object, geom_func)
  54     local self = setmetatable({}, Place)
  55     self.object = object
  56     self.geom_func = geom_func
  57
  58     self.admin_level = tonumber(self.object:grab_tag('admin_level'))
  59     if self.admin_level == nil
  60        or self.admin_level <= 0 or self.admin_level > 15
  61        or math.floor(self.admin_level) ~= self.admin_level then
  62         self.admin_level = 15
  63     end
  64
  65     self.num_entries = 0
  66     self.has_name = false
  67     self.names = {}
  68     self.address = {}
  69     self.extratags = {}
  70
  71     return self
  72 end
  73
  74 function Place:clean(data)
  75     for k, v in pairs(self.object.tags) do
  76         if data.delete ~= nil and data.delete(k, v) then
  77             self.object.tags[k] = nil
  78         elseif data.extra ~= nil and data.extra(k, v) then
  79             self.extratags[k] = v
  80             self.object.tags[k] = nil
  81         end
  82     end
  83 end
  84
  85 function Place:delete(data)
  86     if data.match ~= nil then
  87         for k, v in pairs(self.object.tags) do
  88             if data.match(k, v) then
  89                 self.object.tags[k] = nil
  90             end
  91         end
  92     end
  93 end
  94
  95 function Place:grab_extratags(data)
  96     local count = 0
  97
  98     if data.match ~= nil then
  99         for k, v in pairs(self.object.tags) do
 100             if data.match(k, v) then
 101                 self.object.tags[k] = nil
 102                 self.extratags[k] = v
 103                 count = count + 1
 104             end
 105         end
 106     end
 107
 108     return count
 109 end
 110
 111 function Place:grab_address(data)
 112     local count = 0
 113
 114     if data.match ~= nil then
 115         for k, v in pairs(self.object.tags) do
 116             if data.match(k, v) then
 117                 self.object.tags[k] = nil
 118
 119                 if data.include_on_name == true then
 120                     self.has_name = true
 121                 end
 122
 123                 if data.out_key ~= nil then
 124                     self.address[data.out_key] = v
 125                     return 1
 126                 end
 127
 128                 if k:sub(1, 5) == 'addr:' then
 129                     self.address[k:sub(6)] = v
 130                 elseif k:sub(1, 6) == 'is_in:' then
 131                     self.address[k:sub(7)] = v
 132                 else
 133                     self.address[k] = v
 134                 end
 135                 count = count + 1
 136             end
 137         end
 138     end
 139
 140     return count
 141 end
 142
 143 local function strip_address_prefix(k)
 144     if k:sub(1, 5) == 'addr:' then
 145         return k:sub(6)
 146     end
 147
 148     if k:sub(1, 6) == 'is_in:' then
 149         return k:sub(7)
 150     end
 151
 152     return k
 153 end
 154
 155
 156 function Place:grab_address_parts(data)
 157     local count = 0
 158
 159     if data.groups ~= nil then
 160         for k, v in pairs(self.object.tags) do
 161             local atype = data.groups(k, v)
 162
 163             if atype ~= nil then
 164                 if atype == 'main' then
 165                     self.has_name = true
 166                     self.address[strip_address_prefix(k)] = v
 167                     count = count + 1
 168                 elseif atype == 'extra' then
 169                     self.address[strip_address_prefix(k)] = v
 170                 else
 171                     self.address[atype] = v
 172                 end
 173                 self.object.tags[k] = nil
 174             end
 175         end
 176     end
 177
 178     return count
 179 end
 180
 181 function Place:grab_name(data)
 182     local count = 0
 183
 184     if data.match ~= nil then
 185         for k, v in pairs(self.object.tags) do
 186             if data.match(k, v) then
 187                 self.object.tags[k] = nil
 188                 self.names[k] = v
 189                 if data.include_on_name ~= false then
 190                     self.has_name = true
 191                 end
 192                 count = count + 1
 193             end
 194         end
 195     end
 196
 197     return count
 198 end
 199
 200 function Place:grab_name_parts(data)
 201     local fallback = nil
 202
 203     if data.groups ~= nil then
 204         for k, v in pairs(self.object.tags) do
 205             local atype = data.groups(k, v)
 206
 207             if atype ~= nil then
 208                 self.names[k] = v
 209                 self.object.tags[k] = nil
 210                 if atype == 'main' then
 211                     self.has_name = true
 212                 elseif atype == 'house' then
 213                     self.has_name = true
 214                     fallback = {'place', 'house', 'always'}
 215                 end
 216             end
 217         end
 218     end
 219
 220     return fallback
 221 end
 222
 223 function Place:grab_tag(key)
 224     return self.object:grab_tag(key)
 225 end
 226
 227 function Place:write_place(k, v, mtype, save_extra_mains)
 228     if mtype == nil then
 229         return 0
 230     end
 231
 232     v = v or self.object.tags[k]
 233     if v == nil then
 234         return 0
 235     end
 236
 237     if type(mtype) == 'table' then
 238         mtype = mtype[v] or mtype[1]
 239     end
 240
 241     if mtype == 'always' or (self.has_name and mtype == 'named') then
 242         return self:write_row(k, v, save_extra_mains)
 243     end
 244
 245     if mtype == 'named_with_key' then
 246         local names = {}
 247         local prefix = k .. ':name'
 248         for namek, namev in pairs(self.object.tags) do
 249             if namek:sub(1, #prefix) == prefix
 250                and (#namek == #prefix
 251                     or namek:sub(#prefix + 1, #prefix + 1) == ':') then
 252                 names[namek:sub(#k + 2)] = namev
 253             end
 254         end
 255
 256         if next(names) ~= nil then
 257             local saved_names = self.names
 258             self.names = names
 259
 260             local results = self:write_row(k, v, save_extra_mains)
 261
 262             self.names = saved_names
 263
 264             return results
 265         end
 266     end
 267
 268     return 0
 269 end
 270
 271 function Place:write_row(k, v, save_extra_mains)
 272     if self.geometry == nil then
 273         self.geometry = self.geom_func(self.object)
 274     end
 275     if self.geometry:is_null() then
 276         return 0
 277     end
 278
 279     if save_extra_mains then
 280         for extra_k, extra_v in pairs(self.object.tags) do
 281             if extra_k ~= k then
 282                 self.extratags[extra_k] = extra_v
 283             end
 284         end
 285     end
 286
 287     place_table:insert{
 288         class = k,
 289         type = v,
 290         admin_level = self.admin_level,
 291         name = next(self.names) and self.names,
 292         address = next(self.address) and self.address,
 293         extratags = next(self.extratags) and self.extratags,
 294         geometry = self.geometry
 295     }
 296
 297     if save_extra_mains then
 298         for k, v in pairs(self.object.tags) do
 299             self.extratags[k] = nil
 300         end
 301     end
 302
 303     self.num_entries = self.num_entries + 1
 304
 305     return 1
 306 end
 307
 308
 309 function module.tag_match(data)
 310     if data == nil or next(data) == nil then
 311         return nil
 312     end
 313
 314     local fullmatches = {}
 315     local key_prefixes = {}
 316     local key_suffixes = {}
 317
 318     if data.keys ~= nil then
 319         for _, key in pairs(data.keys) do
 320             if key:sub(1, 1) == '*' then
 321                 if #key > 1 then
 322                     if key_suffixes[#key - 1] == nil then
 323                         key_suffixes[#key - 1] = {}
 324                     end
 325                     key_suffixes[#key - 1][key:sub(2)] = true
 326                 end
 327             elseif key:sub(#key, #key) == '*' then
 328                 if key_prefixes[#key - 1] == nil then
 329                     key_prefixes[#key - 1] = {}
 330                 end
 331                 key_prefixes[#key - 1][key:sub(1, #key - 1)] = true
 332             else
 333                 fullmatches[key] = true
 334             end
 335         end
 336     end
 337
 338     if data.tags ~= nil then
 339         for k, vlist in pairs(data.tags) do
 340             if fullmatches[k] == nil then
 341                 fullmatches[k] = {}
 342                 for _, v in pairs(vlist) do
 343                     fullmatches[k][v] = true
 344                 end
 345             end
 346         end
 347     end
 348
 349     return function (k, v)
 350         if fullmatches[k] ~= nil and (fullmatches[k] == true or fullmatches[k][v] ~= nil) then
 351             return true
 352         end
 353
 354         for slen, slist in pairs(key_suffixes) do
 355             if #k >= slen and slist[k:sub(-slen)] ~= nil then
 356                 return true
 357             end
 358         end
 359
 360         for slen, slist in pairs(key_prefixes) do
 361             if #k >= slen and slist[k:sub(1, slen)] ~= nil then
 362                 return true
 363             end
 364         end
 365
 366         return false
 367     end
 368 end
 369
 370
 371 function module.tag_group(data)
 372     if data == nil or next(data) == nil then
 373         return nil
 374     end
 375
 376     local fullmatches = {}
 377     local key_prefixes = {}
 378     local key_suffixes = {}
 379
 380     for group, tags in pairs(data) do
 381         for _, key in pairs(tags) do
 382             if key:sub(1, 1) == '*' then
 383                 if #key > 1 then
 384                     if key_suffixes[#key - 1] == nil then
 385                         key_suffixes[#key - 1] = {}
 386                     end
 387                     key_suffixes[#key - 1][key:sub(2)] = group
 388                 end
 389             elseif key:sub(#key, #key) == '*' then
 390                 if key_prefixes[#key - 1] == nil then
 391                     key_prefixes[#key - 1] = {}
 392                 end
 393                 key_prefixes[#key - 1][key:sub(1, #key - 1)] = group
 394             else
 395                 fullmatches[key] = group
 396             end
 397         end
 398     end
 399
 400     return function (k, v)
 401         local val = fullmatches[k]
 402         if val ~= nil then
 403             return val
 404         end
 405
 406         for slen, slist in pairs(key_suffixes) do
 407             if #k >= slen then
 408                 val = slist[k:sub(-slen)]
 409                 if val ~= nil then
 410                     return val
 411                 end
 412             end
 413         end
 414
 415         for slen, slist in pairs(key_prefixes) do
 416             if #k >= slen then
 417                 val = slist[k:sub(1, slen)]
 418                 if val ~= nil then
 419                     return val
 420                 end
 421             end
 422         end
 423     end
 424 end
 425
 426 -- Process functions for all data types
 427 function osm2pgsql.process_node(object)
 428
 429     local function geom_func(o)
 430         return o:as_point()
 431     end
 432
 433     module.process_tags(Place.new(object, geom_func))
 434 end
 435
 436 function osm2pgsql.process_way(object)
 437
 438     local function geom_func(o)
 439         local geom = o:as_polygon()
 440
 441         if geom:is_null() then
 442             geom = o:as_linestring()
 443         end
 444
 445         return geom
 446     end
 447
 448     module.process_tags(Place.new(object, geom_func))
 449 end
 450
 451 function osm2pgsql.process_relation(object)
 452     local geom_func = module.RELATION_TYPES[object.tags.type]
 453
 454     if geom_func ~= nil then
 455         module.process_tags(Place.new(object, geom_func))
 456     end
 457 end
 458
 459 function module.process_tags(o)
 460     o:clean{delete = PRE_DELETE, extra = PRE_EXTRAS}
 461
 462     -- Exception for boundary/place double tagging
 463     if o.object.tags.boundary == 'administrative' then
 464         o:grab_extratags{match = function (k, v)
 465             return k == 'place' and v:sub(1,3) ~= 'isl'
 466         end}
 467     end
 468
 469     -- name keys
 470     local fallback = o:grab_name_parts{groups=NAMES}
 471
 472     -- address keys
 473     if o:grab_address_parts{groups=ADDRESS_TAGS} > 0 and fallback == nil then
 474         fallback = {'place', 'house', 'always'}
 475     end
 476     if o.address.country ~= nil and #o.address.country ~= 2 then
 477         o.address['country'] = nil
 478     end
 479     if POSTCODE_FALLBACK and fallback == nil and o.address.postcode ~= nil then
 480         fallback = {'place', 'postcode', 'always'}
 481     end
 482
 483     if o.address.interpolation ~= nil then
 484         o:write_place('place', 'houses', 'always', SAVE_EXTRA_MAINS)
 485         return
 486     end
 487
 488     o:clean{delete = POST_DELETE, extra = POST_EXTRAS}
 489
 490     -- collect main keys
 491     for k, v in pairs(o.object.tags) do
 492         local ktype = MAIN_KEYS[k]
 493         if ktype == 'fallback' then
 494             if o.has_name then
 495                 fallback = {k, v, 'named'}
 496             end
 497         elseif ktype ~= nil then
 498             o:write_place(k, v, MAIN_KEYS[k], SAVE_EXTRA_MAINS)
 499         end
 500     end
 501
 502     if fallback ~= nil and o.num_entries == 0 then
 503         o:write_place(fallback[1], fallback[2], fallback[3], SAVE_EXTRA_MAINS)
 504     end
 505 end
 506
 507 --------- Convenience functions for simple style configuration -----------------
 508
 509
 510 function module.set_prefilters(data)
 511     PRE_DELETE = module.tag_match{keys = data.delete_keys, tags = data.delete_tags}
 512     PRE_EXTRAS = module.tag_match{keys = data.extratag_keys,
 513                                   tags = data.extratag_tags}
 514 end
 515
 516 function module.set_main_tags(data)
 517     MAIN_KEYS = data
 518 end
 519
 520 function module.set_name_tags(data)
 521     NAMES = module.tag_group(data)
 522 end
 523
 524 function module.set_address_tags(data)
 525     if data.postcode_fallback ~= nil then
 526         POSTCODE_FALLBACK = data.postcode_fallback
 527         data.postcode_fallback = nil
 528     end
 529
 530     ADDRESS_TAGS = module.tag_group(data)
 531 end
 532
 533 function module.set_unused_handling(data)
 534     if data.extra_keys == nil and data.extra_tags == nil then
 535         POST_DELETE = module.tag_match{data.delete_keys, tags = data.delete_tags}
 536         POST_EXTRAS = nil
 537         SAVE_EXTRA_MAINS = true
 538     elseif data.delete_keys == nil and data.delete_tags == nil then
 539         POST_DELETE = nil
 540         POST_EXTRAS = module.tag_match{data.extra_keys, tags = data.extra_tags}
 541         SAVE_EXTRA_MAINS = false
 542     else
 543         error("unused handler can have only 'extra_keys' or 'delete_keys' set.")
 544     end
 545 end
 546
 547 function set_relation_types(data)
 548     module.RELATION_TYPES = {}
 549     for k, v in data do
 550         if v == 'multipolygon' then
 551             module.RELATION_TYPES[k] = module.relation_as_multipolygon
 552         elseif v == 'multiline' then
 553             module.RELATION_TYPES[k] = module.relation_as_multiline
 554         end
 555     end
 556 end
 557
 558 return module