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