耳切法处理简单多边形三角化

最新推荐文章于 2024-12-31 20:19:39 发布
最新推荐文章于 2024-12-31 20:19:39 发布
阅读量2.8k 收藏 20
点赞数 1
分类专栏： Unity编辑器 Unity脚本
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_27219065/article/details/80250428
版权

耳切法处理简单多边形三角化

三维家装项目遇到一个问题，需要自定义户型，那么就遇到地板那一块是不规则的，而且后期地板还需要贴图，uv也需要处理，网上没找到适合当前项目能用的，就参考文献自己写了个简单的，在自己的项目里已经够用，在此记录一下我的理解和代码

  • 拿到多边形的多有顶点，需要按照一定的顺序，顺时针逆时针都可以，构造双向链表
  • 通过向量叉乘计算所有的凹点和凸点（内角是否大于180）
  • 通过判断其余点是否在一个三角形内，计算出所有耳朵
  • *每次以耳朵为顶点构造三角形进行剔除，每剔除一个就是一个三角形序列
  • 直到剩余顶点数量为3时，说明三角形化已经完成
  • 在三角形化过程中，会出现操作顶点位置，形成的多边形不是简单多边形，需要抓异常进行提示
  • 下面为代码

using System;
using System.Collections.Generic;
using UnityEngine;

namespace PolygonTool {

#region 耳切法对简单多边形进行三角形化

/// <summary>
/// 判断凹点，凸点，耳朵的比较轴
/// </summary>
public enum CompareAxle {
    X,
    Y,
    Z
}

/// <summary>
/// 对多边形处理
/// </summary>
public class Triangulation {

    /// <summary>
    /// 判断凹凸的时候的比对轴
    /// </summary>
    private CompareAxle _compareAxle = CompareAxle.Y;
    /// <summary>
    /// 多边形顶点
    /// </summary>
    private List<Vector3> _polygonVertexs = new List<Vector3>();
    /// <summary>
    /// 顶点序列
    /// </summary>
    private  List<int> _vertexsSequence = new List<int>();
    /// <summary>
    /// 节点管理器
    /// </summary>
    private NodeManager _nodeManager = new NodeManager();

    /// <summary>
    /// 初始化
    /// </summary>
    /// <param name="polygonVertexs">多边形顶点</param>
    public Triangulation(List<Vector3> polygonVertexs) {
        this._polygonVertexs = polygonVertexs;
        _nodeManager.Init(polygonVertexs);
    }

    /// <summary>
    /// 设置比较轴
    /// </summary>
    /// <param name="compareAxle"></param>
    public void SetCompareAxle(CompareAxle compareAxle) {
        this._compareAxle = compareAxle;
    }

    /// <summary>
    /// 获取三角形的顶点序列
    /// </summary>
    public int[] GetTriangles() {
        while(_nodeManager.LinkedListLength >= 3) {
            SplitResult sr = SplitPolygon();
            //
            if(sr == null) {
                return null;
            }
        }
        return _vertexsSequence.ToArray();
    }

    /// <summary>
    /// 计算凹顶点，凸顶点，耳朵
    /// </summary>
    private SplitResult SplitPolygon() {
        //凹点
        List<Node> _concaveVertexs = new List<Node>();
        //凸点
        List<Node> _raisedVertexs = new List<Node>();
        //耳朵
        List<Node> _polygonEars = new List<Node>();
        //起始节点
        Node currentNode = _nodeManager.FirstNode;

        #region 计算凹顶点，凸顶点
        for (int i = 0; i < _nodeManager.LinkedListLength; i++) {

            Vector3 one = currentNode.vertex - currentNode.lastNode.vertex;
            Vector3 two = currentNode.nextNode.vertex - currentNode.vertex;
            Vector3 crossRes = Vector3.Cross(one, two);

            if (_compareAxle == CompareAxle.Y) {
                if (crossRes.y < 0) {
                    _concaveVertexs.Add(currentNode);
                }
                else {
                    _raisedVertexs.Add(currentNode);
                }
            }
            if (_compareAxle == CompareAxle.X) {
                if (crossRes.x < 0) {
                    _concaveVertexs.Add(currentNode);
                }
                else {
                    _raisedVertexs.Add(currentNode);
                }
            }
            if (_compareAxle == CompareAxle.Z) {
                if (crossRes.z < 0) {
                    _concaveVertexs.Add(currentNode);
                }
                else {
                    _raisedVertexs.Add(currentNode);
                }
            }

            _polygonEars.Add(currentNode);
            currentNode = currentNode.nextNode;
        }

        for (int i = 0; i < _concaveVertexs.Count; i++) {
            _polygonEars.Remove(_concaveVertexs[i]);
        }
        #endregion

        #region 计算耳朵
        for (int i = 0; i < _polygonEars.Count; i++) {
            Node earNode = _polygonEars[i];
            Node compareNode = earNode.nextNode.nextNode;
            while(compareNode != earNode.lastNode) {
                bool isIn = VertexIsInTriangle(compareNode.vertex, earNode.lastNode.vertex, earNode.vertex,earNode.nextNode.vertex);
                if (isIn == true) {
                    if (_polygonEars.Contains(_polygonEars[i])) {
                        _polygonEars.Remove(_polygonEars[i]);
                    }
                    break;
                }
                compareNode = compareNode.nextNode;
            }
        }
        #endregion

        #region 打印初始化结果
        //Debug.Log("凸点");
        //for (int i = 0; i < _raisedVertexs.Count; i++) {
        //    Debug.Log(_raisedVertexs[i].id);
        //}

        //Debug.Log("凹点");
        //for (int i = 0; i < _concaveVertexs.Count; i++) {
        //    Debug.Log(_concaveVertexs[i].id);
        //}

        //Debug.Log("耳朵");
        //for (int i = 0; i < _polygonEars.Count; i++) {
        //    Debug.Log(_polygonEars[i].id);
        //}
        #endregion

        //耳朵为空说明不是简单多边形 多边形三角化失败
        if(_polygonEars.Count == 0) {
            return null;
        }

        _vertexsSequence.Add(_polygonEars[0].lastNode.id);
        _vertexsSequence.Add(_polygonEars[0].id);
        _vertexsSequence.Add(_polygonEars[0].nextNode.id);
        _nodeManager.RemoveNode(_polygonEars[0]);
        return new SplitResult(_raisedVertexs, _concaveVertexs, _polygonEars);
    }

    /// <summary>
    /// 计算凹顶点，凸顶点，耳朵
    /// </summary>
    //private SplitResult SplitPolygon(List<Vector3> _polygonVertexs) {

    //    //凹点
    //    List<int> _concaveVertexs = new List<int>();
    //    //凸点
    //    List<int> _raisedVertexs = new List<int>();
    //    //耳朵
    //    List<int> _polygonEars = new List<int>();

    //    #region 计算凹顶点，凸顶点
    //    for (int i = 0; i < _polygonVertexs.Count; i++) {

    //        Vector3 one;
    //        Vector3 two;

    //        if (i == 0) {
    //            one = _polygonVertexs[0] - _polygonVertexs[_polygonVertexs.Count - 1];
    //            two = _polygonVertexs[1] - _polygonVertexs[0];
    //        }
    //        else if (i == _polygonVertexs.Count - 1) {
    //            one = _polygonVertexs[i] - _polygonVertexs[_polygonVertexs.Count - 2];
    //            two = _polygonVertexs[0] - _polygonVertexs[i];
    //        }
    //        else {
    //            one = _polygonVertexs[i] - _polygonVertexs[i - 1];
    //            two = _polygonVertexs[i + 1] - _polygonVertexs[i];
    //        }

    //        Vector3 crossRes = Vector3.Cross(one, two);

    //        if (_compareAxle == CompareAxle.Y) {
    //            if (crossRes.y < 0) {
    //                _concaveVertexs.Add(i);
    //            }
    //            else {
    //                _raisedVertexs.Add(i);
    //            }
    //        }
    //        if (_compareAxle == CompareAxle.X) {
    //            if (crossRes.x < 0) {
    //                _concaveVertexs.Add(i);
    //            }
    //            else {
    //                _raisedVertexs.Add(i);
    //            }
    //        }
    //        if (_compareAxle == CompareAxle.Z) {
    //            if (crossRes.z < 0) {
    //                _concaveVertexs.Add(i);
    //            }
    //            else {
    //                _raisedVertexs.Add(i);
    //            }
    //        }

    //        _polygonEars.Add(i);
    //    }

    //    for (int i = 0; i < _concaveVertexs.Count; i++) {
    //        _polygonEars.Remove(_concaveVertexs[i]);
    //    }
    //    #endregion

    //    #region 计算耳朵
    //    //计算耳朵
    //    for (int i = 0; i < _polygonEars.Count; i++) {
    //        if (_polygonEars[i] == 0) {
    //            for (int j = 0; j < _polygonVertexs.Count; j++) {
    //                if (j == _polygonVertexs.Count - 1 || j == 0 || j == 1) {
    //                    continue;
    //                }
    //                else {
    //                    bool isIn = VertexIsInTriangle(_polygonVertexs[j], _polygonVertexs[_polygonVertexs.Count - 1], _polygonVertexs[0], _polygonVertexs[1]);
    //                    if (isIn == true) {
    //                        if (_polygonEars.Contains(_polygonEars[i])) {
    //                            _polygonEars.Remove(_polygonEars[i]);
    //                        }
    //                    }
    //                }
    //            }
    //        }
    //        else if (_polygonEars[i] == _polygonVertexs.Count - 1) {
    //            for (int j = 0; j < _polygonVertexs.Count; j++) {
    //                if (j == _polygonVertexs.Count - 2 || j == _polygonVertexs.Count - 1 || j == 0) {
    //                    continue;
    //                }
    //                else {
    //                    bool isIn = VertexIsInTriangle(_polygonVertexs[j], _polygonVertexs[_polygonVertexs.Count - 2], _polygonVertexs[_polygonVertexs.Count - 1], _polygonVertexs[0]);
    //                    if (isIn == true) {
    //                        if (_polygonEars.Contains(_polygonEars[i])) {
    //                            _polygonEars.Remove(_polygonEars[i]);
    //                        }
    //                    }
    //                }
    //            }
    //        }
    //        else {
    //            for (int j = 0; j < _polygonVertexs.Count; j++) {
    //                if (j == _polygonEars[i] - 1 || j == _polygonEars[i] || j == _polygonEars[i] + 1) {
    //                    continue;
    //                }
    //                else {
    //                    bool isIn = VertexIsInTriangle(_polygonVertexs[j], _polygonVertexs[_polygonEars[i] - 1], _polygonVertexs[_polygonEars[i]], _polygonVertexs[_polygonEars[i] + 1]);
    //                    if (isIn == true) {
    //                        if (_polygonEars.Contains(_polygonEars[i])) {
    //                            _polygonEars.Remove(_polygonEars[i]);
    //                        }
    //                    }
    //                }
    //            }
    //        }
    //    }
    //    #endregion

    //    #region 打印初始化结果
    //    //Debug.Log("凸点");
    //    //for (int i = 0; i < _raisedVertexs.Count; i++) {
    //    //    Debug.Log(_raisedVertexs[i]);
    //    //}

    //    //Debug.Log("凹点");
    //    //for (int i = 0; i < _concaveVertexs.Count; i++) {
    //    //    Debug.Log(_concaveVertexs[i]);
    //    //}

    //    //Debug.Log("耳朵");
    //    //for (int i = 0; i < _polygonEars.Count; i++) {
    //    //    Debug.Log(_polygonEars[i]);
    //    //}
    //    #endregion

    //    return new SplitResult(_raisedVertexs, _concaveVertexs, _polygonEars,_polygonVertexs);
    //}

    /// <summary>
    /// 判断一点是否在三角形内
    /// </summary>
    /// <param name="p">一点</param>
    /// <param name="a"></param>
    /// <param name="b"></param>
    /// <param name="c"></param>
    /// <returns></returns>
    private bool VertexIsInTriangle(Vector3 p, Vector3 a,Vector3 b,Vector3 c) {

        Vector3 ab = Vector3.Cross((b - a), (p - a));
        Vector3 bc = Vector3.Cross((c - b), (p -b));
        Vector3 ca = Vector3.Cross((a - c), (p - c));

        if (_compareAxle == CompareAxle.Y) {
            if(ab.y > 0 && bc.y > 0 && ca.y > 0) {
                return true;
            }
        }
        if (_compareAxle == CompareAxle.X) {
            if (ab.x > 0 && bc.x > 0 && ca.x > 0) {
                return true;
            }
        }
        if (_compareAxle == CompareAxle.Z) {
            if (ab.z > 0 && bc.z > 0 && ca.z > 0) {
                return true;
            }
        }
        return false;
    }

    /// <summary>
    /// 管理多边形 构成一个双向链表
    /// </summary>
    public class NodeManager {

        private List<Node> _nodeList = new List<Node>();

        public int LinkedListLength {
            get { return _nodeList.Count; }
        }

        public Node FirstNode {
            get { return _nodeList[0]; }
        }

        public void Init(List<Vector3> vertexs) {

            for (int i = 0; i < vertexs.Count; i++) {
                Node node = new Node(i, vertexs[i]);
                _nodeList.Add(node);
            }

            for (int i = 0; i < LinkedListLength; i++) {
                if (i == 0) {
                    _nodeList[i].lastNode = _nodeList[LinkedListLength - 1];
                    _nodeList[i].nextNode = _nodeList[1];
                }
                else if (i == LinkedListLength - 1) {
                    _nodeList[i].lastNode = _nodeList[LinkedListLength - 2];
                    _nodeList[i].nextNode = _nodeList[0];
                }
                else {
                    _nodeList[i].lastNode = _nodeList[i - 1];
                    _nodeList[i].nextNode = _nodeList[i + 1];
                }
            }
        }

        public void RemoveNode(Node node) {
            _nodeList.Remove(node);
            node.lastNode.nextNode = node.nextNode;
            node.nextNode.lastNode = node.lastNode;
        }
    }

    public class Node {

        public int id;
        public Vector3 vertex;
        public Node lastNode;
        public Node nextNode;

        public Node(int id, Vector3 vertex) {
            this.id = id;
            this.vertex = vertex;
        }

        public Node(int id, Vector3 vertex, Node lastNode, Node nextNode) {
            this.id = id;
            this.vertex = vertex;
            this.lastNode = lastNode;
            this.nextNode = nextNode;
        }
    }

    public class SplitResult {
        /// <summary>
        /// 凸顶点
        /// </summary>
        public List<Node> raisedVertexs;
        /// <summary>
        /// 凹顶点
        /// </summary>
        public List<Node> concaveVertexs;
        /// <summary>
        /// 耳朵
        /// </summary>
        public List<Node> polygonEars;

        public SplitResult(List<Node> raisedVertexs, List<Node> concaveVertexs, List<Node> polygonEars) {
            this.raisedVertexs = raisedVertexs;
            this.concaveVertexs = concaveVertexs;
            this.polygonEars = polygonEars;
        }
    }
}

#endregion

}

耳切法处理多边形三角划分
游戏路上的小学生
10-18 2万+
2016.10.18  孙广东 http://blog.youkuaiyun.com/u010019717         日文《【Unity】Ear Clipping Triangulation》， 它使用这个技术 弄了软体的功能  复原了 Soft Body - p5.js    这也是我Get到的新概念. 一种 网格多边形三角化算法之一。 我之前  也写过文章关于在Unity下 使用Mesh...
ue4 c++ 多边形三角化
10-14
一种常见的方法是使用 ear-clipping 算法，这是一种简单且广泛应用的多边形三角化方法。该算法的基本步骤包括： 1. 确定多边形的外接圆，找到最外层的三个顶点作为“耳朵”。 2. 剪掉这些“耳朵”，形成新的三角形，...
多边形耳切法三角化C++实现
01-15
这是本人自己实现的任意封闭简单多边形三角化代码，使用的方法是耳切法，这次方法是经过本人严格测试，对于中国省边界这种复杂的边界都能通过，并且本人已经应用到项目当中。里面也给了单调多边形三角化的代码，但是还存在一些bug，欢迎补充。另外三角化的要求是多边形封闭且不交叉，点的顺序为逆时针排列。
使用耳切法将多边形三角化
yiwei151的博客
02-26 2016
效果图：   做法及原理可参考此链接：http://www.cnblogs.com/xignzou/p/3721494.html   代码： using System; using System.Collections.Generic; using UnityEngine; namespace PolygonTool { #region 耳切法对简单多边形进行三角形化 ...
Triangulation by Ear Clipping(耳切法处理多边形三角划分）
weixin_34032621的博客
05-11 1089
使用EarClipping三角化多边形（翻译） ---Triangulation by Ear Clipping(http://www.geometrictools.com/Documentation/TriangulationByEarClipping.pdf) 内容提要 1、简介 2、Ear Clipping方法 3、含有岛洞的多边形 4、查找相互可见点 5、含有多个岛洞的...
简单多边形三角化(暴力)
dehukun0483的博客
08-29 1183
简单多边形三角化(暴力) 说在前面 网上流传着各种神奇的多边形三角剖分算法，但是讲道理，实现难度太高了。。。也没有搜到其他人的实现。这里写个最暴力的做法。。随机数据验证没问题，欢迎 hack 实现 一个简单多边形的耳朵定义为：如果一个凸点与他相邻的点构成的三角形内，没有其他多边形的点，那么他是一个耳朵。 我们的思想很简单，每次切掉一个耳朵，直到多边形变为一个三角形。 核心代码 type...
数据结构与算法-耳切法处理多边形三角划分c#语言
习惯冬天的静谧
05-09 1638
外文地址Triangulation by Ear Clipping 译文地址耳切法处理多边形三角划分 这里是对此算法的应用 暂时不去考虑含有岛洞的多边形 这个算法主要考虑的点有以下几个: 1.计算凹凸三角形 2.计算点是否包含在三角形内 3.计算点是否在三角形边上和上一个类似不过我暂时没有写到更好地方法 这是在unity里的效果图 不做共线判断的时候图一会出错 上代码 暂时先这样 过几天等拿到数据之后大规模测试再验证是否完善 生成面的部分用到的是unity的api u..
C++实现耳切法对简单多边形进行三角化
耳切法是一种实用的多边形三角化算法，能够有效处理复杂的多边形边界问题。通过该算法实现的三角化不仅在理论上有重要的意义，在实际应用中也具有广泛的价值。代码的实现应遵循严谨的编程实践，确保算法的鲁棒性和...
耳切法多边形三角化库的实现与优化
由于其直观和简单，耳切法通常用于计算机图形学中的二维多边形三角化处理。 3. Earcut Earcut是实现耳切法的一个JavaScript库，专门用于将任意形状的多边形，包括具有孔洞、扭曲和自相交的多边形，三角化为一组...
将凹凸多边形分解成三角形
02-19
首先，我们需要理解为何要进行多边形三角化。在3D图形处理中，复杂的形状通常由多个多边形组成，这些多边形在某些情况下可能是凹的或凸的。然而，大多数图形硬件和软件库只支持处理简单的三角形，因为它们具有良好的...
切耳法（earcut）js文件
01-25
切耳法：将平面切分为三角面
C++多边形三角剖分,去耳法等三种算法
03-24
1:原始去耳法,随机找一点判断凸角, 2:优化去耳法 3:解决有洞口的多边形
Earcut-Triangulation.zip
06-28
使用耳切法将多边形三角化： 该库实现了修改后的耳朵切片算法，通过z 阶曲线散列优化并扩展到以不保证三角剖分正确性的方式处理孔洞、扭曲多边形、退化和自相交，但尝试始终为地理形状等实用数据。 它基于来自FIST 的想法： Martin Held 的Fast Industrial-Strength Triangulation of Polygons和Triangulation by Ear Clipping by David Eberly。
利用耳切算法三角化复杂多边形以实现复杂多边形填充
哈哈星云
04-23 717
利用耳切算法三角化复杂多边形以实现复杂多边形填充
三角剖分——递归切耳算法（recursive cutting-ear）
qq_32584715的博客
05-07 974
使用条件 只适用于简单多边形。简单多边形：每个顶点只被两条边分享，如下图所示。 术语 带符号面积：顶点p1、p2和p3，通过叉乘（p1p2.X*p2p3.Y - p1p2.Y*p2p3.X）/2计算得到的面积（有正负号），即是带符号面积。 顶点凹凸性：对于待测顶点i，计算i-1, i, i+1组成三角形的带符号面积Area，Area>0为逆时针，Area<0为顺时针，如果其时针特性和多边形的相同，就是凸点(convex vertex)，否则为凹点(concave vert...
耳切法简述
最新发布
GIS探索之路
12-31 1233
简述耳切法多边形三角化算法。
平面封闭图的耳切算法1
aazhoukeaa的博客
08-17 1288
耳切算法： 耳切算法用于将简单多边形切成三角形片，那么什么是简单多边形呢： 顺序排列的点，每个点被相邻两条边共享（即点不能出现在线的中间位置），所有线的交点都是顶点： 所以下面的任务就是上面图形①的操作了，这既是典型的没有内孔的简单多边形。 简单多边形包括了凸边型，也包括凹边型。 进一步：简单多边形的耳朵是指：是指由连续顶点Vn-1-Vn-Vn+1组成的内部不包含其他任意顶点的三角形。 显然上面图 V9-V0-V1就不是耳朵，V0-V1-V2也不是，V2-V3-V4是的，V3-.
PCL 耳切法三角剖分（Surface_EarClipping）
xhm01291212的博客
09-13 564
1.耳切法1.耳切法大致思想：（1）多边形的一个顶点和它相邻两个顶点可以组成一个三角形，如果，那么就可以把这个由该顶点及其相邻点组成的三角形当做一个“”，沿着这两个相邻顶点切下这个“耳朵”，并移除“”所代表的顶点。（2）然后对剩下的顶点组成的多边形重复上述的这个操作。（3）直到这个多边形只剩3个顶点。即把这个多边形完全分解为三角形。如下图：1）对左图原始多边形，执行一次切耳之后，得到右图的一次切耳之后的耳朵三角形（耳朵1）、及剩余多边形。2）不停重复切耳，得到如下结果。
[游戏开发]Unity多边形分割为三角形_耳切法
Blue_carrot_的博客
06-14 3698
带图介绍耳切法、并实现以及进行测试，提供源码
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值