vendor/assets/leaflet/leaflet.osm.js

   1 L.OSM = {};
   2
   3 L.OSM.TileLayer = L.TileLayer.extend({
   4   options: {
   5     url: 'https://tile.openstreetmap.org/{z}/{x}/{y}.png',
   6     attribution: '© <a href="https://www.openstreetmap.org/copyright" target="_blank">OpenStreetMap</a> contributors'
   7   },
   8
   9   initialize: function (options) {
  10     options = L.Util.setOptions(this, options);
  11     L.TileLayer.prototype.initialize.call(this, options.url);
  12   }
  13 });
  14
  15 L.OSM.Mapnik = L.OSM.TileLayer.extend({
  16   options: {
  17     url: 'https://tile.openstreetmap.org/{z}/{x}/{y}.png',
  18     maxZoom: 19
  19   }
  20 });
  21
  22 L.OSM.CyclOSM = L.OSM.TileLayer.extend({
  23   options: {
  24     url: 'https://{s}.tile-cyclosm.openstreetmap.fr/cyclosm/{z}/{x}/{y}.png',
  25     maxZoom: 20,
  26     subdomains: 'abc',
  27     attribution: '© <a href="https://www.openstreetmap.org/copyright" target="_blank">OpenStreetMap</a> contributors. Tiles courtesy of <a href="https://www.openstreetmap.fr" target="_blank">OpenStreetMap France</a>'
  28   }
  29 });
  30
  31 L.OSM.CycleMap = L.OSM.TileLayer.extend({
  32   options: {
  33     url: 'https://{s}.tile.thunderforest.com/cycle/{z}/{x}/{y}{r}.png?apikey={apikey}',
  34     maxZoom: 21,
  35     attribution: '© <a href="https://www.openstreetmap.org/copyright" target="_blank">OpenStreetMap</a> contributors. Tiles courtesy of <a href="http://www.thunderforest.com/" target="_blank">Andy Allan</a>'
  36   }
  37 });
  38
  39 L.OSM.TransportMap = L.OSM.TileLayer.extend({
  40   options: {
  41     url: 'https://{s}.tile.thunderforest.com/transport/{z}/{x}/{y}{r}.png?apikey={apikey}',
  42     maxZoom: 21,
  43     attribution: '© <a href="https://www.openstreetmap.org/copyright" target="_blank">OpenStreetMap</a> contributors. Tiles courtesy of <a href="http://www.thunderforest.com/" target="_blank">Andy Allan</a>'
  44   }
  45 });
  46
  47 L.OSM.TransportDarkMap = L.OSM.TileLayer.extend({
  48   options: {
  49     url: 'https://{s}.tile.thunderforest.com/transport-dark/{z}/{x}/{y}{r}.png?apikey={apikey}',
  50     maxZoom: 21,
  51     attribution: '© <a href="https://www.openstreetmap.org/copyright" target="_blank">OpenStreetMap</a> contributors. Tiles courtesy of <a href="http://www.thunderforest.com/" target="_blank">Andy Allan</a>'
  52   }
  53 });
  54
  55 L.OSM.OPNVKarte = L.OSM.TileLayer.extend({
  56   options: {
  57     url: 'https://tileserver.memomaps.de/tilegen/{z}/{x}/{y}.png',
  58     maxZoom: 18,
  59     attribution: '© <a href="https://www.openstreetmap.org/copyright" target="_blank">OpenStreetMap</a> contributors. Tiles courtesy of <a href="http://memomaps.de/" target="_blank">MeMoMaps</a>'
  60   }
  61 });
  62
  63 L.OSM.HOT = L.OSM.TileLayer.extend({
  64   options: {
  65     url: 'https://tile-{s}.openstreetmap.fr/hot/{z}/{x}/{y}.png',
  66     maxZoom: 20,
  67     subdomains: 'abc',
  68     attribution: '© <a href="https://www.openstreetmap.org/copyright" target="_blank">OpenStreetMap</a> contributors. Tiles courtesy of <a href="http://hot.openstreetmap.org/" target="_blank">Humanitarian OpenStreetMap Team</a>'
  69   }
  70 });
  71
  72 L.OSM.TracestrackTopo = L.OSM.TileLayer.extend({
  73   options: {
  74     url: 'https://tile.tracestrack.com/topo__/{z}/{x}/{y}.webp?key={apikey}',
  75     maxZoom: 19,
  76     attribution: '© <a href="https://www.openstreetmap.org/copyright" target="_blank">OpenStreetMap</a> contributors. Tiles courtesy of <a href="https://www.tracestrack.com/" target="_blank">Tracestrack Maps</a>'
  77   }
  78 });
  79
  80 L.OSM.GPS = L.OSM.TileLayer.extend({
  81   options: {
  82     url: 'https://gps.tile.openstreetmap.org/lines/{z}/{x}/{y}.png',
  83     maxZoom: 21,
  84     maxNativeZoom: 20,
  85     subdomains: 'abc'
  86   }
  87 });
  88
  89 L.OSM.DataLayer = L.FeatureGroup.extend({
  90   options: {
  91     areaTags: ['area', 'building', 'leisure', 'tourism', 'ruins', 'historic', 'landuse', 'military', 'natural', 'sport'],
  92     uninterestingTags: ['source', 'source_ref', 'source:ref', 'history', 'attribution', 'created_by', 'tiger:county', 'tiger:tlid', 'tiger:upload_uuid'],
  93     styles: {},
  94     asynchronous: false,
  95   },
  96
  97   initialize: function (xml, options) {
  98     L.Util.setOptions(this, options);
  99
 100     L.FeatureGroup.prototype.initialize.call(this);
 101
 102     if (xml) {
 103       this.addData(xml);
 104     }
 105   },
 106
 107   loadingLayers: [],
 108
 109   cancelLoading: function () {
 110     this.loadingLayers.forEach(layer => clearTimeout(layer));
 111     this.loadingLayers = [];
 112   },
 113
 114   addData: function (features) {
 115     if (!(features instanceof Array)) {
 116       features = this.buildFeatures(features);
 117     }
 118
 119     for (var i = 0; i < features.length; i++) {
 120       let feature = features[i], layer;
 121
 122       if (feature.type === "changeset") {
 123         layer = L.rectangle(feature.latLngBounds, this.options.styles.changeset);
 124       } else if (feature.type === "node") {
 125         layer = L.circleMarker(feature.latLng, this.options.styles.node);
 126       } else {
 127         var latLngs = new Array(feature.nodes.length);
 128
 129         for (var j = 0; j < feature.nodes.length; j++) {
 130           latLngs[j] = feature.nodes[j].latLng;
 131         }
 132
 133         if (this.isWayArea(feature)) {
 134           latLngs.pop(); // Remove last == first.
 135           layer = L.polygon(latLngs, this.options.styles.area);
 136         } else {
 137           layer = L.polyline(latLngs, this.options.styles.way);
 138         }
 139       }
 140
 141       if (this.options.asynchronous) {
 142         setTimeout(() => layer.addTo(this));
 143       } else {
 144         layer.addTo(this);
 145       }
 146
 147       layer.feature = feature;
 148     }
 149   },
 150
 151   buildFeatures: function (data) {
 152
 153     const parser = data instanceof Document ? L.OSM.XMLParser : L.OSM.JSONParser;
 154
 155     var features = parser.getChangesets(data),
 156         nodes = parser.getNodes(data),
 157         ways = parser.getWays(data, nodes),
 158         relations = parser.getRelations(data, nodes, ways);
 159
 160     var wayNodes = {}
 161     for (var i = 0; i < ways.length; i++) {
 162       var way = ways[i];
 163       for (var j = 0; j < way.nodes.length; j++) {
 164         wayNodes[way.nodes[j].id] = true
 165       }
 166     }
 167
 168     var relationNodes = {}
 169     for (var i = 0; i < relations.length; i++){
 170       var relation = relations[i];
 171       for (var j = 0; j < relation.members.length; j++) {
 172         relationNodes[relation.members[j].id] = true
 173       }
 174     }
 175
 176     for (var node_id in nodes) {
 177       var node = nodes[node_id];
 178       if (this.interestingNode(node, wayNodes, relationNodes)) {
 179         features.push(node);
 180       }
 181     }
 182
 183     for (var i = 0; i < ways.length; i++) {
 184       var way = ways[i];
 185       features.push(way);
 186     }
 187
 188     return features;
 189   },
 190
 191   isWayArea: function (way) {
 192     if (way.nodes[0] != way.nodes[way.nodes.length - 1]) {
 193       return false;
 194     }
 195
 196     for (var key in way.tags) {
 197       if (~this.options.areaTags.indexOf(key)) {
 198         return true;
 199       }
 200     }
 201
 202     return false;
 203   },
 204
 205   interestingNode: function (node, wayNodes, relationNodes) {
 206     if (!wayNodes[node.id] || relationNodes[node.id]) {
 207       return true
 208     }
 209
 210     for (var key in node.tags) {
 211       if (this.options.uninterestingTags.indexOf(key) < 0) {
 212         return true;
 213       }
 214     }
 215
 216     return false;
 217   },
 218
 219   onRemove: function(map) {
 220     this.eachLayer(map.removeLayer, map, this.options.asynchronous);
 221   },
 222
 223   onAdd: function(map) {
 224     this.eachLayer(map.addLayer, map, this.options.asynchronous);
 225   },
 226
 227   eachLayer: function (method, context, asynchronous = false) {
 228     for (let i in this._layers) {
 229       if (asynchronous) {
 230         this.loadingLayers.push(
 231           setTimeout(() => {
 232             method.call(context, this._layers[i]);
 233           })
 234         );
 235       } else {
 236         method.call(context, this._layers[i]);
 237       }
 238     }
 239     return this;
 240   },
 241 });
 242
 243 L.OSM.XMLParser = {
 244   getChangesets(xml) {
 245     const changesets = [...xml.getElementsByTagName("changeset")];
 246     return changesets.map(cs => ({
 247       id: String(cs.getAttribute("id")),
 248       type: "changeset",
 249       latLngBounds: L.latLngBounds(
 250         [cs.getAttribute("min_lat"), cs.getAttribute("min_lon")],
 251         [cs.getAttribute("max_lat"), cs.getAttribute("max_lon")]
 252       ),
 253       tags: this.getTags(cs)
 254     }));
 255   },
 256
 257   getNodes(xml) {
 258     const result = {};
 259     const nodes = [...xml.getElementsByTagName("node")];
 260
 261     for (const node of nodes) {
 262       const id = node.getAttribute("id");
 263       result[id] = {
 264         id: String(id),
 265         type: "node",
 266         latLng: L.latLng(
 267           node.getAttribute("lat"),
 268           node.getAttribute("lon"),
 269           true
 270         ),
 271         tags: this.getTags(node)
 272       };
 273     }
 274
 275     return result;
 276   },
 277
 278   getWays(xml, nodes) {
 279     const ways = [...xml.getElementsByTagName("way")];
 280     return ways.map(way => {
 281       const nds = [...way.getElementsByTagName("nd")];
 282       return {
 283         id: String(way.getAttribute("id")),
 284         type: "way",
 285         nodes: nds.map(nd => nodes[nd.getAttribute("ref")]),
 286         tags: this.getTags(way)
 287       };
 288     });
 289   },
 290
 291   getRelations(xml, nodes, ways) {
 292     const rels = [...xml.getElementsByTagName("relation")];
 293     return rels.map(rel => {
 294       const members = [...rel.getElementsByTagName("member")];
 295       return {
 296         id: String(rel.getAttribute("id")),
 297         type: "relation",
 298         members: members    // relation-way and relation-relation membership not implemented
 299           .map(member => member.getAttribute("type") === "node" ? nodes[member.getAttribute("ref")] : null)
 300           .filter(Boolean),    // filter out null and undefined
 301         tags: this.getTags(rel)
 302       };
 303     });
 304   },
 305
 306   getTags(xml) {
 307     const result = {};
 308     const tags = [...xml.getElementsByTagName("tag")];
 309
 310     for (const tag of tags) {
 311       result[tag.getAttribute("k")] = tag.getAttribute("v");
 312     }
 313
 314     return result;
 315   }
 316 }
 317
 318 L.OSM.JSONParser = {
 319   getChangesets(json) {
 320     const changesets = json.changeset ? [json.changeset] : [];
 321
 322     return changesets.map(cs => ({
 323       id: String(cs.id),
 324       type: "changeset",
 325       latLngBounds: L.latLngBounds(
 326         [cs.min_lat, cs.min_lon],
 327         [cs.max_lat, cs.max_lon]
 328       ),
 329       tags: this.getTags(cs)
 330     }));
 331   },
 332
 333   getNodes(json) {
 334     const nodes = json.elements?.filter(el => el.type === "node") ?? [];
 335     let result = {};
 336
 337     for (const node of nodes) {
 338       result[node.id] = {
 339         id: String(node.id),
 340         type: "node",
 341         latLng: L.latLng(node.lat, node.lon, true),
 342         tags: this.getTags(node)
 343       };
 344     }
 345
 346     return result;
 347   },
 348
 349   getWays(json, nodes) {
 350     const ways = json.elements?.filter(el => el.type === "way") ?? [];
 351
 352     return ways.map(way => ({
 353       id: String(way.id),
 354       type: "way",
 355       nodes: way.nodes.map(nodeId => nodes[nodeId]),
 356       tags: this.getTags(way)
 357     }));
 358   },
 359
 360   getRelations(json, nodes, ways) {
 361     const relations = json.elements?.filter(el => el.type === "relation") ?? [];
 362
 363     return relations.map(rel => ({
 364       id: String(rel.id),
 365       type: "relation",
 366       members: (rel.members ?? [])   // relation-way and relation-relation membership not implemented
 367         .map(member => member.type === "node" ? nodes[member.ref] : null)
 368         .filter(Boolean),     // filter out null and undefined
 369       tags: this.getTags(rel)
 370     }));
 371   },
 372
 373   getTags(json) {
 374     return json.tags ?? {};
 375   }
 376 };