计算几何实验（一）：简单多边形的三角剖分算法

已于 2023-10-20 10:34:19 修改
阅读量550 收藏 7
点赞数 3
分类专栏： 计算几何 文章标签： 算法 几何学
于 2023-10-11 19:34:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/njw21377128/article/details/133776866
版权

预备知识

概念主要参考了Discrete and Computational Geometry 这本书。每一个概念我都会给出原书中的陈述以及我自己翻译的版本。

简单多边形：多边形P是平面上的封闭区域，以形成不与自身相交的封闭曲线的有限线段集为边界。

simple polygon: A polygon P is the closed region of the plane bounded by a finite collection of line segments forming a closed curve that does not intersect itself.

多边形的边界：多边形的顶点和边的集合是多边形的边界，记作\partial P

boundary of polygon： The set of vertices and edges of P is called the boundary of the polygon, denoted as ∂P.

多边形约当曲线定理：一个多边形的边界把平面分成两部分。特别地,R^2\backslash \partial P的两个部分是有界的内部和无界的外部。

Polygonal Jordan Curve: The boundary ∂P of a polygon P partitions the plane into two parts. In particular, the two components of R^2\backslash \partial P are the bounded interior and the unbounded exterior.

对角线：多边形的对角线是一条连接多边形P两个顶点且完全在P的内部，不与多边形的边界\partial P 相交除了在它的两个端点处的线段。

diagonal： A diagonal of a polygon is a line segment connecting two vertices of P and lying in the interior of P, not touching ∂P except at its endpoints.

三角剖分：多边形P的三角剖分是把P分解成三角形，要求分解时添加的对角线不相交且数量最多。

triangulation: A triangulation of a polygon P is a decomposition of P into triangles by a maximal set of noncrossing diagonals.

多边形的耳朵：三个连续的顶点a,b,c形成一个多边形的耳朵，如果ac是该多边形的对角线。

Ears: Three consecutive vertices a, b, c form an ear of a polygon if ac is a diagonal of the polygon.

双耳定理： 每一个具有超过三个顶点的多边形有至少两个耳朵。

Every polygon with more than three vertices has at least two ears.

算法思路分析

考虑到多边形的耳朵的特殊性，我们可以通过对多边形一直切耳朵来实现三角剖分。

多边形切去一个耳朵仍然是多边形，所以该算法可以写成递归算法。

除了三角形外每个多边形都有至少两个耳朵，所以递归算法的出口就是三角形。

所以这里的重点是如何识别多边形的耳朵，按照定义，我们只要枚举所有连续的三个顶点a,b,c判断两个不相邻的顶点连接而成的线段ac是不是对角线就可以了。

两顶点连线ac有四种可能的情况（以下情况都省略掉ac的端点）：

  • 完全在多边形内部，是对角线

  • 完全在多边形外部，不是对角线

  • 部分在多边形内部，部分在多边形外部，不是对角线（包括与多边形的边界相交于顶点处的情况）

  • 与多边形的边界完全重合（这部分是新增的，对应于b是平点，即在该点处内角为180度）

第3种情况，可以通过判断ac是否与多边形的边界相交（不包括ac的端点）来判别。

如果ac不与多边形的边界相交，那么可以随意取ac上一点（不包括端点，下同），通过判断该点是否在多边形的内部来判别第1种和第2种情况，如果在多边形内部，则整条线段都在多边形内部，如果在多边形外部，则整条线段都在多边形外部。

第4种情况，只需要单独判断是否b为平点即可，只需要判断ab和bc是否平行。注意，当多边形为带平点的四边形时，需要额外考虑算法实现中的细节。例如：

特殊四边形

如果只判断ab和bc是否平行是不足以判断ac是否是对角线的，还需要判断ad和dc是否平行。

所以现在需要实现的算法主要有

  • 线段的相交判定算法（包括端点）

  • 一个点是否在多边形的内部的判定算法（不需要判断该点是否在多边形的边界，因为ac不与多边形的边界相交）

  • 针对第4种情况的线段平行判定算法

这里算法实现主要参考了《算法设计与分析》第2版 李春葆 中的计算几何部分。

判定点是否在多边形内部的算法大致思路：

过该点作一条射线，如果射线与多边形相交的点的个数是奇数，那它在多边形内部，如果是偶数，则在多边形外部。为了方便，我们一般使用水平向右的射线。

这里需要考虑一些算法实现方面的细节。

在判断射线与多边形的相交点的个数时，我们肯定会对多边形的每一条边都进行判断。

如果射线与多边形交于顶点，如何判断交点的个数？

有两种情况：

相交顶点的邻接边在射线的同一侧

相交顶点的邻接边在射线的两侧

对于第1种情况，两条邻接边记成有偶数个交点即可

对于第2种情况，两条邻接边记成有奇数个交点即可

还有可能射线与多边形的水平边相交，如何判断？

射线与水平边相交

此时射线必然与另外两条边的端点相交，忽视掉水平边（即不计入点的个数），然后转化成之前的情况即可。

《算法设计与分析》中的判断点是否在多边形内部的算法实现了同样的效果。

算法代码

# author:njw

import random
import time
import matplotlib.pyplot as plt


# 点类
class Point:
    def __init__(self,x,y):
        self.x=x
        self.y=y
# 线段类
class LineSegment:
    def __init__(self,point1,point2):
        self.point1=point1
        self.point2=point2
#   求两个向量的点积
def DotProduct(point1,point2):
    return point1.x*point2.x+point1.y*point2.y

# 求两个向量的叉积
def CrossProduct(point1,point2):
    return point1.x*point2.y-point1.y*point2.x

# 判断两条线段是否平行(p1p2,p2p3)
def IsParallel(point1,point2,point3):
    return CrossProduct(Point(point2.x-point1.x,point2.y-point1.y),Point(point3.x-point2.x,point3.y-point2.y))==0

# 判断两线段的相对方向
def Direction(point1,point2,point3):
    d = CrossProduct(Point(point3.x-point1.x,point3.y-point1.y),Point(point2.x-point1.x,point2.y-point1.y))
    if d>0:
        return 1
    elif d<0:
        return -1
    else:
        return 0

# 判断一个点是否在线段上
def OnSegment(point1,point2,point3):
    return CrossProduct(Point(point2.x-point1.x,point2.y-point1.y),Point(point3.x-point1.x,point3.y-point1.y))==0 and \
    DotProduct(Point(point2.x-point1.x,point2.y-point1.y),Point(point3.x-point1.x,point3.y-point1.y))<=0

# TODO:判断两线段是否相交
# 判断两线段是否相交
def IsIntersect(lineSegment1,lineSegment2):
    d1 = Direction(lineSegment2.point1,lineSegment2.point2,lineSegment1.point1)
    d2 = Direction(lineSegment2.point1,lineSegment2.point2,lineSegment1.point2)
    d3 = Direction(lineSegment1.point1,lineSegment1.point2,lineSegment2.point1)
    d4 = Direction(lineSegment1.point1,lineSegment1.point2,lineSegment2.point2)
    if d1*d2<0 and d3*d4<0:
        return True
    elif d1==0 and OnSegment(lineSegment1.point1,lineSegment2.point1,lineSegment2.point2):
        return True
    elif d2==0 and OnSegment(lineSegment1.point2,lineSegment2.point1,lineSegment2.point2):
        return True
    elif d3==0 and OnSegment(lineSegment2.point1,lineSegment1.point1,lineSegment1.point2):
        return True
    elif d4==0 and OnSegment(lineSegment2.point2,lineSegment1.point1,lineSegment1.point2):
        return True
    else:
        return False


# 初始化多边形时，点的列表不包括初始点，连接点的顺序按照自然顺序
# 如果自然顺序连接不成多边形，则改变点的顺序
# 多边形类
class Polygon:
    def __init__(self,points):
        self.points=points
        self.n = len(points)
        self.edges=[]
        for i in range(self.n-1):
            self.edges.append(LineSegment(points[i],points[i+1]))
        self.edges.append(LineSegment(points[-1],points[0]))
    #     画多边形
    def plot(self):
        x=[]
        y=[]
        for point in self.points:
            x.append(point.x)
            y.append(point.y)
        x.append(self.points[0].x)
        y.append(self.points[0].y)
        plt.plot(x,y)
        # plt.plot([1,2],[1,2])
        plt.show()
    #     算多边形的面积
    def area(self):
        area=0
        for i in range(self.n):
            area+=(self.points[i].x*self.points[(i+1)%self.n].y-self.points[(i+1)%self.n].x*self.points[i].y)/2
        return abs(area)
#     TODO：判断点是否在多边形内部
#    判断点是否在多边形内部，不包括边界
#    对该点作水平向右的射线，判断射线与多边形的交点个数，如果是奇数个，则在多边形内部，否则在多边形外部
    def IsInside(self,point):
        cnt=0
        for i in range(self.n):
            if self.points[i%self.n].y == self.points[(i+1)%self.n].y:
                continue
            if point.y < min(self.points[i%self.n].y,self.points[(i+1)%self.n].y):
                continue
            if point.y >= self.points[i%self.n].y and point.y >= self.points[(i+1)%self.n].y:
                continue
            x = (point.y - self.points[i%self.n].y)*(self.points[(i+1)%self.n].x - self.points[i%self.n].x)/(self.points[(i+1)%self.n].y - self.points[i%self.n].y) + self.points[i%self.n].x
            if x > point.x:
                cnt+=1

        # # special用来记录射线与多边形的交点是顶点以及水平边的特殊情况，在special中的边在最简单的情况中不需要再判断
        # special=[]
        # # 考虑到射线与多边形的交点可能是顶点，该情况比较特殊，单独提前判断
        # # 第一种是判断水平边的情况
        # for i in range(self.n):
        #       # 如果射线与多边形的交点是顶点，则通过判断这个顶点的前后两个边是否位于射线的两侧来确定cnt加多少，同侧加2，两侧加1
        #       # 对于水平边，忽视，考虑与水平边相连的两条边是否在射线的两侧，同侧加2，两侧加1
        #
        #       if point.y == self.points[i%self.n].y and point.y == self.points[(i+1)%self.n].y and point.x < self.points[i%self.n].x and point.x < self.points[(i+1)%self.n].x:
        #             if (self.points[(i-1)%self.n].y - point.y)*(self.points[(i+2)%self.n].y - point.y) > 0:
        #                 cnt+=2
        #             else:
        #                 cnt+=1
        #             #     记录下有关顶点和边，避免重复计算
        #             special.append(i%self.n)
        #             special.append((i-1)%self.n)
        #             special.append((i+1)%self.n)
        # # 第二种是射线与多边形交点是顶点的情况，但排除了水平边的情况
        # for i in range(self.n):
        #     if i not in special:
        #         if point.y == self.points[i%self.n].y and point.x < self.points[i%self.n].x:
        #             if (self.points[(i-1)%self.n].y - point.y)*(self.points[(i+1)%self.n].y - point.y) > 0:
        #                 cnt+=2
        #             else:
        #                 cnt+=1
        #             special.append(i%self.n)
        #             special.append((i-1)%self.n)
        # # 第三种是最简单的情况，射线与多边形的交点不是顶点
        # for i in range(self.n):
        #     if i not in special:
        #         if self.points[i%self.n].y == self.points[(i+1)%self.n].y:
        #             continue
        #         if point.y < min(self.points[i%self.n].y,self.points[(i+1)%self.n].y):
        #             continue
        #         if point.y > max(self.points[i%self.n].y,self.points[(i+1)%self.n].y):
        #             continue
        #         x = (point.y - self.points[i%self.n].y)*(self.points[(i+1)%self.n].x - self.points[i%self.n].x)/(self.points[(i+1)%self.n].y - self.points[i%self.n].y) + self.points[i%self.n].x
        #         if x > point.x:
        #             cnt+=1
        return cnt%2==1

#    TODO：判断两顶点连线是不是对角线
#  判断两顶点连线是不是对角线（判断连续的三个点形成的线段是不是对角线）
    def IsDiagonal(self,point1,point2):
        # 两顶点连线有三种情况：
        # 1.完全在多边形内部，是对角线
        # 2.完全在多边形外部
        # 3.部分在多边形内部，部分在多边形外部。
        # 第3种情况，可以通过判断连线与多边形的边的相交情况来确定
        # 如果与多边形的边相交大于4次，有可能在多边形外部，此时在连线上任取一点判断是否在多边形内部即可。
        # 正常的对角线与多边形的边相交4次（如果我们对多边形的每一条边都单独判断的话）
        cnt=0
        for edge in self.edges:
            if IsIntersect(edge,LineSegment(point1,point2)):
                cnt+=1
                if cnt>4:
                    return False
        return self.IsInside(Point((point1.x+point2.x)/2,(point1.y+point2.y)/2))

#   TODO：多边形三角剖分算法(递归切耳算法)
#   返回值是对角线的列表
    def triangulation(self):
        diagonal = []
        # 递归出口，三角形的情况
        if self.n == 3:
            return diagonal
        seed = int(time.time())
        permutation = list(range(self.n))
        random.Random(seed).shuffle(permutation)
        # 遍历所有的点，找到一个对角线 或者 采用随机化的方法，随机选取一个点，找到一个对角线
        # for i in range(self.n):
        for i in permutation:
            # 现在考虑一种新的情况，即出现“平点”（在该点处的内角为180度）的情况
            if self.IsDiagonal(self.points[i % self.n], self.points[(i + 2) % self.n]) and IsParallel(self.points[i % self.n], self.points[(i + 1) % self.n], self.points[(i + 2) % self.n]) == False:
                # 还需要考虑四边形有一个平点导致退化成三角形的情况
                if self.n == 4 and IsParallel(self.points[i % self.n], self.points[(i - 1) % self.n], self.points[(i - 2) % self.n]):
                    continue
                diagonal.append(LineSegment(self.points[i % self.n], self.points[(i + 2) % self.n]))
                # 递归求解剩下的多边形
                newpoints = []
                for j in range(self.n):
                    if j != (i + 1) % self.n:
                        newpoints.append(self.points[j])
                newpolygon = Polygon(newpoints)
                diagonal.extend(newpolygon.triangulation())
                # 找到一个对角线就可以了
                break
        return diagonal
    # 把三角剖分的结果画出来
    def plotTriangulation(self):
        diagonal = self.triangulation()
        for edge in diagonal:
            plt.plot([edge.point1.x,edge.point2.x],[edge.point1.y,edge.point2.y])
        self.plot()


if __name__ == '__main__':
    # i.18
    # points = [
    #     Point(0, 0),
    #     Point(10, 7),
    #     Point(12, 3),
    #     Point(20, 8),
    #     Point(13, 17),
    #     Point(10, 12),
    #     Point(12, 14),
    #     Point(14, 9),
    #     Point(8, 10),
    #     Point(6, 14),
    #     Point(10, 15),
    #     Point(7, 18),
    #     Point(0, 16),
    #     Point(1, 13),
    #     Point(3, 15),
    #     Point(5, 8),
    #     Point(-2, 9),
    #     Point(5, 5)
    # ]
    # i.snake
    # points = [
    #     Point(10, 0),
    #     Point(20, 10),
    #     Point(30, 0),
    #     Point(40, 10),
    #     Point(50, 0),
    #     Point(50, 10),
    #     Point(40, 20),
    #     Point(30, 10),
    #     Point(20, 20),
    #     Point(10, 10),
    #     Point(0, 20),
    #     Point(0, 10)
    # ]
    # 正方形
    # points = [
    #     Point(0, 0),
    #     Point(10, 0),
    #     Point(10, 10),
    #     Point(0, 10)
    # ]
    # 带平点的三角形
    # points = [
    #     Point(0, 0),
    #     Point(10, 0),
    #     Point(20, 0),
    #     Point(30, 0),
    #     Point(40, 0),
    #     Point(20, 10),
    # ]
    # 五角星
    # points = [
    #     Point(20.0, 0.0),
    #     Point(8.090169943749475, 5.877852522924732),
    #     Point(6.180339887498949, 19.02113032590307),
    #     Point(-3.0901699437494736, 9.510565162951536),
    #     Point(-16.180339887498945, 11.755705045849465),
    #     Point(-10.0, 1.2246467991473533e-15),
    #     Point(-16.18033988749895, -11.75570504584946),
    #     Point(-3.0901699437494754, -9.510565162951535),
    #     Point(6.180339887498945, -19.021130325903073),
    #     Point(8.090169943749473, -5.877852522924734),
    # ]
    # 六边形
    # points = [
    #     Point(17.320508075688775, 9.999999999999998),
    #     Point(17.32050807568877, -10.000000000000002),
    #     Point(3.673940397442059e-15, -20.0),
    #     Point(-17.320508075688767, -10.000000000000009),
    #     Point(-17.32050807568877, 10.0),
    #     Point(-6.123233995736766e-15, 20.0)
    #
    #
    # ]
    # 特殊的多边形
    points = [
        Point(0, 0),
        Point(50, 0),
        Point(50, 30),
        Point(40, 30),
        Point(40, 20),
        Point(30, 20),
        Point(30, 30),
        Point(20, 30),
        Point(20, 20),
        Point(10, 20),
        Point(10, 30),
        Point(0, 30)
    ]
    #
    # points = [
    #     Point(0, 0),
    #     Point(1, 0.3),
    #     Point(0.7, 0.7),
    #     Point(1, 1),
    #     Point(0.7, 1.3),
    #     Point(0.3, 0.7),
    #     Point(0.3, 1),
    #     Point(0, 1),
    #     Point(-0.3, 0.7),
    #     Point(-0.7, 1),
    #     Point(-1, 1.3),
    #     Point(-1, 0.7),
    # ]
    # 六角星
    # points = [
    #     Point(6, 3),
    #     Point(7, 4),
    #     Point(9, 4),
    #     Point(7.5, 5.5),
    #     Point(9, 7),
    #     Point(7, 7),
    #     Point(6, 8),
    #     Point(5, 7),
    #     Point(3, 7),
    #     Point(4.5, 5.5),
    #     Point(3, 4),
    #     Point(5, 4)
    # ]
    polygon=Polygon(points)
    print(polygon.area())
    # polygon.plot()
    polygon.plotTriangulation()

一些注释：

  • 判定点是否在多边形的内部的算法，作者之前针对特殊情况采用了另一种方法，后来发现书上的原算法就可以实现同样的效果

  • i.18和i.snake都是点的数据集

  • 对于特殊的多边形（某个顶点处的内角为平角），可能不能实现三角剖分（已改进）

  • 多边形初始化时，输入的点集需要保证其自然的顺序（列表顺序）可以连接成为一个多边形，不需要在点集末尾再包括起点

  • 导入了random和time模块，用于三角剖分算法初始化，可以改变随机种子来找到不同的三角剖分方案

  • 代码已同步发布在作者的github仓库计算几何实验代码上，欢迎大家收藏，我会更新许多课程的实验代码，希望能对读者有用

实现效果：

i.18

i.snake
带平点的多边形
递归切耳后会出现平点

最后如果作者有误，欢迎大家交流指正。

小海燕awa
关注
  • 3
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【计算几何】Python：德劳内三角剖分算法 | 利用 scatter 绘制散点图 | 实现外接圆生成 | scipy库的 Dealunay 函数 | 实战: A-B间欧氏距离计算
有道无术, 术尚可求。有术无道, 止于术。
12-21 3073
点集的三角剖分属于计算几何学科范畴，对数值分析、有限元分析与图形学来说是极为重要的一项预处理技术。得益于 Delaunay 三角剖分的独特性，关于点集的很多种几何图都与 Delaunay 三角剖分密切相关，如Voronoi 图，EMST 树，Gabriel 图等。
简单多边形的三角剖分算法
12-17
采用C#语言实现计算几何中简单多边形的三角剖分算法。内容包含源程序，可执行程序，程序运行说明文档和参考图。
复杂多边形的三角剖分
人生海海 山山而川
06-19 2829
详细介绍了通过CGAL对复杂多边形进行三角剖分的过程。
简单多边形的三角剖分（并附带python实现代码）
feibinglh的博客
10-21 3930
简单多边形的三角剖分 1 折线、闭折线，简单闭折现 折线：将平面上一些点的序列连接起来，可以得到一条折线。 如：有点列A1,A2,...,AnA_1,A_2,...,A_nA1​,A2​,...,An​，则将其顺次连接，得到的一条折线。 点列中的点，称为折线的控制点。 闭折线：如果一条折线的起点和终点相同，则称该折线为闭折线。以连续两控制点为端点的线段，称为折线的边。有一个共同端点的边称为相邻边。 如：顺次连接点列A1,A2,...,An,A1A_1,A_2,...,A_n,A_1A1​,A2​,.
多边形三角剖分问题的综述
wokeyia的博客
10-16 1486
多边形三角剖分问题的综述问题描述剖分算法Lawson算法：利用队列的基边算法评价标准Lawson算法：利用队列的基边算法： 问题描述 多边形是由一系列首尾连接的直线段组成的图形。如果在多边形的所有边中，任意选一条边无限延长，其他各边都在此直线的同旁，那么这个多边形就是凸多边形，反之就是凹多边形。 三角剖分是代数拓扑学里最基本的研究方法。我们以平面为例，把平面剖开成一块块碎片，要求满足下面条件：1）每块碎片都是三角形；2）任意两个三角形，要么不相交、要么恰好相交于一条公共边。 Delaunay三角剖分是三角剖
三角剖分算法
weixin_45963815的博客
07-19 7906
目录 一、引言 1、背景 2、研究意义 二、散乱点集剖分算法 1、Lawson算法 2、Bowyer算法 3、算法的优化 4、程序实现 三、三角形剖分算法 1、实现思想 2、代码实现 一、引言 1、背景 本算法来源于美术馆问题，美术馆问题如下：假如有一个凹四边形的美术馆，我们需要在美术馆当中安排尽可能少的警卫，使得他们能观察到美术馆的所有角落，对于一个形状复杂的美术馆（如下图示），至少需要安排多少个警卫呢？这就是著名的美术馆问题（ArtGaller...
C++多边形三角剖分,去耳法等三种算法
03-24
在计算机图形学中，多边形三角剖分是一种将多边形分割成一系列不相交的三角形的技术，这是为了便于在屏幕上渲染和处理复杂的几何形状。本文将深入探讨三种多边形三角剖分方法，包括原始去耳法、优化去耳法以及处理有...
计算几何多边形三角剖分
04-07
多边形三角剖分是计算几何( Computational Geometry)中的经典问题，起源于一个有趣的艺术画廊问题。目前有很多不同的算法实现了对多边形的三角剖分，三角化算法所追求的目标主要有两个：形状匀称和计算速度快。 此...
论文研究-一种快速相容三角剖分算法.pdf
07-22
提出了一种基于凹多边形凸分解的相容三角剖分方法。先将凹边形分解成凸多边形，再对子多边形进行三角剖分，即可实现相容三角剖分。在最坏的情况下添加O（jk)个辅助点，时间复杂度为O(jn n log n jk log n)
三角剖分
dulingwen的博客
08-27 568
1.三角剖分算法的数学理解 2.三角剖分浅析
多边形三角剖分（c++,ue4）
03-20
如何将一个多边形三角化是三维模型中一个比较常见的问题。最初的想法很简单，认为就是以一个点起点连接和它不相邻的点所有三角形就区分完了。这样写完后放到ue4里面测试，开始比较顺利，当但遇到凹多边形时，就发现问题了。着实一想确实有问题，这样只能判断凸多边形，对于凹多边形时不行的。于是乎查询资料，找到这篇文档 ，按照上面的思路一想确实可行，便开始垒代码，写完后已测试，发现一个问题在遇到“+”这种多边形时，移除两个点后发现出现了四点共线的情况。想到的便是先把这些共线点移除，在进行凹凸性的判断。
凸多边形的三角剖分
06-20
设P是一个有n个顶点的凸多边形，P中的弦是P中连接两个非相邻顶点的线段。用P中的(n-3)条弦将P剖分成(n-2)个三角形（如下图所示）。使得(n-3)条弦的长度之和最小的三角形剖分称为最优三角剖分。
多边形分解成三角形
01-10
C语言编写的多边形分解。先画出点，然后右键可以选择把点坐标储存到TXT文件，或者生产多边形。生成多边形后可以分解成三角形。成功通过编译跟运行。文件里面有可以直接运行的程序
多边形的三角剖分
08-28
用C#实现了多边形的三角剖分。画廊问题的实现。
任意多边形的三角剖分可视化实现（先划分成单调多边形，再在单调多边形中做三角剖分）
derbi123123的博客
06-09 3628
多边形三角剖分是计算几何( Computational Geometry)中的经典问题，起源于一个有趣的艺术画廊问题。目前有很多不同的算法实现了对多边形的三角剖分，三角化算法所追求的目标主要有两个：形状匀称和计算速度快，这也决定了多边形三角剖分的两个不同的应用方向。在形状匀称方面，人们对三角化的性质、 形状最优准则及算法进行了深入研究 ，采用较多的是 Delaunay 准则。这些算法在保证形状匀称的前提下，也尽可能考虑了提高计算速度。在有限元分析等许多应用场合三角形匀称是必须的，对单元质量是有一定要求的。但
5047. 多边形三角剖分的最低得分
weixin_39390393的博客
05-05 535
5047. 多边形三角剖分的最低得分 题目难度 Medium 题目描述 给定 N，想象一个凸 N 边多边形，其顶点按顺时针顺序依次标记为 A[0], A[i], …, A[N-1]。 假设您将多边形剖分为 N-2 个三角形。对于每个三角形，该三角形的值是顶点标记的乘积，三角剖分的分数是进行三角剖分后所有 N-2 个三角形的值之和。 返回多边形进行三角剖分后可以得到的最低分。 示例 1： 输入：[1...
简单多边形三角剖分发图留念
dreamcs的专栏
04-30 1182
简单多边形三角剖
凹多边形三角剖分
kingBook928的博客
08-13 1020
https://blog.csdn.net/huangzengman/article/details/77114082 https://www.cnblogs.com/lan-yt/p/9200621.html
计算几何基础：凸多边形三角剖分与面积求解
在计算几何领域，对多边形进行三角剖分是解决许多复杂问题的有效手段，如求面积、判断点在多边形内等。课件以讲解凸多边形为例，因为凸多边形的处理相对简单且有明确的几何特性。 首先，课程提到了计算凸多边形面积...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值