devbox
凡人多烦事01
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

OpenLayers结合Turf实现空间运算_openlayers turf

作者：凡人多烦事01 | 2024-05-19 23:49:55

赞

踩

openlayers turf

1. 引言

空间运算利用几何函数来接收输入的空间数据，对其进行分析，然后生成输出数据，输出数据为针对输入数据执行分析的派生结果。

可从空间运算中获得的派生数据包括：

  • 作为输入要素周围缓冲区的面
  • 作为对几何集合执行分析的结果的单个要素
  • 作为比较结果以确定不与其他要素位于同一物理空间的要素部分的单个要素
  • 作为比较结果以查找与其他要素的物理空间相交的要素部分的单个要素
  • 由彼此不位于同一物理空间的输入要素部分组成的多部分 (multipart) 要素
  • 作为两个几何的并集的要素

参考文档：空间运算—ArcMap | 文档 (arcgis.com)

Turf.js是MapBox公司研发的基于浏览器端的空间分析库，它使用JavaScript进行编写，通过npm进行包管理。值得一提的是，良好的模块化设计使其不仅能够作用于浏览器端、还可通过Node.js在服务端使用。Turf 原生支持 GeoJSON 矢量数据。GeoJSON 的优点是结构简单，并且得到了所有网页地图API的支持；但 GeoJSON 不支持空间索引，这个缺点可能会限制 Turf 处理大型文件的能力效率。其适用于轻量级（数据轻量而非功能轻量）的WebGIS应用

参考文献：Turf.js—让你在浏览器上实现地理分析 - 掘金 (juejin.cn)

turf.js官网：Turf.js | Advanced Geospatial Analysis (turfjs.org)

中文站点：Turf.js中文网 (fenxianglu.cn)

Turf.js Github地址：Turfjs/turf: A modular geospatial engine written in JavaScript (github.com)

空间运算可谓是空间分析的基础，Turf.js提供了大量的空间分析功能，包含了空间运算功能，本文参考OpenLayers与Turf集成的官方示例，使用示例数据和原生JavaScript，进行求交运算与缓冲区运算，并进行可视化

OpenLayers与Turf集成示例：turf.js (openlayers.org)

2.初始化地图

引入OpenLayers和Turf.js的CDN：

  1. <link rel="stylesheet"  href="https://cdn.jsdelivr.net/gh/openlayers/openlayers.github.io@master/en/v6.14.1/css/ol.css"  type="text/css">
  2. <script src="https://cdn.jsdelivr.net/gh/openlayers/openlayers.github.io@master/en/v6.14.1/build/ol.js"></script>
  3. <script src='https://unpkg.com/@turf/turf@6/turf.min.js'></script>

注意：

  • OpenLayers与Turf集成示例使用的Turf版本是2.0.0，版本偏老，与目前版本（6.5.0）部分API不兼容，不建议使用

构建网页基本内容，添加地图容器：

  1. <!DOCTYPE html>
  2. <html lang="en">
  3.  
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <meta http-equiv="X-UA-Compatible" content="IE=edge">
  7.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  8.     <title>Document</title>
  9.  
  10.     <link rel="stylesheet"
  11.         href="https://cdn.jsdelivr.net/gh/openlayers/openlayers.github.io@master/en/v6.14.1/css/ol.css" type="text/css">
  12.     <script src="https://cdn.jsdelivr.net/gh/openlayers/openlayers.github.io@master/en/v6.14.1/build/ol.js"></script>
  13.     <script src='https://unpkg.com/@turf/turf@6/turf.min.js'></script>
  14.     <style>
  15.         html,
  16.         body,
  17.         #map {
  18.             height: 100%;
  19.         }
  20.     </style>
  21. </head>
  22.  
  23. <body>
  24.     <div id="map"></div>
  25.  
  26.  
  27. </body>
  28.  
  29. </html>

添加地图并加载示例矢量数据:

  1. <script>
  2.     fetch('https://openlayers.org/en/latest/examples/data/geojson/roads-seoul.geojson')
  3.         .then(response => response.json())
  4.         .then(function (json){
  5.         var vectorSource = new ol.source.Vector({
  6.             features: (new ol.format.GeoJSON()).readFeatures(json, {
  7.                 featureProjection: 'EPSG:3857'
  8.             })
  9.         });
  10.         var vectorLayer = new ol.layer.Vector({
  11.             source: vectorSource
  12.         });
  13.         var map = new ol.Map({
  14.             layers: [
  15.                 new ol.layer.Tile({
  16.                     source: new ol.source.OSM()
  17.                 }),
  18.                 vectorLayer
  19.             ],
  20.             target: 'map',
  21.             view: new ol.View({
  22.                 center: ol.proj.fromLonLat([126.980366, 37.52654]),
  23.                 zoom: 15
  24.             })
  25.         });
  26.     })
  27. </script>

完整代码如下:

  1. <!DOCTYPE html>
  2. <html lang="en">
  3.  
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <meta http-equiv="X-UA-Compatible" content="IE=edge">
  7.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  8.     <title>Document</title>
  9.  
  10.     <link rel="stylesheet"
  11.         href="https://cdn.jsdelivr.net/gh/openlayers/openlayers.github.io@master/en/v6.14.1/css/ol.css" type="text/css">
  12.     <script src="https://cdn.jsdelivr.net/gh/openlayers/openlayers.github.io@master/en/v6.14.1/build/ol.js"></script>
  13.     <script src='https://unpkg.com/@turf/turf@6/turf.min.js'></script>
  14.     <style>
  15.         html,
  16.         body,
  17.         #map {
  18.             height: 100%;
  19.         }
  20.     </style>
  21. </head>
  22.  
  23. <body>
  24.     <div id="map"></div>
  25.     <script>
  26.         fetch('https://openlayers.org/en/latest/examples/data/geojson/roads-seoul.geojson')
  27.             .then(response => response.json())
  28.             .then(function (json){
  29.             var vectorSource = new ol.source.Vector({
  30.                 features: (new ol.format.GeoJSON()).readFeatures(json, {
  31.                     featureProjection: 'EPSG:3857'
  32.                 })
  33.             });
  34.             var vectorLayer = new ol.layer.Vector({
  35.                 source: vectorSource
  36.             });
  37.             var map = new ol.Map({
  38.                 layers: [
  39.                     new ol.layer.Tile({
  40.                         source: new ol.source.OSM()
  41.                     }),
  42.                     vectorLayer
  43.                 ],
  44.                 target: 'map',
  45.                 view: new ol.View({
  46.                     center: ol.proj.fromLonLat([126.980366, 37.52654]),
  47.                     zoom: 15
  48.                 })
  49.             });
  50.         })
  51.     </script>
  52.  
  53. </body>
  54.  
  55. </html>

初始化的地图:

3. 缓冲区计算

参考官方文档:Turf.js | Advanced geospatial analysis (turfjs.org)

步骤实质就是:

  • 将Openlayers的Features对象转换为Turf支持的GeoJSON对象
  • 调用Turf.buff()函数得到运算结果
  • OpenLayers读取运算后的GeoJSON数据加载到图层中

缓存区计算的核心代码如下:

  1. const features = vectorSource.getFeatures();
  2. const turfLines = (new ol.format.GeoJSON()).writeFeaturesObject(features, {
  3.     featureProjection: 'EPSG:3857'
  4. });
  5. var buffered = turf.buffer(turfLines, 25, { units: 'meters' });
  6. const bufferedLayer = new ol.layer.Vector({
  7.     source: new ol.source.Vector({
  8.         features: (new ol.format.GeoJSON()).readFeatures(buffered, {
  9.             featureProjection: 'EPSG:3857'
  10.         })
  11.     })
  12. })
  13. map.addLayer(bufferedLayer);

注意:

  • 从OpenLayers的Feature对象转换为Turf支持的GeoJSON对象时务必指定坐标系

这一步的完成代码如下:

  1. <!DOCTYPE html>
  2. <html lang="en">
  3.  
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <meta http-equiv="X-UA-Compatible" content="IE=edge">
  7.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  8.     <title>Document</title>
  9.  
  10.     <link rel="stylesheet"
  11.         href="https://cdn.jsdelivr.net/gh/openlayers/openlayers.github.io@master/en/v6.14.1/css/ol.css" type="text/css">
  12.     <script src="https://cdn.jsdelivr.net/gh/openlayers/openlayers.github.io@master/en/v6.14.1/build/ol.js"></script>
  13.     <script src='https://unpkg.com/@turf/turf@6/turf.min.js'></script>
  14.     <!-- <script src="https://api.tiles.mapbox.com/mapbox.js/plugins/turf/v2.0.0/turf.min.js"></script> -->
  15.     <style>
  16.         html,
  17.         body,
  18.         #map {
  19.             height: 100%;
  20.         }
  21.     </style>
  22. </head>
  23.  
  24. <body>
  25.     <div id="map"></div>
  26.  
  27.     <script>
  28.         var map = new ol.Map({
  29.             layers: [
  30.                 new ol.layer.Tile({
  31.                     source: new ol.source.OSM()
  32.                 })
  33.  
  34.             ],
  35.             target: 'map',
  36.             view: new ol.View({
  37.                 center: ol.proj.fromLonLat([126.980366, 37.52654]),
  38.                 zoom: 15
  39.             })
  40.         });
  41.         fetch('https://openlayers.org/en/latest/examples/data/geojson/roads-seoul.geojson')
  42.             .then(response => response.json())
  43.             .then(function (json) {
  44.                 var vectorSource = new ol.source.Vector({
  45.                     features: (new ol.format.GeoJSON()).readFeatures(json, {
  46.                         featureProjection: 'EPSG:3857'
  47.                     })
  48.                 });
  49.                 var vectorLayer = new ol.layer.Vector({
  50.                     source: vectorSource,
  51.                     style: new ol.style.Style({
  52.                         stroke: new ol.style.Stroke({
  53.                             color: '#0000ff',
  54.                             width: 2
  55.                         })
  56.                     })
  57.                 });
  58.                 map.addLayer(vectorLayer);
  59.  
  60.                 const features = vectorSource.getFeatures();
  61.                 const turfLines = (new ol.format.GeoJSON()).writeFeaturesObject(features, {
  62.                     featureProjection: 'EPSG:3857'
  63.                 });
  64.                 var buffered = turf.buffer(turfLines, 25, { units: 'meters' });
  65.                 const bufferedLayer = new ol.layer.Vector({
  66.                     source: new ol.source.Vector({
  67.                         features: (new ol.format.GeoJSON()).readFeatures(buffered, {
  68.                             featureProjection: 'EPSG:3857'
  69.                         })
  70.                     })
  71.                 })
  72.                 map.addLayer(bufferedLayer);
  73.             })
  74.     </script>
  75. </body>
  76.  
  77. </html>

结果图如下:

4. 相交计算

参考官方文档:Turf.js | Advanced geospatial analysis (turfjs.org)

步骤与缓冲区计算类似:

  • 将Openlayers的Features对象转换为Turf支持的GeoJSON对象
  • 调用Turf.lineIntersect()函数得到运算结果
  • OpenLayers读取运算后的GeoJSON数据加载到图层中

本文所使用的数据是LineString,所以此处的相交计算的是线段相交

相交运算的核心代码如下:

  1. const features = vectorSource.getFeatures();
  2. const turfLines = (new ol.format.GeoJSON()).writeFeaturesObject(features, {
  3.     featureProjection: 'EPSG:3857'
  4. });
  5.  
  6. const intersectionSource = new ol.source.Vector()
  7. for (let i = 0; i < turfLines.features.length; i++) {
  8.     for (let j = i + 1; j < turfLines.features.length; j++) {
  9.         const intersections = turf.lineIntersect(turfLines.features[i], turfLines.features[j]);
  10.         if (intersections) {
  11.             if (intersections.features.length > 0) {
  12.                 intersectionSource.addFeatures(new ol.format.GeoJSON().readFeatures(intersections, {
  13.                     featureProjection: 'EPSG:3857'
  14.                 }))
  15.             }
  16.         }
  17.     }
  18. }
  19.  
  20. const intersectionLayer = new ol.layer.Vector({
  21.     source: intersectionSource,
  22.     style: new ol.style.Style({
  23.         stroke: new ol.style.Stroke({
  24.             color: '#ff0000',
  25.             width: 2
  26.         }),
  27.         fill: new ol.style.Fill({
  28.             color: '#ff0000'
  29.         }),
  30.         image: new ol.style.Circle({
  31.             radius: 5,
  32.             fill: new ol.style.Fill({
  33.                 color: '#ff0000'
  34.             })
  35.         })
  36.     })
  37. })
  38. map.addLayer(intersectionLayer);

注意:

  • 计算结果为点集合(Point),最好设置一定的显示样式,不然难以看见

这一步的完成代码如下:

  1. <!DOCTYPE html>
  2. <html lang="en">
  3.  
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <meta http-equiv="X-UA-Compatible" content="IE=edge">
  7.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  8.     <title>Document</title>
  9.  
  10.     <link rel="stylesheet"
  11.         href="https://cdn.jsdelivr.net/gh/openlayers/openlayers.github.io@master/en/v6.14.1/css/ol.css" type="text/css">
  12.     <script src="https://cdn.jsdelivr.net/gh/openlayers/openlayers.github.io@master/en/v6.14.1/build/ol.js"></script>
  13.     <script src='https://unpkg.com/@turf/turf@6/turf.min.js'></script>
  14.     <!-- <script src="https://api.tiles.mapbox.com/mapbox.js/plugins/turf/v2.0.0/turf.min.js"></script> -->
  15.     <style>
  16.         html,
  17.         body,
  18.         #map {
  19.             height: 100%;
  20.         }
  21.     </style>
  22. </head>
  23.  
  24. <body>
  25.     <div id="map"></div>
  26.  
  27.     <script>
  28.         var map = new ol.Map({
  29.             layers: [
  30.                 new ol.layer.Tile({
  31.                     source: new ol.source.OSM()
  32.                 })
  33.  
  34.             ],
  35.             target: 'map',
  36.             view: new ol.View({
  37.                 center: ol.proj.fromLonLat([126.980366, 37.52654]),
  38.                 zoom: 15
  39.             })
  40.         });
  41.         fetch('https://openlayers.org/en/latest/examples/data/geojson/roads-seoul.geojson')
  42.             .then(response => response.json())
  43.             .then(function (json) {
  44.                 var vectorSource = new ol.source.Vector({
  45.                     features: (new ol.format.GeoJSON()).readFeatures(json, {
  46.                         featureProjection: 'EPSG:3857'
  47.                     })
  48.                 });
  49.                 var vectorLayer = new ol.layer.Vector({
  50.                     source: vectorSource,
  51.                     style: new ol.style.Style({
  52.                         stroke: new ol.style.Stroke({
  53.                             color: '#0000ff',
  54.                             width: 2
  55.                         })
  56.                     })
  57.                 });
  58.                 map.addLayer(vectorLayer);
  59.  
  60.                 const features = vectorSource.getFeatures();
  61.                 const turfLines = (new ol.format.GeoJSON()).writeFeaturesObject(features, {
  62.                     featureProjection: 'EPSG:3857'
  63.                 });
  64.  
  65.                 const intersectionSource = new ol.source.Vector()
  66.                 for (let i = 0; i < turfLines.features.length; i++) {
  67.                     for (let j = i + 1; j < turfLines.features.length; j++) {
  68.                         const intersections = turf.lineIntersect(turfLines.features[i], turfLines.features[j]);
  69.                         if (intersections) {
  70.                             // console.log(intersections)
  71.                             if (intersections.features.length > 0) {
  72.                                 intersectionSource.addFeatures(new ol.format.GeoJSON().readFeatures(intersections, {
  73.                                     featureProjection: 'EPSG:3857'
  74.                                 }))
  75.                                 // console.log(intersectionSource.getFeatures())
  76.                             }
  77.                         }
  78.                     }
  79.                 }
  80.                 // console.log(intersectionSource)
  81.                 const intersectionLayer = new ol.layer.Vector({
  82.                     source: intersectionSource,
  83.                     style: new ol.style.Style({
  84.                         stroke: new ol.style.Stroke({
  85.                             color: '#ff0000',
  86.                             width: 2
  87.                         }),
  88.                         fill: new ol.style.Fill({
  89.                             color: '#ff0000'
  90.                         }),
  91.                         image: new ol.style.Circle({
  92.                             radius: 5,
  93.                             fill: new ol.style.Fill({
  94.                                 color: '#ff0000'
  95.                             })
  96.                         })
  97.                     })
  98.                 })
  99.                 map.addLayer(intersectionLayer);
  100.             })
  101.     </script>
  102. </body>
  103.  
  104. </html>

结果图如下:

5. 整合

将两个运算结果结合在一起,完整代码如下:

  1. <!DOCTYPE html>
  2. <html lang="en">
  3.  
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <meta http-equiv="X-UA-Compatible" content="IE=edge">
  7.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  8.     <title>Document</title>
  9.  
  10.     <link rel="stylesheet"
  11.         href="https://cdn.jsdelivr.net/gh/openlayers/openlayers.github.io@master/en/v6.14.1/css/ol.css" type="text/css">
  12.     <script src="https://cdn.jsdelivr.net/gh/openlayers/openlayers.github.io@master/en/v6.14.1/build/ol.js"></script>
  13.     <script src='https://unpkg.com/@turf/turf@6/turf.min.js'></script>
  14.     <!-- <script src="https://api.tiles.mapbox.com/mapbox.js/plugins/turf/v2.0.0/turf.min.js"></script> -->
  15.     <style>
  16.         html,
  17.         body,
  18.         #map {
  19.             height: 100%;
  20.         }
  21.     </style>
  22. </head>
  23.  
  24. <body>
  25.     <div id="map"></div>
  26.  
  27.     <script>
  28.         var map = new ol.Map({
  29.             layers: [
  30.                 new ol.layer.Tile({
  31.                     source: new ol.source.OSM()
  32.                 })
  33.  
  34.             ],
  35.             target: 'map',
  36.             view: new ol.View({
  37.                 center: ol.proj.fromLonLat([126.980366, 37.52654]),
  38.                 zoom: 15
  39.             })
  40.         });
  41.         fetch('https://openlayers.org/en/latest/examples/data/geojson/roads-seoul.geojson')
  42.             .then(response => response.json())
  43.             .then(function (json) {
  44.                 var vectorSource = new ol.source.Vector({
  45.                     features: (new ol.format.GeoJSON()).readFeatures(json, {
  46.                         featureProjection: 'EPSG:3857'
  47.                     })
  48.                 });
  49.                 var vectorLayer = new ol.layer.Vector({
  50.                     source: vectorSource,
  51.                     style: new ol.style.Style({
  52.                         stroke: new ol.style.Stroke({
  53.                             color: '#0000ff',
  54.                             width: 2
  55.                         })
  56.                     })
  57.                 });
  58.                 map.addLayer(vectorLayer);
  59.  
  60.                 const features = vectorSource.getFeatures();
  61.                 const turfLines = (new ol.format.GeoJSON()).writeFeaturesObject(features, {
  62.                     featureProjection: 'EPSG:3857'
  63.                 });
  64.                 // console.log(turfLines)
  65.                 // const buffered = turf.buffer(turfLines, 25);
  66.                 var buffered = turf.buffer(turfLines, 25, { units: 'meters' });
  67.                 const bufferedLayer = new ol.layer.Vector({
  68.                     source: new ol.source.Vector({
  69.                         features: (new ol.format.GeoJSON()).readFeatures(buffered, {
  70.                             featureProjection: 'EPSG:3857'
  71.                         })
  72.                     })
  73.                 })
  74.                 map.addLayer(bufferedLayer);
  75.  
  76.                 const intersectionSource = new ol.source.Vector()
  77.                 for (let i = 0; i < turfLines.features.length; i++) {
  78.                     for (let j = i + 1; j < turfLines.features.length; j++) {
  79.                         const intersections = turf.lineIntersect(turfLines.features[i], turfLines.features[j]);
  80.                         if (intersections) {
  81.                             // console.log(intersections)
  82.                             if (intersections.features.length > 0) {
  83.                                 intersectionSource.addFeatures(new ol.format.GeoJSON().readFeatures(intersections, {
  84.                                     featureProjection: 'EPSG:3857'
  85.                                 }))
  86.                                 // console.log(intersectionSource.getFeatures())
  87.                             }
  88.                         }
  89.                     }
  90.                 }
  91.                 // console.log(intersectionSource)
  92.                 const intersectionLayer = new ol.layer.Vector({
  93.                     source: intersectionSource,
  94.                     style: new ol.style.Style({
  95.                         stroke: new ol.style.Stroke({
  96.                             color: '#ff0000',
  97.                             width: 2
  98.                         }),
  99.                         fill: new ol.style.Fill({
  100.                             color: '#ff0000'
  101.                         }),
  102.                         image: new ol.style.Circle({
  103.                             radius: 5,
  104.                             fill: new ol.style.Fill({
  105.                                 color: '#ff0000'
  106.                             })
  107.                         })
  108.                     })
  109.                 })
  110.                 map.addLayer(intersectionLayer);
  111.             })
  112.     </script>
  113. </body>
  114.  
  115. </html>

结果图如下:

6. 参考资料

[1]空间运算—ArcMap | 文档 (arcgis.com)

[2]Turf.js—让你在浏览器上实现地理分析 - 掘金 (juejin.cn)

[3]Turf.js | Advanced Geospatial Analysis (turfjs.org)

[4]Turf.js中文网 (fenxianglu.cn)

[5]Turfjs/turf: A modular geospatial engine written in JavaScript (github.com)

[6]使用 Fetch - Web API 接口参考 | MDN (mozilla.org)

[7]turf.js (openlayers.org)

[8]openlayers+turf.js实现缓冲区的绘制_gis_SSS的博客-CSDN博客_openlayers缓冲区分析

[9]OpenLayers v6.14.1 API - Class: EsriJSON

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/凡人多烦事01/article/detail/595111
推荐阅读