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 ~= nil then
 227         for extra_k, extra_v in pairs(self.object.tags) do
 228             if extra_k ~= k and save_extra_mains(extra_k, extra_v) 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             if save_extra_mains(k, v) then
 247                 self.extratags[k] = nil
 248             end
 249         end
 250     end
 251
 252     self.num_entries = self.num_entries + 1
 253
 254     return 1
 255 end
 256
 257
 258 function module.tag_match(data)
 259     if data == nil or next(data) == nil then
 260         return nil
 261     end
 262
 263     local fullmatches = {}
 264     local key_prefixes = {}
 265     local key_suffixes = {}
 266
 267     if data.keys ~= nil then
 268         for _, key in pairs(data.keys) do
 269             if key:sub(1, 1) == '*' then
 270                 if #key > 1 then
 271                     if key_suffixes[#key - 1] == nil then
 272                         key_suffixes[#key - 1] = {}
 273                     end
 274                     key_suffixes[#key - 1][key:sub(2)] = true
 275                 end
 276             elseif key:sub(#key, #key) == '*' then
 277                 if key_prefixes[#key - 1] == nil then
 278                     key_prefixes[#key - 1] = {}
 279                 end
 280                 key_prefixes[#key - 1][key:sub(1, #key - 1)] = true
 281             else
 282                 fullmatches[key] = true
 283             end
 284         end
 285     end
 286
 287     if data.tags ~= nil then
 288         for k, vlist in pairs(data.tags) do
 289             if fullmatches[k] == nil then
 290                 fullmatches[k] = {}
 291                 for _, v in pairs(vlist) do
 292                     fullmatches[k][v] = true
 293                 end
 294             end
 295         end
 296     end
 297
 298     return function (k, v)
 299         if fullmatches[k] ~= nil and (fullmatches[k] == true or fullmatches[k][v] ~= nil) then
 300             return true
 301         end
 302
 303         for slen, slist in pairs(key_suffixes) do
 304             if #k >= slen and slist[k:sub(-slen)] ~= nil then
 305                 return true
 306             end
 307         end
 308
 309         for slen, slist in pairs(key_prefixes) do
 310             if #k >= slen and slist[k:sub(1, slen)] ~= nil then
 311                 return true
 312             end
 313         end
 314
 315         return false
 316     end
 317 end
 318
 319
 320 function module.tag_group(data)
 321     if data == nil or next(data) == nil then
 322         return nil
 323     end
 324
 325     local fullmatches = {}
 326     local key_prefixes = {}
 327     local key_suffixes = {}
 328
 329     for group, tags in pairs(data) do
 330         for _, key in pairs(tags) do
 331             if key:sub(1, 1) == '*' then
 332                 if #key > 1 then
 333                     if key_suffixes[#key - 1] == nil then
 334                         key_suffixes[#key - 1] = {}
 335                     end
 336                     key_suffixes[#key - 1][key:sub(2)] = group
 337                 end
 338             elseif key:sub(#key, #key) == '*' then
 339                 if key_prefixes[#key - 1] == nil then
 340                     key_prefixes[#key - 1] = {}
 341                 end
 342                 key_prefixes[#key - 1][key:sub(1, #key - 1)] = group
 343             else
 344                 fullmatches[key] = group
 345             end
 346         end
 347     end
 348
 349     return function (k, v)
 350         local val = fullmatches[k]
 351         if val ~= nil then
 352             return val
 353         end
 354
 355         for slen, slist in pairs(key_suffixes) do
 356             if #k >= slen then
 357                 val = slist[k:sub(-slen)]
 358                 if val ~= nil then
 359                     return val
 360                 end
 361             end
 362         end
 363
 364         for slen, slist in pairs(key_prefixes) do
 365             if #k >= slen then
 366                 val = slist[k:sub(1, slen)]
 367                 if val ~= nil then
 368                     return val
 369                 end
 370             end
 371         end
 372     end
 373 end
 374
 375 -- Process functions for all data types
 376 function module.process_node(object)
 377
 378     local function geom_func(o)
 379         return o:as_point()
 380     end
 381
 382     module.process_tags(Place.new(object, geom_func))
 383 end
 384
 385 function module.process_way(object)
 386
 387     local function geom_func(o)
 388         local geom = o:as_polygon()
 389
 390         if geom:is_null() then
 391             geom = o:as_linestring()
 392         end
 393
 394         return geom
 395     end
 396
 397     module.process_tags(Place.new(object, geom_func))
 398 end
 399
 400 function module.process_relation(object)
 401     local geom_func = module.RELATION_TYPES[object.tags.type]
 402
 403     if geom_func ~= nil then
 404         module.process_tags(Place.new(object, geom_func))
 405     end
 406 end
 407
 408 -- The process functions are used by default by osm2pgsql.
 409 osm2pgsql.process_node = module.process_node
 410 osm2pgsql.process_way = module.process_way
 411 osm2pgsql.process_relation = module.process_relation
 412
 413 function module.process_tags(o)
 414     o:clean{delete = PRE_DELETE, extra = PRE_EXTRAS}
 415
 416     -- Exception for boundary/place double tagging
 417     if o.object.tags.boundary == 'administrative' then
 418         o:grab_extratags{match = function (k, v)
 419             return k == 'place' and v:sub(1,3) ~= 'isl'
 420         end}
 421     end
 422
 423     -- name keys
 424     local fallback = o:grab_name_parts{groups=NAMES}
 425
 426     -- address keys
 427     if o:grab_address_parts{groups=ADDRESS_TAGS} > 0 and fallback == nil then
 428         fallback = {'place', 'house', 'always'}
 429     end
 430     if o.address.country ~= nil and #o.address.country ~= 2 then
 431         o.address['country'] = nil
 432     end
 433     if POSTCODE_FALLBACK and fallback == nil and o.address.postcode ~= nil then
 434         fallback = {'place', 'postcode', 'always'}
 435     end
 436
 437     if o.address.interpolation ~= nil then
 438         o:write_place('place', 'houses', 'always', SAVE_EXTRA_MAINS)
 439         return
 440     end
 441
 442     o:clean{delete = POST_DELETE}
 443
 444     -- collect main keys
 445     for k, v in pairs(o.object.tags) do
 446         local ktype = MAIN_KEYS[k]
 447         if ktype == 'fallback' then
 448             if o.has_name then
 449                 fallback = {k, v, 'named'}
 450             end
 451         elseif ktype ~= nil then
 452             o:write_place(k, v, MAIN_KEYS[k], SAVE_EXTRA_MAINS)
 453         end
 454     end
 455
 456     if fallback ~= nil and o.num_entries == 0 then
 457         o:write_place(fallback[1], fallback[2], fallback[3], SAVE_EXTRA_MAINS)
 458     end
 459 end
 460
 461 --------- Convenience functions for simple style configuration -----------------
 462
 463
 464 function module.set_prefilters(data)
 465     PRE_DELETE = module.tag_match{keys = data.delete_keys, tags = data.delete_tags}
 466     PRE_EXTRAS = module.tag_match{keys = data.extra_keys,
 467                                   tags = data.extra_tags}
 468 end
 469
 470 function module.set_main_tags(data)
 471     MAIN_KEYS = data
 472 end
 473
 474 function module.set_name_tags(data)
 475     NAMES = module.tag_group(data)
 476 end
 477
 478 function module.set_address_tags(data)
 479     if data.postcode_fallback ~= nil then
 480         POSTCODE_FALLBACK = data.postcode_fallback
 481         data.postcode_fallback = nil
 482     end
 483
 484     ADDRESS_TAGS = module.tag_group(data)
 485 end
 486
 487 function module.set_unused_handling(data)
 488     if data.extra_keys == nil and data.extra_tags == nil then
 489         POST_DELETE = module.tag_match{keys = data.delete_keys, tags = data.delete_tags}
 490         SAVE_EXTRA_MAINS = function() return true end
 491     elseif data.delete_keys == nil and data.delete_tags == nil then
 492         POST_DELETE = nil
 493         SAVE_EXTRA_MAINS = module.tag_match{keys = data.extra_keys, tags = data.extra_tags}
 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