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