---
knowledge_id: GIS-KB-G06-003
group: 6
group_name: "现代GIS技术栈"
category: modern
gb_standards: []
software_versions: []
keywords: ['JTS', 'GEOS', 'Shapely', 'NTS', '几何引擎', '跨语言', 'C++', 'Java', 'Go', 'JS']
related_modules: ['21_Python_GIS生态.md', '39_R语言GIS生态.md']
risk_level: medium
update_cycle: annual
last_updated: "2026-06-23"
version: "V5.0"
---

# 多语言地理空间库生态 | 关联：21_Python_GIS生态.md 39_R语言GIS生态.md 22_空间数据库.md 23_WebGIS开发.md | 群组六：现代GIS技术栈

> 横跨 Java/C++/Python/R/JavaScript/.NET/Rust 七大语言，以几何引擎继承链(JTS→GEOS→Shapely→NTS→JSTS)为骨架，
> 提供跨语言库速查、决策矩阵、CRS处理、格式兼容性对照。源自 opengis-skills-main 深度交叉分析。

---

## 一、几何引擎继承链全景图

```
                              JTS (Java, 2001─)
                          Martin Davis, Vivid Solutions
                    定位：Java拓扑套件，OGC Simple Features 参考实现
                              │
              ┌───────────────┼───────────────┬───────────────┐
              │               │               │               │
              ▼               ▼               ▼               ▼
   GEOS (C++)        NTS (.NET/C#)    JSTS (JavaScript)   GeoTools
   Refractions      NetTopologySuite   Björn Harrtell     (Java GIS
   Research, 2003    Diego Guidi,      TS/JS 端口          框架，内嵌JTS)
   C++ 精确端口      2006 (.NET 端口)  2013 (JS 端口)      1996, OSGeo
      │                                                      项目
      │
  ┌───┴────┬──────────┬──────────────┐
  │        │          │              │
  ▼        ▼          ▼              ▼
Shapely  libgeos    PostGIS       SpatiaLite
(Python  (QGIS C++  (PostgreSQL   (SQLite
绑定)     底层)      扩展)         扩展)
```

### 1.1 Esri Geometry API（独立实现，非JTS系）

```
Esri Geometry API Java    ────  不是JTS端口，独立设计
  ├── 支持地理坐标运算（geodesic buffer/distance/area）
  ├── Hadoop/Spark 兼容（分布式空间分析）
  └── REST 序列化原生集成

Esri Geometry API .NET    ────  独立C#实现
  ├── 与 ArcGIS Runtime 深度集成
  └── 支持 ArcGIS 原生格式（GDB/FGDB）
```

> **关键区别**：JTS 系列库默认在平面坐标系下运算（笛卡尔平面）；Esri Geometry API 原生支持大地测量运算（椭球面上的 true geodesic 计算）。对于 CGCS2000 高精度场景，Esri 的 geodesic 方法优于 JTS 系默认平面算法。

### 1.2 各引擎核心能力对比

| 维度 | JTS (Java) | GEOS (C++) | Shapely (Python) | NTS (.NET) | JSTS (JS/TS) | Esri Java | Esri .NET |
|------|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
| **语言** | Java 8+ | C++11 | Python 3.8+ | .NET Standard 2.0 | JS/TS | Java 8+ | .NET Standard |
| **版本** | 1.20.0 | 3.12.2 | 2.0.6 | 2.5.0 | 2.12.1 | 2.2.4 | 100.16 |
| **平面拓扑** | ✓ (完整) | ✓ (完整) | ✓ (GEOS代理) | ✓ (完整) | ✓ (80%+) | ✓ | ✓ |
| **大地测量运算** | ✗ | ✗ (需PROJ辅助) | ✗ | ✗ | ✗ | ✓ | ✓ |
| **3D 几何** | 部分 | 部分 | 部分 | 部分 | ✗ | ✓ | ✓ |
| **STRtree 索引** | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ (HRtree) | ✓ |
| **WKT/WKB** | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
| **GeoJSON** | 第三方 | 第三方 | ✓ | ✓ | ✓ | ✓ | ✓ |
| **精度模型** | FIXED/FLOATING | FIXED/FLOATING | FIXED/FLOATING | FIXED/FLOATING | FLOATING | 高精度 | 高精度 |
| **线程安全** | 部分 | ✓ (GDAL) | ✓ (GEOS 3.12+) | ✓ | ✓ | ✓ | ✓ |
| **性能 (100K多边形相交)** | 快 | 最快 | 快 | 快 | 中等 | 快 | 快 |

### 1.3 核心类对照表（Geometry 体系）

| 抽象概念 | JTS | GEOS | Shapely | NTS | JSTS | Esri |
|---------|-----|------|---------|-----|------|------|
| 工厂类 | `GeometryFactory` | `GEOSGeomFactory` | `shapely.geometry` 模块 | `GeometryFactory` | `jsts.geom.GeometryFactory` | `GeometryEngine` |
| 基础类型 | `Geometry` | `GEOSGeometry` | `shapely.Geometry` | `Geometry` | `jsts.geom.Geometry` | `Geometry` |
| 点 | `Point` | `GEOSGeom_createPoint` | `Point(x,y)` | `Point` | `jsts.geom.Point` | `Point` |
| 线 | `LineString` | `GEOSGeom_createLineString` | `LineString([...])` | `LineString` | `jsts.geom.LineString` | `Polyline` |
| 面 | `Polygon` | `GEOSGeom_createPolygon` | `Polygon(...)` | `Polygon` | `jsts.geom.Polygon` | `Polygon` |
| 多点 | `MultiPoint` | `GEOSGeom_createMultiPoint` | `MultiPoint([...])` | `MultiPoint` | — | `Multipoint` |
| 坐标系 | 外挂 (CRS) | 外挂 (SRID int) | 外挂 (pyproj) | 外挂 (ProjNet) | 无内置 | 内置 (SpatialReference) |
| 包路径 | `org.locationtech.jts.geom` | `geos_c.h` (C API) | `shapely.geometry` | `NetTopologySuite.Geometries` | `jsts/geom` | `com.esri.core.geometry` |

### 1.4 拓扑操作 API 对照

| 操作 | JTS | Shapely | NTS | JSTS | Esri Java |
|------|-----|---------|-----|------|-----------|
| 缓冲区 | `geom.buffer(dist)` | `geom.buffer(dist)` | `geom.Buffer(dist)` | `geom.buffer(dist)` | `GeometryEngine.buffer(geom, dist, sr)` |
| 相交判断 | `geom.intersects(other)` | `geom.intersects(other)` | `geom.Intersects(other)` | `geom.intersects(other)` | `GeometryEngine.intersects(geom1, geom2, sr)` |
| 交集 | `geom.intersection(other)` | `geom.intersection(other)` | `geom.Intersection(other)` | `geom.intersection(other)` | `GeometryEngine.intersection(geom1, geom2, sr)` |
| 并集 | `geom.union(other)` | `geom.union(other)` | `geom.Union(other)` | `geom.union(other)` | `GeometryEngine.union(geoms, sr)` |
| 差集 | `geom.difference(other)` | `geom.difference(other)` | `geom.Difference(other)` | `geom.difference(other)` | `GeometryEngine.difference(geom1, geom2, sr)` |
| 包含 | `geom.contains(other)` | `geom.contains(other)` | `geom.Contains(other)` | `geom.contains(other)` | `GeometryEngine.contains(geom1, geom2, sr)` |
| 被包含 | `geom.within(other)` | `geom.within(other)` | `geom.Within(other)` | `geom.within(other)` | `GeometryEngine.within(geom1, geom2, sr)` |
| 重叠 | `geom.overlaps(other)` | `geom.overlaps(other)` | `geom.Overlaps(other)` | `geom.overlaps(other)` | `GeometryEngine.overlaps(geom1, geom2, sr)` |
| 相切 | `geom.touches(other)` | `geom.touches(other)` | `geom.Touches(other)` | `geom.touches(other)` | — |
| 距离 | `geom.distance(other)` | `geom.distance(other)` | `geom.Distance(other)` | `geom.distance(other)` | `GeometryEngine.distance(geom1, geom2, sr)` |
| 简化 | `TopologyPreservingSimplifier` | `geom.simplify(tol)` | `DouglasPeuckerSimplifier` | `simplify(tol)` | `GeometryEngine.simplify(geom)` |
| 凸包 | `geom.convexHull()` | `geom.convex_hull` | `geom.ConvexHull()` | `geom.convexHull()` | `GeometryEngine.convexHull(geom)` |
| 质心 | `geom.getCentroid()` | `geom.centroid` | `geom.Centroid` | `geom.getCentroid()` | `GeometryEngine.centroid(geom, sr)` |
| 求交返点 | `geom.getInteriorPoint()` | `geom.representative_point()` | — | — | — |
| 修复无效 | `GeometryFixer` | `make_valid(geom)` | `GeometryFixer` | — | `OperatorImportFromESRIShape` |
| Voronoi图 | — | `voronoi_diagram(geom)` | 第三方 | — | — |
| Delaunay三角 | — | `triangulate(geom)` | 第三方 | — | — |

---

## 二、跨语言快速参考

### 2.1 Java 生态

#### JTS (Java Topology Suite) — 几何引擎鼻祖

```
groupId:     org.locationtech.jts
artifactId:  jts-core
安装:        Maven/Gradle 依赖
仓库:        https://github.com/locationtech/jts
```

| 概念 | 类/方法 | 说明 |
|------|---------|------|
| 几何工厂 | `new GeometryFactory(new PrecisionModel(1000), 4490)` | 精度模型 + SRID |
| 读取WKT | `new WKTReader().read("POINT(120 30)")` | 文本→几何 |
| 写入WKT | `new WKTWriter().write(geom)` | 几何→文本 |
| 读取WKB | `new WKBReader().read(bytes)` | 二进制→几何 |
| 空间索引 | `new STRtree().insert(envelope, item)` | R-tree 索引 |
| 关系判断 | `geom.relate(other)` | DE-9IM 矩阵 |
| 叠加分析 | `OverlayOp.overlayOp(geom1, geom2, OverlayOp.INTERSECTION)` | 低级叠加 |
| 验证 | `geom.isValid()` | 有效性检查 |
| 面积 | `geom.getArea()` | 平面面积 |
| 长度 | `geom.getLength()` | 平面长度 |

```java
// JTS 典型工作流
import org.locationtech.jts.geom.*;
import org.locationtech.jts.io.*;

GeometryFactory gf = new GeometryFactory(new PrecisionModel(1000), 4490);
WKTReader reader = new WKTReader(gf);

// 构建几何
Point p = gf.createPoint(new Coordinate(120.0, 30.0));
Polygon aoi = (Polygon) reader.read("POLYGON((119 29, 121 29, 121 31, 119 31, 119 29))");

// 空间查询
if (aoi.contains(p)) {
    System.out.println("点落在范围内");
}

// 缓冲区（平面坐标下）
Geometry buffer = aoi.buffer(0.01); // 约1km

// 面积
double areaDeg = aoi.getArea(); // 注意：经纬度下为"度²"无实际意义
```

#### GeoTools — JTS + 数据访问层

```
groupId:     org.geotools
版本:        31.x (2026最新)
仓库:        https://github.com/geotools/geotools
```

| 模块 | 功能 | 关键类 |
|------|------|--------|
| gt-main | 核心渲染 | `MapContent`, `Style` |
| gt-shapefile | SHP 读写 | `ShapefileDataStore` |
| gt-geopkg | GeoPackage | `GeoPkgDataStore` |
| gt-jdbc-postgis | PostGIS | `PostGISDataStoreFactory` |
| gt-epsg-hsql | EPSG 数据库 | `CRS.decode("EPSG:4490")` |
| gt-referencing | 坐标参考 | `CRS`, `CoordinateOperation` |
| gt-wms/wfs/wmts | OGC 服务 | `WMSDataStore`, `WFSDataStore` |
| gt-ogr | OGR 桥接 | 访问 GDAL 所有格式 |

```java
// GeoTools 读取 Shapefile
File file = new File("D:/data/roads.shp");
DataStore store = new ShapefileDataStore(file.toURI().toURL());
SimpleFeatureSource source = store.getFeatureSource();
SimpleFeatureCollection features = source.getFeatures();

// CGCS2000 投影变换
CoordinateReferenceSystem sourceCRS = CRS.decode("EPSG:4326");
CoordinateReferenceSystem targetCRS = CRS.decode("EPSG:4490");
MathTransform transform = CRS.findMathTransform(sourceCRS, targetCRS, true);
// 注意：GeoTools 默认轴序为 latitude/longitude (northing/easting)!
```

#### Esri Geometry API Java

```
groupId:     com.esri.geometry
artifactId:  esri-geometry-api
版本:        2.2.4
仓库:        https://github.com/Esri/geometry-api-java
```

```java
import com.esri.core.geometry.*;

// 创建几何（大地测量运算原生支持）
Point point = new Point(120.0, 30.0);
Polygon aoi = new Polygon();
aoi.startPath(119, 29);
aoi.lineTo(121, 29);
aoi.lineTo(121, 31);
aoi.lineTo(119, 31);
aoi.closeAllPaths();

// 大地测量缓冲区（椭球面真实距离）
SpatialReference sr = SpatialReference.create(4490);
Geometry geodeticBuffer = GeometryEngine.geodesicBuffer(aoi, 1000, sr, 32);

// 分布式计算（Hadoop/Spark 兼容，使用 JSON 序列化）
String json = GeometryEngine.geometryToJson(sr, point);
```

---

### 2.2 C++ 生态

#### GEOS — 高性能 C++ 引擎

```
安装 (vcpkg):  vcpkg install geos
安装 (apt):    sudo apt install libgeos-dev
安装 (conda):  conda install -c conda-forge geos
版本:          3.12.2
仓库:          https://github.com/libgeos/geos
```

| 概念 | C API 函数 | 说明 |
|------|-----------|------|
| 初始化 | `initGEOS(notice, error)` | 必须最先调用 |
| 读取WKT | `GEOSWKTReader_read(reader, "POINT(120 30)")` | 返回 GEOSGeometry* |
| 求交 | `GEOSIntersection(g1, g2)` | 返回新几何（需释放） |
| 缓冲 | `GEOSBuffer(g, dist, segments)` | 缓冲区 |
| 验证 | `GEOSisValid(g)` | 有效性 |
| 写入WKB | `GEOSGeomToWKB_buf(g, &size)` | 需手动释放 |
| 释放 | `GEOSGeom_destroy(g)` | 每个几何必须释放 |
| 结束 | `finishGEOS()` | 最后调用 |

```cpp
// GEOS C++ API (C++11+)
#include <geos/geom/GeometryFactory.h>
#include <geos/io/WKTReader.h>
#include <geos/operation/buffer/BufferOp.h>

using namespace geos::geom;

GeometryFactory::Ptr factory = GeometryFactory::create();
geos::io::WKTReader reader(*factory);

auto point = reader.read("POINT(120 30)");
auto aoi = reader.read("POLYGON((119 29, 121 29, 121 31, 119 31, 119 29))");

// 空间查询
bool contains = aoi->contains(point.get());
auto buffer = aoi->buffer(0.01);
double area = aoi->getArea();
```

#### GDAL/OGR — 万能数据访问层

```
安装 (vcpkg):  vcpkg install gdal
安装 (apt):    sudo apt install libgdal-dev
版本:          3.9.x
仓库:          https://github.com/OSGeo/GDAL
```

| CLI 命令 | 说明 |
|----------|------|
| `ogr2ogr -f GPKG output.gpkg input.shp` | 矢量格式转换 |
| `gdalwarp -t_srs EPSG:4490 input.tif output.tif` | 栅格投影转换 |
| `gdal_translate -of COG input.tif output.tif` | 生成 Cloud Optimized GeoTIFF |
| `ogrinfo -al input.gpkg` | 查看矢量元数据 |
| `gdalinfo input.tif` | 查看栅格元数据 |

---

### 2.3 Python 生态

#### Shapely 2.x — GEOS 的高层 Python 接口

```
安装:   pip install shapely
版本:   2.0.6 (使用 PyGEOS 后端, GEOS 3.12+)
```

```python
from shapely.geometry import Point, LineString, Polygon, box
from shapely.ops import unary_union, transform
from shapely import wkt, wkb, from_geojson, to_geojson

# 创建几何
p = Point(120.0, 30.0)
line = LineString([(119, 29), (121, 31)])
poly = box(119, 29, 121, 31)

# 空间操作
poly.contains(p)           # True/False
poly.intersects(line)      # True/False
intersection = poly.intersection(line)
buffer = poly.buffer(0.01)
area = poly.area           # 注意：经纬度"度²"

# WKT/WKB 序列化
wkt_str = wkt.dumps(poly)            # → "POLYGON (...)"
geom = wkt.loads(wkt_str)
wkb_bytes = wkb.dumps(poly)

# GeoJSON
geojson_dict = to_geojson(poly)
geom2 = from_geojson('{"type":"Point","coordinates":[120,30]}')

# 简化
simplified = poly.simplify(0.001, preserve_topology=True)

# 修复无效几何
from shapely.validation import make_valid
fixed = make_valid(invalid_poly)

# STRtree 空间索引
from shapely import STRtree
tree = STRtree([p, line, poly])
result = tree.query(box(118, 28, 122, 32))  # 返回索引列表
```

#### GeoPandas — DataFrame 空间分析

```
安装:   pip install geopandas
版本:   1.0.x
```

```python
import geopandas as gpd

gdf = gpd.read_file("data.shp", encoding="utf-8")
gdf = gdf.to_crs("EPSG:4490")
gdf["area_ha"] = gdf.to_crs("EPSG:102025").area / 10000  # 等积投影算面积

# 空间连接
aoi = gpd.read_file("aoi.shp")
roads_in_aoi = gpd.sjoin(gdf, aoi, predicate="intersects")

# 溶解
dissolved = gdf.dissolve(by="district", aggfunc="sum")

# DuckDB Spatial 集成
import duckdb
duckdb.sql("INSTALL spatial; LOAD spatial;")
duckdb.sql("SELECT * FROM gdf WHERE ST_Area(geom) > 1000")
```

#### PyProj — 坐标变换

```
安装:   pip install pyproj
版本:   3.6+
```

```python
from pyproj import CRS, Transformer

# CRS 定义
crs_4490 = CRS.from_epsg(4490)
crs_4326 = CRS.from_epsg(4326)

# 坐标转换 (always_xy=True 保证 x,y 顺序)
transformer = Transformer.from_crs(crs_4326, crs_4490, always_xy=True)
lon_cgcs, lat_cgcs = transformer.transform(120.0, 30.0)
```

#### DuckDB Spatial — SQL 分析引擎

```
安装:   pip install duckdb
加载:   INSTALL spatial; LOAD spatial;
```

```sql
-- 空间查询
SELECT ST_Area(ST_Transform(geom, 'EPSG:102025')) AS area_m2
FROM read_parquet('data.parquet')
WHERE ST_Intersects(geom, ST_GeomFromText('POLYGON((...))'));
```

#### PDAL Python — 点云管道

```
安装:   pip install pdal
版本:   3.x
```

```python
import pdal
import json

pipeline = pdal.Pipeline(json.dumps([
    {"type": "readers.las", "filename": "input.las"},
    {"type": "filters.smrf"},           # 地面滤波
    {"type": "filters.ferry", "dimensions": "Classification=2"},  # 分类
    {"type": "writers.las", "filename": "output.las"}
]))
pipeline.execute()
```

---

### 2.4 R 语言生态

#### sf (Simple Features) — R 空间数据核心

```
安装:   install.packages("sf")
依赖:   GEOS + GDAL + PROJ
```

```r
library(sf)

# 读取
gdf <- st_read("data.shp", options = "ENCODING=UTF-8")

# CRS 变换
gdf_cgcs <- st_transform(gdf, 4490)

# 面积（自动转等积投影警告必须手动处理）
gdf$area_m2 <- st_area(st_transform(gdf, 102025))

# 空间筛选
aoi <- st_read("aoi.shp")
roads_in_aoi <- st_filter(gdf, aoi, .predicate = st_intersects)

# 缓冲区
gdf_buffer <- st_buffer(gdf, dist = 100)

# 写GPKG
st_write(gdf, "output.gpkg", driver = "GPKG")
```

#### terra — 栅格引擎

```r
library(terra)

r <- rast("dem.tif")
r_cgcs <- project(r, "EPSG:4490")
r_crop <- crop(r, ext(119, 121, 29, 31))
writeRaster(r_crop, "output.tif", overwrite=TRUE)
```

---

### 2.5 JavaScript/TypeScript 生态

#### Turf.js — 浏览器端空间分析

```
安装:   npm install @turf/turf
CDN:    https://cdn.jsdelivr.net/npm/@turf/turf/turf.min.js
```

```javascript
import * as turf from '@turf/turf';

const point = turf.point([120, 30]);
const poly = turf.bboxPolygon([119, 29, 121, 31]);

// 空间查询
turf.booleanContains(poly, point);   // true/false
turf.booleanIntersects(line1, line2);

// 缓冲区
const buffer = turf.buffer(point, 1, {units: 'kilometers'});

// 简化
const simplified = turf.simplify(line, {tolerance: 0.001, highQuality: true});

// 面积
const area = turf.area(poly);  // 单位：平方米

// 坐标变换（需 proj4）
import proj4 from 'proj4';
proj4.defs('EPSG:4490', '+proj=longlat +ellps=GRS80 +no_defs');
const [lon, lat] = proj4('EPSG:4490', 'EPSG:4326', [120.0, 30.0]);
```

| 模块 | 功能 | 性能 |
|------|------|------|
| `@turf/buffer` | 缓冲区 | <10K 顶点 |
| `@turf/union` | 合并多边形 | <5K 顶点 |
| `@turf/boolean-contains` | 包含判断 | 极快 |
| `@turf/area` | 面积计算 | 极快 |
| `@turf/centroid` | 质心 | 极快 |
| `@turf/simplify` | 线简化 | 中等 |

#### JSTS — JTS 的 TypeScript/JavaScript 端口

```
安装:   npm install jsts
```

```javascript
import { GeometryFactory } from 'jsts/org/locationtech/jts/geom/GeometryFactory';
import { WKTReader } from 'jsts/org/locationtech/jts/io/WKTReader';

const gf = new GeometryFactory();
const reader = new WKTReader(gf);
const geom = reader.read('POINT(120 30)');
const buffer = geom.buffer(0.01);
```

#### MapLibre GL JS — Web 渲染引擎

```
安装:   npm install maplibre-gl
```

```javascript
import maplibregl from 'maplibre-gl';

const map = new maplibregl.Map({
    container: 'map',
    style: 'https://demotiles.maplibre.org/style.json',
    center: [120, 30],
    zoom: 10
});
```

#### deck.gl — 大规模数据可视化

```
安装:   npm install deck.gl @deck.gl/layers
```

```javascript
import { Deck } from '@deck.gl/core';
import { GeoJsonLayer, ScatterplotLayer } from '@deck.gl/layers';
import { Map } from 'react-map-gl/maplibre';
```

#### OpenLayers — OGC 客户端

```
安装:   npm install ol
```

```javascript
import Map from 'ol/Map.js';
import View from 'ol/View.js';
import TileLayer from 'ol/layer/Tile.js';
import OSM from 'ol/source/OSM.js';
import GeoJSON from 'ol/format/GeoJSON.js';
import VectorLayer from 'ol/layer/Vector.js';
import VectorSource from 'ol/source/Vector.js';

const map = new Map({
    target: 'map',
    layers: [new TileLayer({ source: new OSM() })],
    view: new View({ center: [120, 30], zoom: 10 })
});

// WFS 请求
const vectorSource = new VectorSource({
    format: new GeoJSON(),
    url: 'https://example.com/geoserver/wfs?service=WFS&version=2.0.0&request=GetFeature&typeNames=namespace:layer&outputFormat=application/json'
});
```

---

### 2.6 .NET / C# 生态

#### NetTopologySuite (NTS) — JTS 的 .NET 端口

```
安装:   dotnet add package NetTopologySuite
版本:   2.5.0
仓库:   https://github.com/NetTopologySuite/NetTopologySuite
```

```csharp
using NetTopologySuite.Geometries;
using NetTopologySuite.IO;

// 工厂
var gf = new GeometryFactory(new PrecisionModel(1000), 4490);

// 创建几何
var point = gf.CreatePoint(new Coordinate(120, 30));
var ring = new LinearRing(new[] {
    new Coordinate(119, 29), new Coordinate(121, 29),
    new Coordinate(121, 31), new Coordinate(119, 31),
    new Coordinate(119, 29)
});
var poly = gf.CreatePolygon(ring);

// 空间操作
bool contains = poly.Contains(point);
var buffer = poly.Buffer(0.01);
double area = poly.Area;

// WKT 序列化
var writer = new WKTWriter();
string wkt = writer.Write(poly);

// WKB 序列化 (EF Core Spatial 使用)
var wkbWriter = new WKBWriter();
byte[] wkb = wkbWriter.Write(poly);

// STRtree 索引
var tree = new STRtree<Geometry>();
tree.Insert(poly.EnvelopeInternal, poly);
var results = tree.Query(point.EnvelopeInternal);
```

**NTS 生态系统包**：

| 包名 | 功能 | NuGet |
|------|------|-------|
| `NetTopologySuite` | 核心几何引擎 | 基础 |
| `NetTopologySuite.IO.GeoJSON` | GeoJSON 序列化 | NTS.IO.GeoJSON |
| `NetTopologySuite.IO.ShapeFile` | Shapefile 读写 | NTS.IO.ShapeFile |
| `NetTopologySuite.IO.GPKG` | GeoPackage 支持 | NTS.IO.GPKG |
| `NetTopologySuite.IO.SqlServerBytes` | SQL Server Geometry 序列化 | NTS.IO.SqlServerBytes |
| `Microsoft.EntityFrameworkCore.SqlServer.NetTopologySuite` | EF Core SQL Server Spatial | Microsoft |
| `Npgsql.EntityFrameworkCore.PostgreSQL.NetTopologySuite` | EF Core PostGIS | Npgsql |
| `ProjNet` | 投影变换 (PROJ 的 .NET 实现) | ProjNet |

```csharp
// EF Core + NTS 集成示例
public class LandParcel
{
    public int Id { get; set; }
    public Point Location { get; set; }
    public Polygon Boundary { get; set; }
}

// LINQ 空间查询
var parcelsInArea = dbContext.LandParcels
    .Where(p => p.Boundary.Intersects(searchPolygon))
    .ToList();
```

#### Esri Geometry API .NET

```
安装:   dotnet add package Esri.ArcGISRuntime.Geometry
```

```csharp
using Esri.ArcGISRuntime.Geometry;

var point = new MapPoint(120, 30, SpatialReference.Create(4490));
var poly = new Polygon(new[] {
    new MapPoint(119, 29), new MapPoint(121, 29),
    new MapPoint(121, 31), new MapPoint(119, 31)
}, SpatialReference.Create(4490));

// 大地测量缓冲区
var buffer = GeometryEngine.GeodesicBuffer(poly, 1000, LinearUnits.Meters);

// 大地测量面积
var area = GeometryEngine.GeodesicArea(poly, AreaUnits.SquareMeters);
```

#### Mapsui — 跨平台地图组件

```
安装:   dotnet add package Mapsui
```

支持 WPF / MAUI / Avalonia / Uno Platform / Blazor 跨平台地图渲染。

---

### 2.7 Rust 生态

#### geo — Rust 几何原语

```
Cargo.toml:  geo = "0.28"
```

```rust
use geo::{Point, Polygon, LineString, Contains, Buffer};

let point = Point::new(120.0, 30.0);
let poly = Polygon::new(
    LineString::from(vec![
        (119.0, 29.0), (121.0, 29.0),
        (121.0, 31.0), (119.0, 31.0),
        (119.0, 29.0),
    ]),
    vec![],
);

// 空间操作
let contains = poly.contains(&point);
let buffer = poly.buffer(0.01);
```

**Rust GIS 生态包**：

| 包名 | 功能 | Cargo |
|------|------|-------|
| `geo` | 几何原语+基础操作 | 核心 |
| `geo-types` | 类型定义 (Point/LineString/Polygon) | 基础 |
| `gdal` | GDAL Rust 绑定 | 数据访问 |
| `geojson` | GeoJSON 序列化 | 互操作 |
| `wkt` | WKT 序列化 | 互操作 |
| `proj` | PROJ 绑定 | 坐标变换 |
| `geos` | GEOS C API 绑定 | 拓扑运算 |
| `geo-index` | R-tree 空间索引 | 索引 |

---

## 三、场景决策矩阵

| 场景 | 推荐引擎/库 | 语言 | 原因 |
|------|-----------|------|------|
| **桌面GIS脚本** | PyQGIS | Python | QGIS 直接集成，API完整 |
| **Web前端空间分析** | Turf.js | JavaScript | 浏览器原生，无后端依赖 |
| **企业Java后端** | GeoTools + JTS | Java | OGC 标准全面，Spring生态 |
| **企业.NET后端** | NTS + EF Core Spatial | C# | SQL Server/PostGIS集成 |
| **数据科学探索** | GeoPandas + Shapely + DuckDB | Python | Pandas生态，Jupyter友好 |
| **高性能批量处理** | GDAL/OGR CLI | C++ | 最快批处理，格式覆盖最广 |
| **实时Web渲染** | MapLibre GL JS / deck.gl | JavaScript | WebGL加速，大数据量 |
| **大数据(>100M要素)** | Apache Sedona (Spark) | Java/Scala | 分布式几何运算 |
| **点云处理** | PDAL | C++/Python | 行业标准管道 |
| **统计建模与可视化** | sf + terra + tmap | R | 统计生态，出版级图表 |
| **跨平台桌面App** | Mapsui | C# | WPF/MAUI/Avalonia/Blazor |
| **嵌入式/高性能** | GEOS C API | C++ | 最小依赖，最高性能 |
| **移动端GIS** | ArcGIS Runtime SDK | Swift/Kotlin/C# | 原生渲染，离线地图 |
| **CGCS2000精确运算** | Esri Geometry API | Java/.NET | 原生大地测量运算 |
| **OGC服务开发** | GeoServer (JTS) | Java | 完整OGC协议栈 |
| **空间数据库操作** | PostGIS (GEOS) | SQL | 百万级数据高效查询 |
| **WASM/浏览器重型计算** | GEOS WASM | C++→Wasm | 浏览器端全拓扑能力 |

### 3.1 按数据量决策

```
< 10K 要素    → 任何库均可，Turf.js/Python 脚本最快开发
10K-1M 要素   → GeoPandas (单机) / PostGIS (持久化) / sf (R)
1M-100M 要素  → PostGIS + 索引 / GDAL CLI 批处理
> 100M 要素   → Apache Sedona (Spark) / Dask-GeoPandas (分布式)
```

### 3.2 跨语言工作流推荐

```
开发阶段        Python (GeoPandas + Shapely) → 快速原型
生产部署        Java (GeoTools+JTS) / C# (NTS+EF Core)
批处理          GDAL/OGR CLI + Shell/Python 脚本
可视化          JavaScript (MapLibre + Turf.js) → Web前端
统计报告        R (sf + ggplot2 + tmap)
空间数据库      PostgreSQL + PostGIS (GEOS 引擎)
```

---

## 四、CRS / CGCS2000 跨语言处理

### 4.1 CGCS2000 EPSG 编码速查

| 类型 | EPSG 编码 | 说明 |
|------|----------|------|
| 地理坐标系 | **EPSG:4490** | CGCS2000 经纬度（度为单位） |
| 地理坐标系(等同) | EPSG:4479 | CGCS2000 (GEOCENTRIC) |
| 投影坐标系基础 | EPSG:4522~4554 | CGCS2000 / 3-degree Gauss-Kruger CM |
| 6度带 | EPSG:4491~4516 | CGCS2000 / 6-degree Gauss-Kruger CM |
| UTM | EPSG:4547~4558 | CGCS2000 / UTM zone |
| Albers等积 | EPSG:102025 | 中国区域自定义Albers |
| Web Mercator | EPSG:3857 | WGS84 Web Mercator |

### 4.2 各语言 CGCS2000 处理示例

#### Python — pyproj (always_xy=True 关键)

```python
from pyproj import CRS, Transformer

crs_4490 = CRS.from_epsg(4490)
crs_4527 = CRS.from_epsg(4527)  # CGCS2000 / 3-degree Gauss-Kruger CM 120E

# 经纬度 → 投影坐标
transformer = Transformer.from_crs(crs_4490, crs_4527, always_xy=True)
x, y = transformer.transform(120.5, 30.2)

# WGS84 → CGCS2000
trans_wgs84 = Transformer.from_crs("EPSG:4326", "EPSG:4490", always_xy=True)
lon_cgcs, lat_cgcs = trans_wgs84.transform(120.0, 30.0)

# ⚠️ 常见陷阱：如果 always_xy=False (默认)，pyproj 会按 EPSG 定义的轴序(lat,lon)处理
# 这会导致经纬度颠倒！始终使用 always_xy=True
```

#### Java — GeoTools (轴序陷阱：northing/easting)

```java
import org.geotools.api.referencing.crs.CoordinateReferenceSystem;
import org.geotools.referencing.CRS;
import org.geotools.geometry.jts.JTS;
import org.geotools.api.referencing.operation.MathTransform;

// 解码 CRS
CoordinateReferenceSystem crs4490 = CRS.decode("EPSG:4490");
CoordinateReferenceSystem crs4527 = CRS.decode("EPSG:4527");
// 注意：EPSG:4490 在GeoTools中轴序为 north/east (lat, lon)!

// 坐标变换
MathTransform transform = CRS.findMathTransform(crs4490, crs4527, true);

// ⚠️ GeoTools CRS.decode("EPSG:4490") 会返回轴序 (纬度, 经度)
// 即 GeographicCRS.WGS84 风格的 northing/easting
// 使用 JTS.transform() 时要注意输入坐标顺序
```

#### .NET/C# — ProjNet

```csharp
using ProjNet.CoordinateSystems;
using ProjNet.CoordinateSystems.Transformations;

// 解析 EPSG
var csFactory = new CoordinateSystemFactory();
var cf = new CoordinateTransformationFactory();

var wgs84 = csFactory.CreateFromWkt("GEOGCS[...]");      // EPSG:4326
var cgcs2000 = csFactory.CreateFromWkt("GEOGCS[...]");   // EPSG:4490

var transform = cf.CreateFromCoordinateSystems(wgs84, cgcs2000);
double[] result = transform.MathTransform.Transform(new double[] { 120.0, 30.0 });
```

```csharp
// SQL Server + CGCS2000
// geometry 类型存储投影坐标；geography 类型存储地理坐标
geometry::STGeomFromText('POINT(40500000 3320000)', 4527)  -- 3度带 120E
```

#### JavaScript — proj4js

```javascript
import proj4 from 'proj4';

// 定义 CGCS2000 (如果 proj4 没有内置)
proj4.defs('EPSG:4490', '+proj=longlat +ellps=GRS80 +towgs84=0,0,0,0,0,0,0 +no_defs +type=crs');

// 坐标变换
const [x, y] = proj4('EPSG:4490', 'EPSG:4326', [120.0, 30.0]);

// 懒人方案：CGCS2000 ≈ WGS84 在线差 5cm 级别，Web 端可近似
const cgcs2000ToWgs84 = ([lon, lat]) => [lon, lat];  // 可接受近似
```

#### OGU4J / OGU4NET — 内置 CGCS2000

```java
// OGU4J
CrsUtil.toCgcs2000(wgs84Point);
CrsUtil.extract3DegreeZone(lon);        // 返回 EPSG:4522~4554
CrsUtil.extract6DegreeZone(lon);        // 返回 EPSG:4491~4516
```

```csharp
// OGU4NET
var cgcs = CrsUtil.ToCgcs2000(wgs84Point);
int zone3 = CrsUtil.Extract3DegreeZone(120.5);  // → 4527 (120E)
int zone6 = CrsUtil.Extract6DegreeZone(120.5);  // → 4501
```

### 4.3 轴序陷阱速查表

| 库/SDK | EPSG:4490 轴序 | 解决方法 |
|--------|:---:|------|
| **pyproj** | lat,lon (默认) | `Transformer(..., always_xy=True)` |
| **GeoTools** CRS.decode("EPSG:4490") | lat,lon | 转换时交换输入坐标 |
| **PROJ** (C API) | lat,lon | 使用 `proj_trans(..., PJ_FWD, ...)` 注意轴序 |
| **proj4js** | x,y (proj4默认) | 跟 PROJ 一致，直接使用 |
| **GDAL** ogr2ogr | 自动处理 | GDAL 3.0+ 自动处理 CRS 轴序 |
| **Shapely** | 无CRS概念 | 纯几何运算，不关心轴序 |
| **PostGIS** ST_Transform | x,y (lng,lat) | `ST_Transform(geom, 4490)` 返回 x,y 轴序 |
| **Esri** API | x,y | Esri 始终用 x,y 轴序 |

> **核心原则**：处理地理坐标时始终检查当前库的默认轴序，尤其在 Python/Java 之间互操作时必须明确轴序约定。

---

## 五、文件格式读写对照表

### 5.1 矢量格式

| 格式 | Python | Java | .NET | JS | R | C++ CLI | 备注 |
|------|:---:|:---:|:---:|:---:|:---:|:---:|------|
| **Shapefile** | GeoPandas/Fiona | GeoTools | NTS.IO.ShapeFile | shpjs | sf | ogr2ogr | **2026年不再推荐新项目** |
| **GeoPackage** | GeoPandas/Fiona | GeoTools | NTS.IO.GPKG | ol/format/GPX | sf | ogr2ogr | **2026年矢量首选** |
| **GeoJSON** | GeoPandas/fiona | GeoTools | NTS.IO.GeoJSON | 原生 | sf | ogr2ogr | Web 标准交换 |
| **GeoParquet** | GeoPandas | GeoParquet Java | — | @loaders.gl/parquet | arrow | — | 云原生矢量大文件 |
| **FlatGeobuf** | Fiona | GeoTools | — | flatgeobuf | sf | ogr2ogr | 流式随机读取 |
| **FileGDB** | GDAL (只读) | FileGDB API | Esri API | — | — | — | Esri 专有 |
| **PostGIS dump** | GeoPandas+SQLAlchemy | GeoTools JDBC | Npgsql+NTS | pg | RPostgreSQL+sf | — | SQL导出 |
| **KML/KMZ** | Fiona | GeoTools | — | togeojson/tokml | sf | ogr2ogr | Google Earth |
| **GPX** | Fiona | GeoTools | — | togpx | sf | ogr2ogr | GPS 轨迹 |
| **GML** | Fiona/GDAL | GeoTools | — | ol/format/GML | sf | ogr2ogr | OGC 标准 |
| **DXF/DWG** | Fiona (DXF) | — | — | — | — | ogr2ogr | CAD互转→参见30号文件 |
| **CSV (WKT)** | GeoPandas | GeoTools | — | csv2geojson | sf | ogr2ogr | 通用文本 |
| **TopoJSON** | topojson | — | — | topojson | — | — | 压缩拓扑 |
| **MBTiles** | — | — | — | maplibre-gl | — | ogr2ogr | 矢量瓦片 |
| **PMTiles** | pmtiles | — | — | pmtiles.js | — | pmtiles CLI | 云原生单文件 |

> 详细格式说明见：←→ 03_数据模型与格式.md（含GeoParquet/COG/PMTiles云原生格式）

### 5.2 栅格格式

| 格式 | Python | Java | .NET | JS | R | C++ CLI | 备注 |
|------|:---:|:---:|:---:|:---:|:---:|:---:|------|
| **GeoTIFF** | Rasterio 1.x | GeoTools | — | geotiff.js | terra | gdalwarp | 标准栅格 |
| **COG** (Cloud Optimized GeoTIFF) | Rasterio | GeoTools | — | geotiff.js | terra | gdal_translate | **云原生首选** |
| **NetCDF** | xarray | — | — | — | terra/stars | gdal_translate | 气象/海洋 |
| **HDF5** | h5py/rioxarray | — | — | — | — | gdal_translate | 科学数据 |
| **IMG (ERDAS)** | Rasterio | — | — | — | terra | gdal_translate | ERDAS Imagine |
| **JPEG2000** | Rasterio | GeoTools | — | — | terra | gdal_translate | 压缩存档 |
| **ECW** | GDAL (需插件) | — | — | — | — | gdal_translate | 需授权 |
| **MrSID** | GDAL (需插件) | — | — | — | — | gdal_translate | 需LizardTech SDK |
| **DEM/USGS** | Rasterio | — | — | — | terra | gdal_translate | 高程专用 |
| **MBTiles** (栅格) | — | — | — | Leaflet/MapLibre | — | gdal2tiles | 栅格瓦片包 |
| **XYZ Tiles** | — | — | — | MapLibre | — | gdal2tiles | 瓦片目录 |
| **Zarr** | xarray/zarr | — | — | zarr.js | — | — | 云原生分块存储 |

> 详细栅格格式见：←→ 03_数据模型与格式.md、←→ 24_遥感与GEE.md

### 5.3 点云格式

| 格式 | Python | C++ CLI | R | JS | 备注 |
|------|:---:|:---:|:---:|:---:|------|
| **LAS/LAZ** 1.4 | PDAL/laspy | PDAL | lidR | loaders.gl | **行业标准** |
| **E57** | PDAL | PDAL | — | — | 扫描注册 |
| **PLY** | Open3D/PDAL | PDAL | — | — | 三角网格 |
| **PCD** (PCL) | pclpy | PDAL | — | — | PCL 原生 |
| **COPC** (Cloud Optimized) | PDAL | PDAL | — | copc.js | **云原生点云** |
| **BIN** (TerraScan) | PDAL | PDAL | — | — | TerraSolid |
| **Potree** | — | — | — | Potree/loaders.gl | Web 可视化 |

> 点云处理详细：←→ 36_LiDAR360_点云处理软件.md

### 5.4 格式选择决策树

```
数据类型
├── 矢量
│   ├── 新项目 → GeoPackage (.gpkg)
│   ├── Web 交换 → GeoJSON / FlatGeobuf
│   ├── 大数据存档 → GeoParquet
│   └── 遗留兼容 → Shapefile (仅读取)
│
├── 栅格
│   ├── 标准分发 → GeoTIFF
│   ├── 云端访问 → COG (Cloud Optimized GeoTIFF)
│   ├── 多波段科学 → NetCDF / HDF5 / Zarr
│   ├── 瓦片服务 → MBTiles / PMTiles
│   └── 高程数据 → GeoTIFF (Float32)
│
├── 点云
│   ├── 通用 → LAS 1.4 / LAZ (压缩)
│   ├── 云端访问 → COPC
│   ├── 扫描交换 → E57
│   └── Web 发布 → Potree / 3DTiles
│
└── 瓦片
    ├── 矢量瓦片 → MVT (Mapbox Vector Tile) / PMTiles
    ├── 栅格瓦片 → MBTiles
    └── 3D瓦片  → 3DTiles / SLPK (i3s)
```

---

## 六、性能基准参考

### 6.1 拓扑运算性能 (100K 多边形)

| 操作 | GEOS (C++) | JTS (Java) | Shapely (Python) | NTS (.NET) | JSTS (JS) | 单位 |
|------|:---:|:---:|:---:|:---:|:---:|------|
| 相交判断 × 100K | **0.3s** | 0.6s | 0.5s | 0.7s | 2.1s | 秒 |
| 缓冲区(1km) × 1K | **1.2s** | 2.1s | 1.8s | 2.3s | 8.5s | 秒 |
| 并集合并 × 10K | **0.8s** | 1.5s | 1.2s | 1.7s | 6.2s | 秒 |
| WKT解析 × 100K | 0.4s | **0.3s** | 0.5s | 0.4s | 1.8s | 秒 |
| 空间索引构建(1M点) | **0.9s** | 1.1s | 1.0s | 1.2s | 15s+ | 秒 |

> 基准环境：Intel i7-13700, 32GB RAM, Windows 11。Python 使用 Shapely 2.x (PyGEOS 后端)。

### 6.2 内存占用 (1M 多边形加载)

| 引擎 | 内存 | 相对比值 |
|------|------|:---:|
| GEOS (C++) | ~180 MB | 1.0x |
| Shapely (PyGEOS) | ~220 MB | 1.2x |
| JTS (Java) | ~350 MB | 1.9x |
| NTS (.NET) | ~340 MB | 1.9x |
| JSTS (JS) | ~800 MB | 4.4x |

---

## 七、版本兼容性与迁移

### 7.1 Shapely 1.x → 2.x 迁移

```python
# Shapely 1.x (旧)
from shapely.geometry import Point
p = Point(120, 30)
wkt_str = p.wkt

# Shapely 2.x (新，推荐)
from shapely import Point, wkt
p = Point(120, 30)
wkt_str = wkt.dumps(p)
```

| Shapely 1.x | Shapely 2.x | 说明 |
|-------------|-------------|------|
| `p.wkt` | `wkt.dumps(p)` | WKT 序列化改为模块函数 |
| `p.wkb` | `wkb.dumps(p)` | WKB 序列化 |
| `wkt.loads(s)` | `wkt.loads(s)` | 解析函数不变 |
| `p.to_wkt()` | `wkt.dumps(p)` | 推荐新 API |
| `p.intersects(q)` | `p.intersects(q)` | 方法名不变 |

### 7.2 GeoTools 版本选择

| GeoTools 版本 | Java 要求 | 关键变化 |
|:---:|:---:|------|
| 29.x | Java 11 | LTS 长期支持 |
| 30.x | Java 17 | 移除废弃 API |
| **31.x** | Java 17+ | **推荐：2026 最新版**，支持 GeoParquet 1.0 |

---

## 八、空间索引跨语言对照

| 索引类型 | JTS | GEOS | Shapely | NTS | JSTS | Esri | 适用场景 |
|---------|-----|------|---------|-----|------|------|---------|
| **STRtree** | `STRtree` | `GEOSSTRtree` | `STRtree` | `STRtree<T>` | — | — | 通用R-tree(线/面) |
| **QuadTree** | `Quadtree` | — | — | — | — | `QuadTree` | 点数据 |
| **KDBush** | — | — | — | — | 有 | — | JS 点索引最快 |
| **HRtree** | — | — | — | — | — | `HRtree` | Esri 高性能R-tree |
| **GiST** | — | PostGIS 内部 | — | — | — | — | PostgreSQL 原生 |

```python
# Shapely STRtree
from shapely import STRtree
geoms = [poly1, poly2, poly3]
tree = STRtree(geoms)
query_box = box(119, 29, 121, 31)
result_indices = tree.query(query_box)
```

```java
// JTS STRtree
STRtree tree = new STRtree();
for (Geometry g : geometries) {
    tree.insert(g.getEnvelopeInternal(), g);
}
tree.build();
List<Geometry> results = tree.query(searchEnvelope);
```

```csharp
// NTS STRtree
var tree = new STRtree<Geometry>();
foreach (var g in geometries) {
    tree.Insert(g.EnvelopeInternal, g);
}
var results = tree.Query(searchEnvelope);
```

---

## 九、生态依赖关系图

```
┌─────────────────────────────────────────────────────────┐
│                    应用层                                │
│  QGIS  ArcGIS Pro  GeoServer  MapServer  deck.gl       │
└────┬──────┬──────────┬──────────┬──────────┬───────────┘
     │      │          │          │          │
     ▼      ▼          ▼          ▼          ▼
┌─────────────────────────────────────────────────────────┐
│                  语言绑定层                              │
│  Shapely(Py)  sf(R)  NTS(.NET)  JSTS(JS)  geo(Rust)   │
└────────┬─────────┬─────────┬─────────┬─────────────────┘
         │         │         │         │
         └────┬────┴────┬────┴────┬────┘
              │         │         │
              ▼         ▼         ▼
┌─────────────────────────────────────────────────────────┐
│                C/C++ 引擎层                              │
│          GEOS  ───  GDAL/OGR  ───  PROJ                │
│       (拓扑引擎)   (格式翻译器)   (投影引擎)              │
└─────────────────────────────────────────────────────────┘
         │              │              │
         └──────────────┼──────────────┘
                        ▼
┌─────────────────────────────────────────────────────────┐
│                  数据库层                                │
│   PostGIS(GEOS)  SpatiaLite(GEOS)  DuckDB Spatial      │
└─────────────────────────────────────────────────────────┘
```

> **关键路径**：几乎所有高级语言的 GIS 能力最终都通过 GEOS/GDAL/PROJ 这 C/C++ 三剑客实现。选择绑定时关注底层版本（如 Shapely 2.x 要求 GEOS 3.12+）。

---

## 十、推荐工具栈 (2026)

### 10.1 按角色推荐

| 角色 | 语言 | 推荐栈 |
|------|------|--------|
| **GIS 分析师/技术员** | Python | QGIS + GeoPandas + Shapely + GDAL |
| **空间数据科学家** | Python | GeoPandas + DuckDB Spatial + Shapely + PyProj + Rasterio |
| **统计分析师** | R | sf + terra + tmap + leaflet |
| **后端工程师(Java)** | Java | Spring Boot + GeoTools + JTS + PostGIS |
| **后端工程师(.NET)** | C# | ASP.NET + NTS + EF Core Spatial + SQL Server |
| **前端工程师** | JS/TS | MapLibre GL JS + Turf.js + deck.gl |
| **全栈GIS开发** | Python+JS | PostgreSQL/PostGIS + GeoServer + OpenLayers/MapLibre |
| **大数据架构师** | Scala/Python | Apache Sedona + GeoMesa + GeoWave |
| **DevOps/SRE** | Shell/Python | GDAL CLI + tippecanoe + Martin (PMTiles服务) |
| **点云工程师** | C++/Python | PDAL + LAStools + lidR (R) + LiDAR360 |
| **移动开发(iOS)** | Swift | ArcGIS Maps SDK for Swift |
| **移动开发(Android)** | Kotlin | ArcGIS Maps SDK for Kotlin |
| **桌面GIS扩展** | C# | ArcGIS Pro SDK + NTS + Esri Geometry API |
| **嵌入式/WASM** | C++/Rust | GEOS C API + GDAL + PROJ |

### 10.2 2026 退役/谨慎使用

| 技术 | 状态 | 替代方案 |
|------|------|---------|
| Shapefile (.shp) | **退役** | GeoPackage (.gpkg) |
| Mapbox GL JS v1 | 退役 | MapLibre GL JS |
| Shapely 1.x | 退役 | Shapely 2.x |
| OpenLayers 6 | 退役 | OpenLayers 10+ |
| Java 8 + GeoTools 24 | 谨慎使用 | Java 17+ / GeoTools 31 |
| GDAL 2.x | 退役 | GDAL 3.9+ |
| PROJ 6.x | 退役 | PROJ 9.4+ |

> 格式退役详情见：←→ 43_格式选择决策树与反模式.md

---

## 十一、交叉参考索引

| 相关主题 | 文件 | 说明 |
|---------|------|------|
| Python GIS 完整生态 | ←→ 21_Python_GIS生态.md | GeoPandas/Rasterio/Shapely/PyProj/DuckDB |
| R 语言 GIS 生态 | ←→ 39_R语言GIS生态.md | sf/terra/tmap/leaflet 完整工作流 |
| 空间数据库 | ←→ 22_空间数据库.md | PostGIS/GDB/GeoPackage/DuckDB Spatial |
| WebGIS 开发 | ←→ 23_WebGIS开发.md | MapLibre/OpenLayers/Cesium/PMTiles |
| OGC 国际标准 | ←→ 40_OGC国际标准速查手册.md | WMS/WFS/WMTS/OGC API |
| 格式选择决策树 | ←→ 43_格式选择决策树与反模式.md | 文件格式选择+反模式 |
| QGIS 算法速查 | ←→ 44_QGIS_Processing算法速查手册.md | 200+ Processing 算法 |
| GIS Agent 范式 | ←→ 45_GIS_Agent技能设计范式.md | Reviewer/Inversion/Pipeline/Orchestrator |
| 点云处理 | ←→ 36_LiDAR360_点云处理软件.md | LiDAR/PDAL/lasR |
| 三维GIS | ←→ 25_三维GIS与数字孪生.md | 3DTiles/SLPK/倾斜摄影 |
| CAD转换 | ←→ 30_GIS↔CAD数据转换.md | DWG/DXF 互转 |
| 数据模型与格式 | ←→ 03_数据模型与格式.md | 云原生格式 (GeoParquet/COG/PMTiles) |

---

> **维护日志**：2026-06-04 创建 V1.0 | 基于 opengis-skills-main 交叉分析 | 几何引擎继承链全文档化
> **下一版本计划**：Apache Sedona 4.0 新 API、DuckDB Spatial 1.1 功能、GeoParquet 1.1 GeoArrow 编码


<!-- wm:坤图_GIS:V1.0 -->
