计算机图形学 | Weiler-Atherton多边形裁剪

简介

Weiler-Atherton多边形裁剪是计算机图形学中的一种算法，用于将一个多边形裁剪为另一个多边形的内部或外部部分，在计算机图形学中常用于裁剪视窗和多边形的算法中。

该算法的基本思想是，将被裁剪和裁剪多边形分别看作是依次经过的点的集合，然后将这两个点集合合并，通过判断交点的位置和顺序，获得裁剪后多边形的顶点。

实现

以下是一个基于Python的Weiler-Atherton多边形裁剪算法的实现，包括了两个多边形的生成、展示和裁剪功能。

from PIL import Image, ImageDraw
from typing import List, Tuple

class Polygon:
    def __init__(self, vertices: List[Tuple[int, int]]):
        self.vertices = vertices

    def __repr__(self):
        return str(self.vertices)

    def inside(self, point: Tuple[int, int]) -> bool:
        x, y = point
        inside = False
        for i in range(len(self.vertices)):
            x1, y1 = self.vertices[i]
            x2, y2 = self.vertices[(i+1)%len(self.vertices)]
            if (y1 > y) != (y2 > y) and (x < (x2 - x1) * (y - y1) / (y2 - y1) + x1):
                inside = not inside
        return inside

    def intersect(self, edge: Tuple[Tuple[int, int], Tuple[int, int]]) -> Tuple[int, int]:
        (A, B), (C, D) = edge, (self.vertices[-1], self.vertices[0])
        for i in range(len(self.vertices)-1):
            A, B, C, D = C, D, self.vertices[i], self.vertices[i+1]
            if (B[1]-A[1])*(C[0]-D[0]) - (B[0]-A[0])*(C[1]-D[1]) == 0:
                continue
            intersect_x = ((B[0]-A[0])*(C[0]*D[1]-C[1]*D[0]) - (A[0]*B[1]-A[1]*B[0])*(C[0]-D[0]))\
                            / ((B[1]-A[1])*(C[0]-D[0]) - (B[0]-A[0])*(C[1]-D[1]))
            intersect_y = ((B[1]-A[1])*(C[1]*D[0]-C[0]*D[1]) - (A[0]*B[1]-A[1]*B[0])*(C[1]-D[1]))\
                            / ((B[1]-A[1])*(C[0]-D[0]) - (B[0]-A[0])*(C[1]-D[1]))
            if min(A[0], B[0]) < intersect_x < max(A[0], B[0]) and min(A[1], B[1]) < intersect_y < max(A[1], B[1])\
                and min(C[0], D[0]) < intersect_x < max(C[0], D[0]) and min(C[1], D[1]) < intersect_y < max(C[1], D[1]):
                return intersect_x, intersect_y
        return None

    def clip(self, clip_polygon) -> List[Tuple[int, int]]:
        t_vertices = clip_polygon.vertices.copy()
        t_vertices.append(t_vertices[0])
        s_vertices = self.vertices.copy()
        s_vertices.append(s_vertices[0])
        intersection_points = []
        for i in range(len(t_vertices)-1):
            for j in range(len(s_vertices)-1):
                p = clip_polygon.intersect((t_vertices[i], t_vertices[i+1]))
                if p is not None:
                    intersection_points.append((i, p))
                p = self.intersect((s_vertices[j], s_vertices[j+1]))
                if p is not None:
                    intersection_points.append((j, p))
        if not intersection_points:
            return None
        intersection_points.sort(key=lambda x: x[0])
        new_vertices = []
        for i in range(len(intersection_points)-1):
            segment = (intersection_points[i][1], intersection_points[i+1][1])
            mid = int(intersection_points[i][0] * 0.5 + intersection_points[i+1][0] * 0.5)
            if clip_polygon.inside(segment[0]):
                new_vertices.append(segment[0])
            for k in range(mid, len(s_vertices)-1):
                new_vertices.append(s_vertices[k])
            for k in range(mid, 0, -1):
                new_vertices.append(s_vertices[k])
        return new_vertices

def generate_polygon(size: Tuple[int, int], max_vertices: int = 10, min_distance: int = 20) -> List[Tuple[int, int]]:
    w, h = size
    center_x, center_y = w//2, h//2
    start_angle = random.uniform(0, 2*math.pi)
    vertices = []
    while len(vertices) < max_vertices:
        angle = random.uniform(start_angle, start_angle + 2*math.pi)
        distance = random.uniform(min_distance, w//2-10)
        x, y = distance * math.cos(angle) + center_x, distance * math.sin(angle) + center_y
        if not vertices or math.dist((x, y), vertices[-1]) > min_distance:
            vertices.append((int(x), int(y)))
        start_angle = angle
    return vertices

def show_polygon(polygon: List[Tuple[int, int]], screen_size: Tuple[int, int] = (200, 200), fill: str = None) -> None:
    img = Image.new("RGB", screen_size, color='white')
    draw = ImageDraw.Draw(img)
    draw.polygon(polygon, fill=fill, outline='black')
    img.show()

def show_polygons(p1: Polygon, p2: Polygon, screen_size: Tuple[int, int] = (200, 200), fill1: str = None, fill2: str = None) -> None:
    img = Image.new("RGB", screen_size, color='white')
    draw = ImageDraw.Draw(img)
    draw.polygon(p1.vertices, fill=fill1, outline='black')
    draw.polygon(p2.vertices, fill=fill2, outline='black')
    img.show()  

def clip_polygons(p1: Polygon, p2: Polygon, screen_size: Tuple[int, int] = (200, 200), fill1: str = None, fill2: str = None) -> None:
    show_polygons(p1, p2, screen_size, fill1, fill2)
    clipped_vertices = p1.clip(p2)
    if clipped_vertices:
        show_polygon(clipped_vertices, screen_size, fill='gray')
    else:
        print('No intersection found')

p1 = Polygon([(20, 50), (150, 50), (150, 150), (20, 150)])
p2 = Polygon([(100, 20), (180, 80), (120, 180)])
clip_polygons(p1, p2)

结论

Weiler-Atherton多边形裁剪算法是一种用于计算机图形学中多边形裁剪的算法，可以将两个多边形的顶点集合通过判断该多边形的内部还是外部，裁剪为一个新的多边形。该算法在多边形裁剪问题中非常实用，容易实现，同时能处理各种情况。