前言

        多边形裁剪是一种计算几何技术，用于确定一个多边形在另一个多边形内的部分。这在计算机图形学、地理信息系统以及各种需要可见性和交集计算的应用中非常有用。

基本概念

        多边形裁剪的基本思想是取两个多边形：一个是被裁剪的多边形（即目标多边形），另一个是裁剪多边形（定义裁剪区域的多边形）。目标是找到这两个多边形的交集，结果是一个新的多边形，表示目标多边形在裁剪多边形内的区域。

常见的多边形裁剪算法

1. Sutherland-Hodgman 算法：适用于简单多边形的裁剪，逐边处理。
2. Weiler-Atherton 算法：适用于复杂多边形的裁剪，能够处理自交多边形。
3. Greiner-Hormann 算法：适用于任意多边形的裁剪，支持多种形状的裁剪。
4. Cohen-Sutherland 算法：主要用于线段裁剪，但可以扩展到多边形裁剪。

这里介绍的是Sutherland-Hodgman算法。

Sutherland-Hodgman 算法概念

        Sutherland-Hodgman 算法是一种逐边裁剪算法，主要用于将一个多边形裁剪到另一个多边形。该算法通过检查目标多边形的每个顶点相对于裁剪多边形的边的位置，来决定哪些顶点应该保留在裁剪后的多边形中。

算法原理

        该算法的基本原理是：

• 对于每条裁剪多边形的边，检查目标多边形的每条边的两个端点。
• 根据端点的位置（在内或在外）决定是否将端点添加到新的多边形中。
• 如果一个端点在内而另一个在外，则计算它们与裁剪边的交点，并将交点添加到新多边形中。

算法步骤

        1、初始化：准备目标多边形和裁剪多边形。

        2、遍历裁剪边：对于每条裁剪多边形的边：

                 2.1、初始化一个新的列表来存储裁剪后的多边形的顶点。

                 2.2、遍历目标多边形的每条边。

                 2.3、对于每条边，检查其两个端点相对于裁剪边的位置。

                 2.4、根据端点的位置，决定是否将顶点添加到新列表中：

                        2.4.1、如果两个端点都在内，则将第二个端点添加到新列表。

                        2.4.2、如果一个端点在内，另一个在外，则计算交点并添加。

                        2.4.3、如果两个端点都在外，则不添加。

        3、更新目标多边形：处理完所有裁剪边后，新列表成为下一次迭代的目标多边形。

        4、输出结果：处理完所有裁剪边后，最终列表表示裁剪后的多边形。      

详细代码  

以下是详细的代码步骤。

public class Point2D  
{  
    public double X { get; set; }  
    public double Y { get; set; }  

    public Point2D(double x, double y)  
    {  
        X = x;  
        Y = y;  
    }  
}  

public class Polygon  
{  
    public List<Point2D> Vertices { get; set; }  

    public Polygon(List<Point2D> vertices)  
    {  
        Vertices = vertices;  
    }  
}  

class PolygonClipping  
{  
    // 检查一个点是否在裁剪边内  
    private static bool IsInside(Point2D point, Point2D edgeStart, Point2D edgeEnd)  
    {  
        // 使用叉积判断点是否在边的左侧  
        return (edgeEnd.X - edgeStart.X) * (point.Y - edgeStart.Y) > (edgeEnd.Y - edgeStart.Y) * (point.X - edgeStart.X);  
    }  

    // 计算两条线的交点  
    private static Point2D ComputeIntersection(Point2D p1, Point2D p2, Point2D edgeStart, Point2D edgeEnd)  
    {  
        // 计算交点的公式  
        double denom = (edgeEnd.X - edgeStart.X) * (p2.Y - p1.Y) - (p2.X - p1.X) * (edgeEnd.Y - edgeStart.Y);  
        if (denom == 0) return null; // 线平行  

        double ua = ((p2.X - p1.X) * (edgeStart.Y - p1.Y) - (p2.Y - p1.Y) * (edgeStart.X - p1.X)) / denom;  
        return new Point2D(edgeStart.X + ua * (edgeEnd.X - edgeStart.X), edgeStart.Y + ua * (edgeEnd.Y - edgeStart.Y));  
    }  

    // 执行 Sutherland-Hodgman 多边形裁剪算法  
    public static Polygon SutherlandHodgman(Polygon subjectPolygon, Polygon clippingPolygon)  
    {  
        // 初始化输出多边形为目标多边形  
        List<Point2D> outputPolygon = new List<Point2D>(subjectPolygon.Vertices);  

        // 遍历裁剪多边形的每条边  
        for (int i = 0; i < clippingPolygon.Vertices.Count; i++)  
        {  
            Point2D edgeStart = clippingPolygon.Vertices[i];  
            Point2D edgeEnd = clippingPolygon.Vertices[(i + 1) % clippingPolygon.Vertices.Count];  
            List<Point2D> newOutputPolygon = new List<Point2D>();  

            // 遍历目标多边形的每条边  
            for (int j = 0; j < outputPolygon.Count; j++)  
            {  
                Point2D currentPoint = outputPolygon[j];  
                Point2D previousPoint = outputPolygon[j == 0 ? outputPolygon.Count - 1 : j - 1];  

                // 检查当前点是否在裁剪边内  
                if (IsInside(currentPoint, edgeStart, edgeEnd))  
                {  
                    // 如果前一个点在外，则添加交点  
                    if (!IsInside(previousPoint, edgeStart, edgeEnd))  
                    {  
                        Point2D intersection = ComputeIntersection(previousPoint, currentPoint, edgeStart, edgeEnd);  
                        if (intersection != null)  
                            newOutputPolygon.Add(intersection);  
                    }  
                    // 添加当前点  
                    newOutputPolygon.Add(currentPoint);  
                }  
                // 如果前一个点在内，则添加交点  
                else if (IsInside(previousPoint, edgeStart, edgeEnd))  
                {  
                    Point2D intersection = ComputeIntersection(previousPoint, currentPoint, edgeStart, edgeEnd);  
                    if (intersection != null)  
                        newOutputPolygon.Add(intersection);  
                }  
            }  

            // 更新输出多边形为新生成的多边形  
            outputPolygon = newOutputPolygon;  
        }  

        return new Polygon(outputPolygon);  
    }  

    // 示例用法  
    public static void Main()  
    {  
        // 定义目标多边形和裁剪多边形  
        Polygon subjectPolygon = new Polygon(new List<Point2D>  
        {  
            new Point2D(1.0, 1.0),  
            new Point2D(4.0, 1.0),  
            new Point2D(4.0, 4.0),  
            new Point2D(1.0, 4.0)  
        });  

        Polygon clippingPolygon = new Polygon(new List<Point2D>  
        {  
            new Point2D(2.0, 2.0),  
            new Point2D(3.0, 2.0),  
            new Point2D(3.0, 3.0),  
            new Point2D(2.0, 3.0)  
        });  

        // 执行裁剪  
        Polygon clippedPolygon = SutherlandHodgman(subjectPolygon, clippingPolygon);  

        // 输出裁剪后的多边形  
        Console.WriteLine("裁剪后的多边形:");  
        foreach (var point in clippedPolygon.Vertices)  
        {  
            Console.WriteLine($"({point.X}, {point.Y})");  
        }  
    }  
}  

总结

        Sutherland-Hodgman 算法是一种有效的多边形裁剪方法，适用于简单多边形的裁剪。通过逐边处理，算法能够准确地确定目标多边形在裁剪多边形内的部分。该算法的实现相对简单，适合用于计算机图形学和几何处理等领域。

 更多学习内容，可关注公众号：

 

以上内容为个人测试过程的记录，供大家参考。

内容如有错欢迎批评指正，谢谢！！！！