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 local 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 local function strip_address_prefix(k)
 112     if k:sub(1, 5) == 'addr:' then
 113         return k:sub(6)
 114     end
 115
 116     if k:sub(1, 6) == 'is_in:' then
 117         return k:sub(7)
 118     end
 119
 120     return k
 121 end
 122
 123
 124 function Place:grab_address_parts(data)
 125     local count = 0
 126
 127     if data.groups ~= nil then
 128         for k, v in pairs(self.object.tags) do
 129             local atype = data.groups(k, v)
 130
 131             if atype ~= nil then
 132                 if atype == 'main' then
 133                     self.has_name = true
 134                     self.address[strip_address_prefix(k)] = v
 135                     count = count + 1
 136                 elseif atype == 'extra' then
 137                     self.address[strip_address_prefix(k)] = v
 138                 else
 139                     self.address[atype] = v
 140                 end
 141                 self.object.tags[k] = nil
 142             end
 143         end
 144     end
 145
 146     return count
 147 end
 148
 149
 150 function Place:grab_name_parts(data)
 151     local fallback = nil
 152
 153     if data.groups ~= nil then
 154         for k, v in pairs(self.object.tags) do
 155             local atype = data.groups(k, v)
 156
 157             if atype ~= nil then
 158                 self.names[k] = v
 159                 self.object.tags[k] = nil
 160                 if atype == 'main' then
 161                     self.has_name = true
 162                 elseif atype == 'house' then
 163                     self.has_name = true
 164                     fallback = {'place', 'house', 'always'}
 165                 end
 166             end
 167         end
 168     end
 169
 170     return fallback
 171 end
 172
 173
 174 function Place:write_place(k, v, mtype, save_extra_mains)
 175     if mtype == nil then
 176         return 0
 177     end
 178
 179     v = v or self.object.tags[k]
 180     if v == nil then
 181         return 0
 182     end
 183
 184     if type(mtype) == 'table' then
 185         mtype = mtype[v] or mtype[1]
 186     end
 187
 188     if mtype == 'always' or (self.has_name and mtype == 'named') then
 189         return self:write_row(k, v, save_extra_mains)
 190     end
 191
 192     if mtype == 'named_with_key' then
 193         local names = {}
 194         local prefix = k .. ':name'
 195         for namek, namev in pairs(self.object.tags) do
 196             if namek:sub(1, #prefix) == prefix
 197                and (#namek == #prefix
 198                     or namek:sub(#prefix + 1, #prefix + 1) == ':') then
 199                 names[namek:sub(#k + 2)] = namev
 200             end
 201         end
 202
 203         if next(names) ~= nil then
 204             local saved_names = self.names
 205             self.names = names
 206
 207             local results = self:write_row(k, v, save_extra_mains)
 208
 209             self.names = saved_names
 210
 211             return results
 212         end
 213     end
 214
 215     return 0
 216 end
 217
 218 function Place:write_row(k, v, save_extra_mains)
 219     if self.geometry == nil then
 220         self.geometry = self.geom_func(self.object)
 221     end
 222     if self.geometry:is_null() then
 223         return 0
 224     end
 225
 226     if save_extra_mains then
 227         for extra_k, extra_v in pairs(self.object.tags) do
 228             if extra_k ~= k then
 229                 self.extratags[extra_k] = extra_v
 230             end
 231         end
 232     end
 233
 234     place_table:insert{
 235         class = k,
 236         type = v,
 237         admin_level = self.admin_level,
 238         name = next(self.names) and self.names,
 239         address = next(self.address) and self.address,
 240         extratags = next(self.extratags) and self.extratags,
 241         geometry = self.geometry
 242     }
 243
 244     if save_extra_mains then
 245         for k, v in pairs(self.object.tags) do
 246             self.extratags[k] = nil
 247         end
 248     end
 249
 250     self.num_entries = self.num_entries + 1
 251
 252     return 1
 253 end
 254
 255
 256 function module.tag_match(data)
 257     if data == nil or next(data) == nil then
 258         return nil
 259     end
 260
 261     local fullmatches = {}
 262     local key_prefixes = {}
 263     local key_suffixes = {}
 264
 265     if data.keys ~= nil then
 266         for _, key in pairs(data.keys) do
 267             if key:sub(1, 1) == '*' then
 268                 if #key > 1 then
 269                     if key_suffixes[#key - 1] == nil then
 270                         key_suffixes[#key - 1] = {}
 271                     end
 272                     key_suffixes[#key - 1][key:sub(2)] = true
 273                 end
 274             elseif key:sub(#key, #key) == '*' then
 275                 if key_prefixes[#key - 1] == nil then
 276                     key_prefixes[#key - 1] = {}
 277                 end
 278                 key_prefixes[#key - 1][key:sub(1, #key - 1)] = true
 279             else
 280                 fullmatches[key] = true
 281             end
 282         end
 283     end
 284
 285     if data.tags ~= nil then
 286         for k, vlist in pairs(data.tags) do
 287             if fullmatches[k] == nil then
 288                 fullmatches[k] = {}
 289                 for _, v in pairs(vlist) do
 290                     fullmatches[k][v] = true
 291                 end
 292             end
 293         end
 294     end
 295
 296     return function (k, v)
 297         if fullmatches[k] ~= nil and (fullmatches[k] == true or fullmatches[k][v] ~= nil) then
 298             return true
 299         end
 300
 301         for slen, slist in pairs(key_suffixes) do
 302             if #k >= slen and slist[k:sub(-slen)] ~= nil then
 303                 return true
 304             end
 305         end
 306
 307         for slen, slist in pairs(key_prefixes) do
 308             if #k >= slen and slist[k:sub(1, slen)] ~= nil then
 309                 return true
 310             end
 311         end
 312
 313         return false
 314     end
 315 end
 316
 317
 318 function module.tag_group(data)
 319     if data == nil or next(data) == nil then
 320         return nil
 321     end
 322
 323     local fullmatches = {}
 324     local key_prefixes = {}
 325     local key_suffixes = {}
 326
 327     for group, tags in pairs(data) do
 328         for _, key in pairs(tags) do
 329             if key:sub(1, 1) == '*' then
 330                 if #key > 1 then
 331                     if key_suffixes[#key - 1] == nil then
 332                         key_suffixes[#key - 1] = {}
 333                     end
 334                     key_suffixes[#key - 1][key:sub(2)] = group
 335                 end
 336             elseif key:sub(#key, #key) == '*' then
 337                 if key_prefixes[#key - 1] == nil then
 338                     key_prefixes[#key - 1] = {}
 339                 end
 340                 key_prefixes[#key - 1][key:sub(1, #key - 1)] = group
 341             else
 342                 fullmatches[key] = group
 343             end
 344         end
 345     end
 346
 347     return function (k, v)
 348         local val = fullmatches[k]
 349         if val ~= nil then
 350             return val
 351         end
 352
 353         for slen, slist in pairs(key_suffixes) do
 354             if #k >= slen then
 355                 val = slist[k:sub(-slen)]
 356                 if val ~= nil then
 357                     return val
 358                 end
 359             end
 360         end
 361
 362         for slen, slist in pairs(key_prefixes) do
 363             if #k >= slen then
 364                 val = slist[k:sub(1, slen)]
 365                 if val ~= nil then
 366                     return val
 367                 end
 368             end
 369         end
 370     end
 371 end
 372
 373 -- Process functions for all data types
 374 function module.process_node(object)
 375
 376     local function geom_func(o)
 377         return o:as_point()
 378     end
 379
 380     module.process_tags(Place.new(object, geom_func))
 381 end
 382
 383 function module.process_way(object)
 384
 385     local function geom_func(o)
 386         local geom = o:as_polygon()
 387
 388         if geom:is_null() then
 389             geom = o:as_linestring()
 390         end
 391
 392         return geom
 393     end
 394
 395     module.process_tags(Place.new(object, geom_func))
 396 end
 397
 398 function module.process_relation(object)
 399     local geom_func = module.RELATION_TYPES[object.tags.type]
 400
 401     if geom_func ~= nil then
 402         module.process_tags(Place.new(object, geom_func))
 403     end
 404 end
 405
 406 -- The process functions are used by default by osm2pgsql.
 407 osm2pgsql.process_node = module.process_node
 408 osm2pgsql.process_way = module.process_way
 409 osm2pgsql.process_relation = module.process_relation
 410
 411 function module.process_tags(o)
 412     o:clean{delete = PRE_DELETE, extra = PRE_EXTRAS}
 413
 414     -- Exception for boundary/place double tagging
 415     if o.object.tags.boundary == 'administrative' then
 416         o:grab_extratags{match = function (k, v)
 417             return k == 'place' and v:sub(1,3) ~= 'isl'
 418         end}
 419     end
 420
 421     -- name keys
 422     local fallback = o:grab_name_parts{groups=NAMES}
 423
 424     -- address keys
 425     if o:grab_address_parts{groups=ADDRESS_TAGS} > 0 and fallback == nil then
 426         fallback = {'place', 'house', 'always'}
 427     end
 428     if o.address.country ~= nil and #o.address.country ~= 2 then
 429         o.address['country'] = nil
 430     end
 431     if POSTCODE_FALLBACK and fallback == nil and o.address.postcode ~= nil then
 432         fallback = {'place', 'postcode', 'always'}
 433     end
 434
 435     if o.address.interpolation ~= nil then
 436         o:write_place('place', 'houses', 'always', SAVE_EXTRA_MAINS)
 437         return
 438     end
 439
 440     o:clean{delete = POST_DELETE, extra = POST_EXTRAS}
 441
 442     -- collect main keys
 443     for k, v in pairs(o.object.tags) do
 444         local ktype = MAIN_KEYS[k]
 445         if ktype == 'fallback' then
 446             if o.has_name then
 447                 fallback = {k, v, 'named'}
 448             end
 449         elseif ktype ~= nil then
 450             o:write_place(k, v, MAIN_KEYS[k], SAVE_EXTRA_MAINS)
 451         end
 452     end
 453
 454     if fallback ~= nil and o.num_entries == 0 then
 455         o:write_place(fallback[1], fallback[2], fallback[3], SAVE_EXTRA_MAINS)
 456     end
 457 end
 458
 459 --------- Convenience functions for simple style configuration -----------------
 460
 461
 462 function module.set_prefilters(data)
 463     PRE_DELETE = module.tag_match{keys = data.delete_keys, tags = data.delete_tags}
 464     PRE_EXTRAS = module.tag_match{keys = data.extra_keys,
 465                                   tags = data.extra_tags}
 466 end
 467
 468 function module.set_main_tags(data)
 469     MAIN_KEYS = data
 470 end
 471
 472 function module.set_name_tags(data)
 473     NAMES = module.tag_group(data)
 474 end
 475
 476 function module.set_address_tags(data)
 477     if data.postcode_fallback ~= nil then
 478         POSTCODE_FALLBACK = data.postcode_fallback
 479         data.postcode_fallback = nil
 480     end
 481
 482     ADDRESS_TAGS = module.tag_group(data)
 483 end
 484
 485 function module.set_unused_handling(data)
 486     if data.extra_keys == nil and data.extra_tags == nil then
 487         POST_DELETE = module.tag_match{keys = data.delete_keys, tags = data.delete_tags}
 488         POST_EXTRAS = nil
 489         SAVE_EXTRA_MAINS = true
 490     elseif data.delete_keys == nil and data.delete_tags == nil then
 491         POST_DELETE = nil
 492         POST_EXTRAS = module.tag_match{keys = data.extra_keys, tags = data.extra_tags}
 493         SAVE_EXTRA_MAINS = false
 494     else
 495         error("unused handler can have only 'extra_keys' or 'delete_keys' set.")
 496     end
 497 end
 498
 499 function set_relation_types(data)
 500     module.RELATION_TYPES = {}
 501     for k, v in data do
 502         if v == 'multipolygon' then
 503             module.RELATION_TYPES[k] = module.relation_as_multipolygon
 504         elseif v == 'multiline' then
 505             module.RELATION_TYPES[k] = module.relation_as_multiline
 506         end
 507     end
 508 end
 509
 510 return module