几何运算操作符用于对几何对象进行变换和计算，生成新的几何对象或计算几何属性。这些操作符是空间分析的核心工具。
| 类别 | 操作符 | 说明 |
|---|---|---|
| 创建型 | BufferOperator | 创建缓冲区 |
| 创建型 | ConvexHullOperator | 计算凸包 |
| 创建型 | BoundaryOperator | 获取边界 |
| 创建型 | OffsetOperator | 创建偏移几何 |
| 计算型 | AreaOperator | 计算面积 |
| 计算型 | LengthOperator | 计算长度 |
| 计算型 | CentroidOperator | 计算质心 |
| 变换型 | SimplifyOperator | 简化几何 |
| 变换型 | GeneralizeOperator | 概化几何 |
| 变换型 | DensifyOperator | 密化几何 |
| 变换型 | ClipOperator | 裁剪几何 |
缓冲区操作在几何对象周围创建指定距离的区域。这是 GIS 分析中最常用的操作之一。
应用场景：
public class BufferOperator : IGeometryOperator<Polygon>
{
public static BufferOperator Instance { get; }
public Polygon Execute(Geometry geometry, double distance,
SpatialReference? spatialRef = null);
}
using Esri.Geometry.Core;
using Esri.Geometry.Core.Geometries;
// 点缓冲区
var point = new Point(100, 100);
var buffer = GeometryEngine.Buffer(point, 10);
Console.WriteLine($"缓冲区类型：{buffer.Type}"); // Polygon
Console.WriteLine($"环数：{buffer.RingCount}"); // 1
// 包络矩形缓冲区
var envelope = new Envelope(0, 0, 50, 30);
var envBuffer = GeometryEngine.Buffer(envelope, 5);
// 缓冲区扩展了各方向 5 个单位
var bufferEnv = envBuffer.GetEnvelope();
Console.WriteLine($"缓冲区范围：({bufferEnv.XMin}, {bufferEnv.YMin}) - ({bufferEnv.XMax}, {bufferEnv.YMax})");
// 输出：(-5, -5) - (55, 35)
当前实现为简化版本，创建矩形缓冲区：
private Polygon BufferPoint(Point point, double distance)
{
// 在点周围创建正方形缓冲区
var polygon = new Polygon();
var ring = new List<Point>
{
new Point(point.X - distance, point.Y - distance),
new Point(point.X + distance, point.Y - distance),
new Point(point.X + distance, point.Y + distance),
new Point(point.X - distance, point.Y + distance),
new Point(point.X - distance, point.Y - distance) // 闭合
};
polygon.AddRing(ring);
return polygon;
}
private Polygon BufferEnvelope(Envelope envelope, double distance)
{
// 在各个方向上扩展包络
var polygon = new Polygon();
var ring = new List<Point>
{
new Point(envelope.XMin - distance, envelope.YMin - distance),
new Point(envelope.XMax + distance, envelope.YMin - distance),
new Point(envelope.XMax + distance, envelope.YMax + distance),
new Point(envelope.XMin - distance, envelope.YMax + distance),
new Point(envelope.XMin - distance, envelope.YMin - distance)
};
polygon.AddRing(ring);
return polygon;
}
// 场景：创建商店的配送范围
var storeLocation = new Point(116.4074, 39.9042);
var deliveryRadius = 0.02; // 约 2 公里（经纬度）
var deliveryZone = GeometryEngine.Buffer(storeLocation, deliveryRadius);
// 检查客户是否在配送范围内
var customerLocation = new Point(116.41, 39.91);
bool canDeliver = GeometryEngine.Contains(deliveryZone, customerLocation);
Console.WriteLine($"可以配送：{canDeliver}");
凸包是包含给定点集的最小凸多边形。可以想象为用橡皮筋套住一组钉子形成的形状。
应用场景：
public class ConvexHullOperator : IGeometryOperator<Geometry>
{
public static ConvexHullOperator Instance { get; }
public Geometry Execute(Geometry geometry,
SpatialReference? spatialRef = null);
}
using Esri.Geometry.Core;
using Esri.Geometry.Core.Geometries;
// 多点的凸包
var multiPoint = new MultiPoint();
multiPoint.Add(new Point(0, 0));
multiPoint.Add(new Point(10, 0));
multiPoint.Add(new Point(5, 5));
multiPoint.Add(new Point(10, 10));
multiPoint.Add(new Point(0, 10));
multiPoint.Add(new Point(5, 3)); // 内部点
var hull = GeometryEngine.ConvexHull(multiPoint);
if (hull is Polygon polygon)
{
Console.WriteLine($"凸包顶点数：{polygon.GetRing(0).Count}");
// 内部点 (5, 3) 不在凸包边界上
}
// 折线的凸包
var polyline = new Polyline();
polyline.AddPath(new List<Point>
{
new Point(0, 0),
new Point(5, 10),
new Point(10, 0)
});
var lineHull = GeometryEngine.ConvexHull(polyline); // 返回三角形
private List<Point> GrahamScan(List<Point> points)
{
if (points.Count < 3) return points;
// 1. 找到 Y 坐标最小的点（最低点）
var lowestPoint = points.OrderBy(p => p.Y).ThenBy(p => p.X).First();
// 2. 按极角排序其他点
var sortedPoints = points
.Where(p => p != lowestPoint)
.OrderBy(p => Math.Atan2(p.Y - lowestPoint.Y, p.X - lowestPoint.X))
.ThenBy(p => p.Distance(lowestPoint))
.ToList();
// 3. 构建凸包
var hull = new List<Point> { lowestPoint };
foreach (var point in sortedPoints)
{
// 移除产生右转的点
while (hull.Count > 1 && !IsLeftTurn(hull[hull.Count - 2], hull[hull.Count - 1], point))
{
hull.RemoveAt(hull.Count - 1);
}
hull.Add(point);
}
return hull;
}
private bool IsLeftTurn(Point p1, Point p2, Point p3)
{
// 使用叉积判断是否左转
var cross = (p2.X - p1.X) * (p3.Y - p1.Y) - (p2.Y - p1.Y) * (p3.X - p1.X);
return cross > 0;
}
算法复杂度：O(n log n)，其中 n 是点的数量。
根据输入几何的不同，凸包返回不同类型：
| 输入点数 | 返回类型 |
|---|---|
| 0 | 空 Polygon |
| 1 | Point |
| 2 | Line |
| ≥3 | Polygon |
public class AreaOperator : IGeometryOperator<double>
{
public static AreaOperator Instance { get; }
public double Execute(Geometry geometry,
SpatialReference? spatialRef = null);
}
public class LengthOperator : IGeometryOperator<double>
{
public static LengthOperator Instance { get; }
public double Execute(Geometry geometry,
SpatialReference? spatialRef = null);
}
using Esri.Geometry.Core;
using Esri.Geometry.Core.Geometries;
// 计算多边形面积
var polygon = new Polygon();
polygon.AddRing(new List<Point>
{
new Point(0, 0),
new Point(10, 0),
new Point(10, 10),
new Point(0, 10),
new Point(0, 0)
});
double area = GeometryEngine.Area(polygon);
Console.WriteLine($"多边形面积：{area}"); // 100
// 计算包络矩形面积
var envelope = new Envelope(0, 0, 100, 50);
double envArea = GeometryEngine.Area(envelope);
Console.WriteLine($"包络面积：{envArea}"); // 5000
// 计算折线长度
var polyline = new Polyline();
polyline.AddPath(new List<Point>
{
new Point(0, 0),
new Point(3, 4), // 距离原点 5
new Point(3, 14) // 向上 10
});
double length = GeometryEngine.Length(polyline);
Console.WriteLine($"折线长度：{length}"); // 15
// 计算多边形周长
double perimeter = GeometryEngine.Length(polygon);
Console.WriteLine($"多边形周长：{perimeter}"); // 40
public double Execute(Geometry geometry, SpatialReference? spatialRef = null)
{
if (geometry is Polygon polygon)
{
double area = 0;
foreach (var ring in polygon.GetRings())
{
var count = ring.Count;
if (count < 3) continue;
double ringArea = 0;
for (var i = 0; i < count - 1; i++)
{
// 鞋带公式
ringArea += ring[i].X * ring[i + 1].Y - ring[i + 1].X * ring[i].Y;
}
// 闭合环
ringArea += ring[count - 1].X * ring[0].Y - ring[0].X * ring[count - 1].Y;
area += Math.Abs(ringArea) * 0.5;
}
return area;
}
if (geometry is Envelope envelope)
{
return envelope.Width * envelope.Height;
}
return 0; // 点和线没有面积
}
public double Execute(Geometry geometry, SpatialReference? spatialRef = null)
{
if (geometry is Polyline polyline)
{
double length = 0;
foreach (var path in polyline.GetPaths())
{
for (var i = 0; i < path.Count - 1; i++)
{
length += path[i].Distance(path[i + 1]);
}
}
return length;
}
if (geometry is Polygon polygon)
{
double length = 0;
foreach (var ring in polygon.GetRings())
{
for (var i = 0; i < ring.Count - 1; i++)
{
length += ring[i].Distance(ring[i + 1]);
}
// 闭合段
if (ring.Count > 1)
{
length += ring[ring.Count - 1].Distance(ring[0]);
}
}
return length;
}
return 0; // 点没有长度
}
使用 Douglas-Peucker 算法减少几何对象的顶点数量，同时保持其基本形状。常用于减少数据量，提高渲染性能。
应用场景：
public class SimplifyOperator : IGeometryOperator<Geometry>
{
public static SimplifyOperator Instance { get; }
public Geometry Execute(Geometry geometry, double tolerance,
SpatialReference? spatialRef = null);
}
using Esri.Geometry.Core;
using Esri.Geometry.Core.Geometries;
// 创建包含多个点的折线
var polyline = new Polyline();
polyline.AddPath(new List<Point>
{
new Point(0, 0),
new Point(1, 0.1), // 几乎在直线上
new Point(2, 0.05), // 几乎在直线上
new Point(3, 0.08), // 几乎在直线上
new Point(4, 0),
new Point(5, 5), // 明显转折
new Point(6, 4.9), // 几乎在直线上
new Point(7, 5.1), // 几乎在直线上
new Point(8, 5),
new Point(9, 0),
new Point(10, 0)
});
Console.WriteLine($"原始点数：{polyline.GetPath(0).Count}"); // 11
// 使用容差 0.2 简化
var simplified = GeometryEngine.Simplify(polyline, 0.2);
if (simplified is Polyline simplifiedLine)
{
Console.WriteLine($"简化后点数：{simplifiedLine.GetPath(0).Count}"); // 减少
}
// 使用更大的容差会更激进地简化
var moreSimplified = GeometryEngine.Simplify(polyline, 1.0);
private List<Point> DouglasPeucker(List<Point> points, double tolerance)
{
if (points.Count < 3) return points;
// 1. 找到距离首尾连线最远的点
double maxDistance = 0;
int maxIndex = 0;
int end = points.Count - 1;
for (int i = 1; i < end; i++)
{
double distance = PerpendicularDistance(points[i], points[0], points[end]);
if (distance > maxDistance)
{
maxDistance = distance;
maxIndex = i;
}
}
// 2. 如果最大距离超过容差，递归处理两段
if (maxDistance > tolerance)
{
var left = DouglasPeucker(points.GetRange(0, maxIndex + 1), tolerance);
var right = DouglasPeucker(points.GetRange(maxIndex, end - maxIndex + 1), tolerance);
// 合并结果（去掉重复的中间点）
var result = new List<Point>(left);
result.AddRange(right.Skip(1));
return result;
}
// 3. 否则只保留端点
return new List<Point> { points[0], points[end] };
}
// 计算点到线段的垂直距离
private double PerpendicularDistance(Point point, Point lineStart, Point lineEnd)
{
double dx = lineEnd.X - lineStart.X;
double dy = lineEnd.Y - lineStart.Y;
double mag = Math.Sqrt(dx * dx + dy * dy);
if (mag < GeometryConstants.Epsilon)
return point.Distance(lineStart);
// 参数化位置
double u = ((point.X - lineStart.X) * dx + (point.Y - lineStart.Y) * dy) / (mag * mag);
if (u < 0) return point.Distance(lineStart);
if (u > 1) return point.Distance(lineEnd);
// 最近点
double ix = lineStart.X + u * dx;
double iy = lineStart.Y + u * dy;
return point.Distance(new Point(ix, iy));
}
算法复杂度：平均 O(n log n)，最坏 O(n²)。
质心是几何对象的几何中心点（质量中心）。
public class CentroidOperator : IGeometryOperator<Point>
{
public static CentroidOperator Instance { get; }
public Point Execute(Geometry geometry,
SpatialReference? spatialRef = null);
}
using Esri.Geometry.Core;
using Esri.Geometry.Core.Geometries;
// 多边形的质心
var polygon = new Polygon();
polygon.AddRing(new List<Point>
{
new Point(0, 0),
new Point(10, 0),
new Point(10, 10),
new Point(0, 10),
new Point(0, 0)
});
var centroid = GeometryEngine.Centroid(polygon);
Console.WriteLine($"质心：({centroid.X}, {centroid.Y})"); // (5, 5)
// 多点的质心（平均值）
var multiPoint = new MultiPoint();
multiPoint.Add(new Point(0, 0));
multiPoint.Add(new Point(10, 0));
multiPoint.Add(new Point(10, 10));
multiPoint.Add(new Point(0, 10));
var mpCentroid = GeometryEngine.Centroid(multiPoint);
Console.WriteLine($"多点质心：({mpCentroid.X}, {mpCentroid.Y})"); // (5, 5)
// 三角形的质心
var triangle = new Polygon();
triangle.AddRing(new List<Point>
{
new Point(0, 0),
new Point(6, 0),
new Point(3, 6),
new Point(0, 0)
});
var triangleCentroid = GeometryEngine.Centroid(triangle);
Console.WriteLine($"三角形质心：({triangleCentroid.X}, {triangleCentroid.Y})"); // (3, 2)
public Point Execute(Geometry geometry, SpatialReference? spatialRef = null)
{
if (geometry.IsEmpty)
return new Point();
switch (geometry.Type)
{
case GeometryType.Point:
return (Point)geometry;
case GeometryType.MultiPoint:
return CalculateMultiPointCentroid((MultiPoint)geometry);
case GeometryType.Polygon:
return CalculatePolygonCentroid((Polygon)geometry);
case GeometryType.Envelope:
return ((Envelope)geometry).Center;
default:
// 对于其他类型，返回包络的中心
return geometry.GetEnvelope().Center;
}
}
private Point CalculateMultiPointCentroid(MultiPoint multiPoint)
{
double sumX = 0, sumY = 0;
int count = 0;
foreach (var point in multiPoint.GetPoints())
{
sumX += point.X;
sumY += point.Y;
count++;
}
return new Point(sumX / count, sumY / count);
}
private Point CalculatePolygonCentroid(Polygon polygon)
{
// 使用多边形质心公式
double sumX = 0, sumY = 0, sumArea = 0;
foreach (var ring in polygon.GetRings())
{
for (int i = 0; i < ring.Count - 1; i++)
{
double cross = ring[i].X * ring[i + 1].Y - ring[i + 1].X * ring[i].Y;
sumX += (ring[i].X + ring[i + 1].X) * cross;
sumY += (ring[i].Y + ring[i + 1].Y) * cross;
sumArea += cross;
}
}
double area = sumArea / 2;
return new Point(sumX / (6 * area), sumY / (6 * area));
}
边界操作返回几何对象的边界几何。根据 OGC 规范：
public class BoundaryOperator : IGeometryOperator<Geometry>
{
public static BoundaryOperator Instance { get; }
public Geometry Execute(Geometry geometry,
SpatialReference? spatialRef = null);
}
using Esri.Geometry.Core;
using Esri.Geometry.Core.Geometries;
// 点的边界是空
var point = new Point(10, 20);
var pointBoundary = GeometryEngine.Boundary(point);
Console.WriteLine($"点边界为空：{pointBoundary.IsEmpty}"); // true
// 折线的边界是端点
var polyline = new Polyline();
polyline.AddPath(new List<Point>
{
new Point(0, 0),
new Point(10, 10),
new Point(20, 0)
});
var lineBoundary = GeometryEngine.Boundary(polyline);
if (lineBoundary is MultiPoint boundaryPoints)
{
Console.WriteLine($"折线边界点数：{boundaryPoints.Count}"); // 2（起点和终点）
}
// 多边形的边界是折线
var polygon = new Polygon();
polygon.AddRing(new List<Point>
{
new Point(0, 0),
new Point(10, 0),
new Point(10, 10),
new Point(0, 10),
new Point(0, 0)
});
var polyBoundary = GeometryEngine.Boundary(polygon);
if (polyBoundary is Polyline boundaryLine)
{
Console.WriteLine($"多边形边界长度：{boundaryLine.Length}"); // 40
}
概化操作通过删除顶点来简化几何对象，同时保持其总体形状。与 Simplify 类似，但参数含义不同：
public class GeneralizeOperator : IGeometryOperator<Geometry>
{
public static GeneralizeOperator Instance { get; }
public Geometry Execute(Geometry geometry, double maxDeviation,
SpatialReference? spatialRef = null);
}
using Esri.Geometry.Core;
using Esri.Geometry.Core.Geometries;
var polyline = new Polyline();
polyline.AddPath(new List<Point>
{
new Point(0, 0),
new Point(1, 0.5),
new Point(2, 0),
new Point(3, 0.3),
new Point(4, 0),
new Point(5, 1),
new Point(6, 0)
});
Console.WriteLine($"原始点数：{polyline.GetPath(0).Count}"); // 7
var generalized = GeometryEngine.Generalize(polyline, 0.6);
if (generalized is Polyline genLine)
{
Console.WriteLine($"概化后点数：{genLine.GetPath(0).Count}"); // 减少
}
密化操作在几何对象的线段上添加额外的顶点，确保没有线段超过指定的最大长度。这是概化的逆操作。
应用场景：
public class DensifyOperator : IGeometryOperator<Geometry>
{
public static DensifyOperator Instance { get; }
public Geometry Execute(Geometry geometry, double maxSegmentLength,
SpatialReference? spatialRef = null);
}
using Esri.Geometry.Core;
using Esri.Geometry.Core.Geometries;
// 简单的两点折线
var polyline = new Polyline();
polyline.AddPath(new List<Point>
{
new Point(0, 0),
new Point(10, 0) // 长度为 10 的线段
});
Console.WriteLine($"原始点数：{polyline.GetPath(0).Count}"); // 2
// 密化，最大线段长度为 2
var densified = GeometryEngine.Densify(polyline, 2);
if (densified is Polyline denLine)
{
Console.WriteLine($"密化后点数：{denLine.GetPath(0).Count}"); // 6
// 点：(0,0), (2,0), (4,0), (6,0), (8,0), (10,0)
}
// 多边形密化
var square = new Polygon();
square.AddRing(new List<Point>
{
new Point(0, 0),
new Point(10, 0),
new Point(10, 10),
new Point(0, 10),
new Point(0, 0)
});
var densifiedSquare = GeometryEngine.Densify(square, 3);
private List<Point> DensifyPath(IReadOnlyList<Point> path, double maxLength)
{
var result = new List<Point>();
for (int i = 0; i < path.Count - 1; i++)
{
result.Add(path[i]);
var start = path[i];
var end = path[i + 1];
double length = start.Distance(end);
if (length > maxLength)
{
// 计算需要插入的点数
int numSegments = (int)Math.Ceiling(length / maxLength);
for (int j = 1; j < numSegments; j++)
{
double t = (double)j / numSegments;
result.Add(new Point(
start.X + t * (end.X - start.X),
start.Y + t * (end.Y - start.Y)
));
}
}
}
result.Add(path[path.Count - 1]);
return result;
}
裁剪操作将几何对象裁剪到指定的包络矩形范围内。常用于视口裁剪和数据范围限制。
public class ClipOperator : IGeometryOperator<Geometry>
{
public static ClipOperator Instance { get; }
public Geometry Execute(Geometry geometry, Envelope clipEnvelope);
}
using Esri.Geometry.Core;
using Esri.Geometry.Core.Geometries;
// 创建裁剪范围
var clipEnvelope = new Envelope(0, 0, 50, 50);
// 裁剪点
var pointInside = new Point(25, 25);
var pointOutside = new Point(100, 100);
var clippedIn = GeometryEngine.Clip(pointInside, clipEnvelope); // 返回原点
var clippedOut = GeometryEngine.Clip(pointOutside, clipEnvelope); // 返回空点
// 裁剪折线（Cohen-Sutherland 算法）
var polyline = new Polyline();
polyline.AddPath(new List<Point>
{
new Point(-10, 25), // 裁剪区外
new Point(25, 25), // 裁剪区内
new Point(75, 25) // 裁剪区外
});
var clippedLine = GeometryEngine.Clip(polyline, clipEnvelope);
// 结果：从 (0, 25) 到 (50, 25) 的线段
// 区域码定义
private const int INSIDE = 0; // 0000
private const int LEFT = 1; // 0001
private const int RIGHT = 2; // 0010
private const int BOTTOM = 4; // 0100
private const int TOP = 8; // 1000
private int ComputeOutCode(double x, double y, Envelope clip)
{
int code = INSIDE;
if (x < clip.XMin) code |= LEFT;
else if (x > clip.XMax) code |= RIGHT;
if (y < clip.YMin) code |= BOTTOM;
else if (y > clip.YMax) code |= TOP;
return code;
}
private Line? ClipLine(Point p1, Point p2, Envelope clip)
{
int outcode1 = ComputeOutCode(p1.X, p1.Y, clip);
int outcode2 = ComputeOutCode(p2.X, p2.Y, clip);
double x1 = p1.X, y1 = p1.Y;
double x2 = p2.X, y2 = p2.Y;
while (true)
{
if ((outcode1 | outcode2) == 0)
{
// 两点都在内部
return new Line(new Point(x1, y1), new Point(x2, y2));
}
else if ((outcode1 & outcode2) != 0)
{
// 线段完全在外部
return null;
}
else
{
// 需要裁剪
int outcodeOut = outcode1 != 0 ? outcode1 : outcode2;
double x, y;
if ((outcodeOut & TOP) != 0)
{
x = x1 + (x2 - x1) * (clip.YMax - y1) / (y2 - y1);
y = clip.YMax;
}
else if ((outcodeOut & BOTTOM) != 0)
{
x = x1 + (x2 - x1) * (clip.YMin - y1) / (y2 - y1);
y = clip.YMin;
}
else if ((outcodeOut & RIGHT) != 0)
{
y = y1 + (y2 - y1) * (clip.XMax - x1) / (x2 - x1);
x = clip.XMax;
}
else
{
y = y1 + (y2 - y1) * (clip.XMin - x1) / (x2 - x1);
x = clip.XMin;
}
// 更新端点
if (outcodeOut == outcode1)
{
x1 = x; y1 = y;
outcode1 = ComputeOutCode(x1, y1, clip);
}
else
{
x2 = x; y2 = y;
outcode2 = ComputeOutCode(x2, y2, clip);
}
}
}
}
偏移操作创建几何对象的偏移版本。正值向外偏移，负值向内偏移。
public class OffsetOperator : IGeometryOperator<Geometry>
{
public static OffsetOperator Instance { get; }
public Geometry Execute(Geometry geometry, double distance,
SpatialReference? spatialRef = null);
}
using Esri.Geometry.Core;
using Esri.Geometry.Core.Geometries;
// 多边形偏移
var polygon = new Polygon();
polygon.AddRing(new List<Point>
{
new Point(0, 0),
new Point(100, 0),
new Point(100, 100),
new Point(0, 100),
new Point(0, 0)
});
// 向外偏移 10
var offsetPolygon = GeometryEngine.Offset(polygon, 10);
// 向内偏移 10
var insetPolygon = GeometryEngine.Offset(polygon, -10);
本章详细介绍了 geometry-api-net 的几何运算操作符：
| 操作符 | 功能 | 核心算法 |
|---|---|---|
| Buffer | 创建缓冲区 | 几何扩展 |
| ConvexHull | 计算凸包 | Graham 扫描 |
| Area | 计算面积 | 鞋带公式 |
| Length | 计算长度 | 欧几里得距离 |
| Simplify | 简化几何 | Douglas-Peucker |
| Centroid | 计算质心 | 多边形质心公式 |
| Boundary | 获取边界 | OGC 规范 |
| Generalize | 概化几何 | Douglas-Peucker 变体 |
| Densify | 密化几何 | 线段插值 |
| Clip | 裁剪几何 | Cohen-Sutherland |
| Offset | 偏移几何 | 几何偏移 |
这些操作符是进行空间分析的核心工具。在下一章中，我们将学习集合操作符，用于计算几何对象之间的并集、交集和差集。
此内容由惯性聚合(RSS阅读器)自动聚合整理，仅供阅读参考。 原文来自 — 版权归原作者所有。