settings/flex-base.lua

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