七巧板复原之剩余区域的计算-多边形的加减法计算

最新推荐文章于 2022-08-21 15:25:00 发布
最新推荐文章于 2022-08-21 15:25:00 发布
阅读量264 收藏
点赞数
分类专栏： 软件开发 文章标签： 算法 多边形的加减法算法 七巧板复原算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Uman/article/details/125023881
版权

按：这个区域就是之前小文提到的空腔，后来笔者经过抽象，发现其实这是个多边形加减法的问题（不知道计算机图形学里有没有专门的叫法）

多边形的减法

如图示
在这里插入图片描述

图中G1是已经放好的部分，Part是刚刚摆放好的部件，我们要把G2用多边形的点的集合表达出来。也就是要把ABCDEFHG各个点的坐标求出来。（说明，G2可能并不是唯一的，也就是说空腔不止一个）。 下面给出了计算Part的非重合边 与 box 多边形的边围成的多边形的算法，这是我们要使用的剩余的主要区域，其他区域也快吃参照这种算法进行计算，但是我们暂时忽略。（其实其他空腔可以通过算法排除掉，或者认为出现这种空腔是一种不合理的方法，本算法就是采用了这种方式。）

根据上文的匹配方法，Part 的第一条边和G1的某一边是重合的，并且有一个公共的起始点。我们从这个起点开始计算，利用边线关系，确定 A点，也就是G2的初始点，然后烟逆时针方向遍历G2 的其余点，再利用边线关系确定F点， 再在Part上沿顺时针方向遍历Part的顶点一直到 A点， 这样就找到了G2的所有顶点。

判断A点和F点比较复杂，有各种情况，笔者简单总结了一下，如图示：
在这里插入图片描述
AB 是PArt上的线段， CD是G2 上的线段，上图基本覆盖了线段AB和CD的各种位置关系， 其中18 是比较特殊的关系，本算法中用的部件不会出现这种情况，因此没有考虑。图中 12 和7 ， 11 和16 是一样的， 顾只采用其中的一种即可。由于在本算法中，采用了有向线段，因此可以根据AB和CD的方向，确定G2的A点和F点。
下面是多边形减法主程序代码：

       /// <summary>
        ///  get all of the new plygons enclosed by the 2 input polygpons which just have the common side and the 
        ///  parttial polygong is inside the box polygon. 
        ///  In this version the new polygon will be "trimed" that the segments on have the same slope and share the same vertex will be merged to one segment.
        /// </summary>
        /// <param name="partPlg"> the parts polygon which is a subset of the box polygon</param>
        /// <param name="boxPlg"> The bigger polygon which enclose partial polygon</param>
        /// <returns></returns>
        public static List<TangramPolygon> GetNewPolygonV1(TangramPolygon partPlg, TangramPolygon boxPlg,bool border=true)
        {
            List<TangramPolygon> newPlgLst = new List<TangramPolygon>();// the result of the new polygon , the number of it is not fixed theoritically 
            List<KeyValuePair<int, int>> UnCoincidentSegLst = new List<KeyValuePair<int, int>>();// point index on part polygon , side index on box polygon
            // get those vertexes of part polygon on the side of the box polygon
            List<PointF> newPolygonPntLst = new List<PointF>();
            int partIdx = partPlg.firstPntIdx;
            //var bFindStPartPnt = false;// the first point in the part polygon of the new polygon has been found
            //var bFindEndPartPnt = false;// the second point in the part polygon of the new polygon has been found
            //var bFindEndBoxPnt = false;
            int boxIdx;
            boxIdx = boxPlg.firstPntIdx;
            //1# find the segment in part polygon 
            //newPolygonPntLst = GetPntsBetween2PlgOld(partPlg, ref partIdx, boxPlg, ref boxIdx);
            newPolygonPntLst = GetPntsBetween2Plg(partPlg, ref partIdx, boxPlg, ref boxIdx,border);

            PointF[] pntArr = newPolygonPntLst.ToArray();
            if (pntArr.Length != 0)
            {
                TangramPolygon tplg = new TangramPolygon(pntArr, false);
                // merge the segments which have the same slop and point.
                
                tplg = MergeSegment(tplg);// here is the difference compared with the old version. 

                newPlgLst.Add(tplg);
            }
            return newPlgLst;

        }

GetPntsBetween2Plg 函数就是上面算法的具体实现，代码如下：

        /// <summary>
        ///  Get the the points between 2 polygons, starts from an known coinsected  segment of the 2 plygons. 
        /// </summary>
        /// <param name="part"></param>
        /// <param name="partIdx"> the coinsected segment index in polygon 1 </param>
        /// <param name="box"></param>
        /// <param name="boxIdx"></param>
        /// <param name="bSub"> true, plygon substract, false: add  </param>
        /// <returns> The points of the new plolygon in a list</returns>
        private static List<PointF> GetPntsBetween2Plg(TangramPolygon part, ref int partIdx, TangramPolygon box, ref int boxIdx,bool bSub = true)
        {
            List<PointF> newPntLst = new List<PointF>();
            bool bFindStartPnt = false;
            bool bFindEndPnt = false;
            int partStIdx, partEndIdx, boxStIdx, boxEndIdx;
            boxStIdx = boxIdx;
            boxEndIdx = boxIdx;
            bool bOrder = true;
            bool bSearchAll = false;// false: only return the end point, true: all the point 
            int searchIdx = box.firstPntIdx;
            int lastCaseNo = -1;
            var caseNo0 = -1;
            var caseNo1 = -1;
            var caseNo2 = -1;
            var caseNo3 = -1;
            for (int i = 0; i < part.Count(); i++)
            {
                caseNo0 = -1;
                caseNo1 = -1;
                caseNo2 = -1;
                caseNo3 = -1;
                PointF A = part.GetVertexPoint(partIdx);// postive order 
                PointF B = part.GetNextVertexPoint(partIdx);
                var segCaseLst = PointsCoincidePlgSeg(new Segment(A, B), box, searchIdx, bSub, false);
                
                if (segCaseLst.Count > 0)
                {
                    searchIdx = segCaseLst[0].idx;
                    caseNo0 = segCaseLst[0].no; 
                }
               
                

                if (segCaseLst.Count > 1)
                {
                    caseNo1 = segCaseLst[1].no;

                }
                if (segCaseLst.Count > 2)
                {
                    caseNo2 = segCaseLst[2].no;

                }
                if (segCaseLst.Count > 3)
                {
                    caseNo3 = segCaseLst[3].no;

                }
                if (!(lastCaseNo == 2 || lastCaseNo == 5 || lastCaseNo == 7 || lastCaseNo == 8 || lastCaseNo == 9) && lastCaseNo != -1)
                {
                    searchIdx = box.GetVertex(searchIdx).next_idx;
                }
                var caseHeadNo = string.Format("{0}-{1}", caseNo0, caseNo1);
                var caseTailNo = string.Format("{0}-{1}", caseNo2, caseNo3);
                lastCaseNo = caseNo0;
                if (!bFindStartPnt)
                {
                    bOrder = true;
                    bSearchAll = false;
                    // check the first element by far
                    if (caseHeadNo == "2-5" || caseHeadNo == "5-2")// find startPoint  and end point , 5 (A)is the start point , but the idx is different 
                    {

                        bFindStartPnt = true;
                        newPntLst.Add(A);
                        if (caseNo1 == 5)
                        {
                            boxStIdx = segCaseLst[1].idx;
                            boxEndIdx = segCaseLst[0].idx;
                        }
                        else
                        {
                            boxStIdx = segCaseLst[0].idx;
                            boxEndIdx = segCaseLst[1].idx;
                        }
                        bFindEndPnt = true;
                        newPntLst.Add(B);
                       

                    }
                    else if (caseHeadNo == "3-1")
                    {
                        if (caseNo2 == 5)// find startPoint  and end point , 5 is the start point 
                        {
                            bFindStartPnt = true;
                            newPntLst.Add(A);
                            boxStIdx = segCaseLst[2].idx;
                            bFindEndPnt = true;
                            newPntLst.Add(B);
                            boxEndIdx = segCaseLst[0].idx;

                        }
                    }
                    
                    else  if (caseHeadNo == "6-4")// find startPoint 
                    {
                        bFindStartPnt = true;
                        newPntLst.Add(A);
                        boxStIdx = segCaseLst[0].idx;
                    }
                    else
                    {
                        if (caseNo0 == 4 || caseNo0 == 5 || caseNo0 == 6 || caseNo0 == 11 || caseNo0 == 14 || caseNo0 == 15)
                        {

                            if (caseNo0 == 4 || caseNo0 == 6)
                            {
                                if (caseNo1 == 8 || caseNo1 == 17)
                                {
                                    partIdx = part.GetVertex(partIdx).next_idx;
                                    continue;
                                }
                                if(caseNo1 == 15)// D 
                                {
                                    var D = segCaseLst[1].casePntLst[2].Value;
                                    newPntLst.Add(D);
                                    bFindStartPnt = true;
                                    boxStIdx = segCaseLst[1].idx;
                                    partIdx = part.GetVertex(partIdx).next_idx;
                                    continue;

                                }
                            }


                            bFindStartPnt = true;
                            boxStIdx = segCaseLst[0].idx;
                            if (caseNo0 == 4 || caseNo0 == 5 || caseNo0 == 6)
                            {
                                newPntLst.Add(A);
                            }
                            else //if (caseNo == 11 || caseNo == 14 ||caseNo == 15))
                            {
                                var D = segCaseLst[0].casePntLst[2].Value;
                                newPntLst.Add(D);
                            }

                        }
                    }
                    if (caseTailNo == "3-1")// find endPoint 
                    {
                        bFindEndPnt = true;
                        newPntLst.Add(B);
                        boxEndIdx = segCaseLst[2].idx;
                    }
                    else if (caseTailNo == "13-1")// find endPoint
                    {
                        bFindEndPnt = true;
                        var C = segCaseLst[2].casePntLst[1].Value;
                        newPntLst.Add(C);
                        boxEndIdx = segCaseLst[2].idx;
                    }else if (caseTailNo == "2--1")// find endPoint -1 means not found 
                    {
                        bFindEndPnt = true;
                        B = segCaseLst[2].casePntLst[1].Value;

                        newPntLst.Add(B);
                        boxEndIdx = segCaseLst[2].idx;
                    }
                    else if(bFindStartPnt && ! bFindEndPnt)
                    {
                        // check the second element for end poing check 
                        if (segCaseLst.Count > 1)
                        {
                            caseNo1 = segCaseLst[1].no;
                            if (caseNo1 == 1 || caseNo1 == 2 || caseNo1 == 3 || caseNo1 == 7 || caseNo1 == 13 || caseNo1 == 14)
                            {
                                if (caseNo1 == 1 || caseNo1 == 3)
                                {
                                    if (caseNo0 == 10 || caseNo0 == 13 || caseNo0 == 17)
                                    {
                                        partIdx = part.GetVertex(partIdx).next_idx;
                                        continue;
                                    }
                                }
                                bFindEndPnt = true;
                                boxEndIdx = segCaseLst[1].idx;
                                if (caseNo1 == 1 || caseNo1 == 2 || caseNo1 == 3)
                                {
                                    newPntLst.Add(B);
                                }
                                else
                                {
                                    var C = segCaseLst[1].casePntLst[1].Value;
                                    newPntLst.Add(C);
                                }
                            }
                        }
                    }

                }
                else if (!bFindEndPnt)
                {
                    newPntLst.Add(A);

                    if (caseNo0 == 0)
                    {
                        partIdx = part.GetVertex(partIdx).next_idx;
                        continue;
                    }
                    bOrder = true;

                    if (caseNo0 == 1 || caseNo0 == 2 || caseNo0 == 3 || caseNo0 == 7 || caseNo0 == 13 || caseNo0 == 14)
                    {
                        if (caseNo0 == 1 || caseNo0 == 3)
                        {
                            //if (caseNo1 == 10 || caseNo1 == 13 || caseNo1 == 17)
                            if (caseNo1 == 10 || caseNo1 == 17)
                            {
                                partIdx = part.GetVertex(partIdx).next_idx;
                                continue;
                            }
                        }
                        bFindEndPnt = true;
                        if (caseNo1 == 13)
                        {
                            boxEndIdx = segCaseLst[1].idx;
                        }
                        else
                        {
                            boxEndIdx = segCaseLst[0].idx;
                        }
                        
                        //if the intersection is on the vertex of the boxPlg, the outBoxIdx should move to its previous one 
                        var boxPnt = box.GetVertexPoint(boxEndIdx);

                        if (B == boxPnt)
                        {
                            if (bSub)
                            {
                                boxEndIdx = box.GetVertex(boxEndIdx).last_idx;
                            }
                            //else
                            //{
                            //    boxEndIdx = box.GetVertex(boxEndIdx).next_idx;

                            //}
                        }
                        if (caseNo0 == 1 || caseNo0 == 2 || caseNo0 == 3)
                        {
                            if(caseNo1 == 7 || caseNo1 == 13 || caseNo1 == 14)
                            {
                                var C = segCaseLst[1].casePntLst[1].Value;
                                newPntLst.Add(C);
                               
                            }
                            else
                            {
                                newPntLst.Add(B);
                            }
                           
                        }
                        else
                        {
                            var C = segCaseLst[0].casePntLst[1].Value;
                            newPntLst.Add(C);
                        }
                    }
                }
                if (bFindEndPnt) break;

                partIdx = part.GetVertex(partIdx).next_idx;

            }
            // build the new point list based one start and end index...
            boxIdx = boxEndIdx;
            for (int i = 0; i < box.Count(); i++)
            {
                var boxPnt = box.GetVertexPoint(boxIdx);
                if (!bSub)// plus 
                {
                    boxIdx = box.GetVertex(boxIdx).next_idx;
                    boxPnt = box.GetVertexPoint(boxIdx);
                }
                if (boxIdx != boxStIdx)
                {
                    //newPntLst.Add(boxPnt);
                    int findIdx = newPntLst.FindIndex(p => p.X == boxPnt.X && p.Y == boxPnt.Y);
                    if (findIdx == -1)
                    {
                        newPntLst.Add(boxPnt);
                    }
                }
                else
                {
                    //var stPnt = newPntLst[0];
                    //if(!(stPnt.X == boxPnt.X && stPnt.Y == boxPnt.Y))// if the end point of the last segment is not equal the first point , add it to list.
                    //{
                    //    newPntLst.Add(boxPnt);
                    //    break;// finished 
                    //}
                    if (!bSub)// plus 
                    {
              
                        int findIdx = newPntLst.FindIndex(p => p.X == boxPnt.X && p.Y == boxPnt.Y);
                        if (findIdx == -1)
                        {
                            newPntLst.Add(boxPnt);
                        }

                    }
                    break;
                }

                if (bSub)//substract 
                {
                    boxIdx = box.GetVertex(boxIdx).last_idx;
                }
               
            }
            //if (newPntLst.Count < 3)
            //{
            //    throw new Exception("Calculation error!");
            //}
            return newPntLst;
        }

说明：函数支持多边形加法和减法，通过参数控制。
MergeSegment(tplg)： 该函数的作用是将在同一条线段上的点合并，只保留最长线段的的端点，代码如下：

      /// <summary>
        ///  Merge the segments to one segments if they are adjancent and have the same slop
        /// </summary>
        /// <param name="newPlg"></param>
        /// <returns></returns>
        private static TangramPolygon MergeSegment(TangramPolygon plg)
        {
            List<PointF> pntLst = new List<PointF>();
            var idx = plg.GetVertex(0).idx;
            for (int i = 0; i < plg.Count(); i++)
            {
                bool slopAB_EQ_BC = false; 

                var A = plg.GetLastVertexPoint(idx);
                var B = plg.GetVertexPoint(idx); 
                var C = plg.GetNextVertexPoint(idx);
                if(A.X == B.X && B.X == C.X)
                {
                    slopAB_EQ_BC = true;
                }
                else if(A.X != B.X && B.X != C.X)
                {
                    slopAB_EQ_BC = (B.Y - A.Y) / (B.X - A.X) == (C.Y - B.Y) / (C.X - B.X);
                }
                if (!slopAB_EQ_BC)
                {
                    pntLst.Add(B);
                }
                idx = plg.GetVertex(idx).next_idx;
  
            }
            if(pntLst.Count == plg.Count())
            {
                return plg;
            }
            else
            {
                return new TangramPolygon(pntLst.ToArray());
            }
        }

至此，核心计算程序已经叙述完毕，下面将讨论如何回溯的方法查找七巧板的大部分解决方法。

maraSun 于BJFJDQ。
北京仍然在尝试不使用上海用过的方法处理北京的特殊问题，但是事实上是殊途同归。
海淀小区核酸连续不中断检查到20多天了，不知道何时算个完。

MaraSun
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
复杂多边形运算（并、交、差）
11-26
可以对简单多边形实现求并、交、差，复杂多边形之间的并、交、差
一种简单、快速、高效的多边形减面算法
amd k_7的专栏
06-03 1万+
 一种简单、快速、高效的多边形减面算法A Simple, Fast, and Effective Polygon Reduction Algorithm Stan Melax 正在加拿大亚伯达大学攻读计算机科学博士学位，致力于研究交互式3D技术和算法。他同时是Bioware的技
[Boost::Polygon]多边形相减得到新的多边形序列
aees4684的博客
08-25 880
#include <iostream> #include <boost/polygon/polygon.hpp> #include <cassert> namespace gtl = boost::polygon; using namespace boost::polygon::operators; //lets construct ...
Maya: 菜单 网格 >布尔>差集
Alisa200920的专栏
08-08 2043
网格 >布尔>差集 可以将两个多边形对象进行相减运算，以消去对象与其他对象的相交部分，同时也会消去其他对象。
七巧板-手工坊--DIY--创业计划书.zip
11-25
【标题】"七巧板-手工坊--DIY--创业计划书.zip" 是一个压缩文件，其中包含了关于开设一家以七巧板制作和手工DIY为主题的创业计划书。七巧板是一种古老的智力玩具，由七块不同形状的木板组成，可以拼出各种图案，锻炼...
创业计划书-七巧板-手工坊--DIY--创业计划书
08-25
【创业计划书-七巧板-手工坊--DIY--创业计划书】 在这个充满创新精神的时代，DIY（Do It Yourself）活动越来越受到人们的欢迎，尤其是对于儿童和年轻人，它不仅可以提升动手能力，还能激发创造力。"七巧板-手工坊...
七巧板-手工坊--DIY--创业计划书商业计划书精品模板.ppt
04-23
七巧板-手工坊--DIY--创业计划书商业计划书精品模板.ppt
封闭多边形的并、交、差运算
12-30
封闭多边形的并、交、差运算，李旭健，韩丛英，提出了一种基于交点的凹凸性求封闭多边形的并、交、差的算法。首先给出了环、并、交、差、凹凸点的定义；然后描述了算法。该算法
多边形求交并差
马德里小铁匠的铁匠铺
11-28 5507
代码：Github:team79/PolygonOverlayAnalysis基本概念介绍多边形交并差计算的算法的相关证明过程是很繁琐，因此在这里将直接给出算法所需的概念以及算法所用到的一些性质。具体的相关证明过程在ZHU Ya-Yin[1]论文中有详细证明。 算法中的一些概念： 1、∂A :多边形A 的边的集合, 或A 的边界上点的集合; 2、P ↓:过点P 作的垂直向下射线; 3、<:点的小于
计算机图形学：多边形裁剪之交并差计算
Yan
07-17 3443
背景 多边形裁剪是一个复杂而又常用的功能，然而自己造轮子是万万不能的。所以花了一个下午浏览了网上现在能够找到所有可以进行多边形裁剪的库，除去没有代码（Polygon Clipper library）、库太庞大（CGAL）、难以编译（clipoly）；最终选定Clipper，并将其稍加修改转移到CMake下方便使用。 代码地址 https://github.com/Yannnnnnnnnn...
几种判断点与多边形关系的算法介绍
weixin_30709929的博客
01-29 835
本文讨论如何判断一个点是在多边形内部，边上还是在外部。为了方便，这里的多边形默认为有向多边形，规定沿多边形的正向，边的左侧为多边形的内侧域，即多边形边按逆时针方向遍历，不考虑自交等复杂情况。 比较常见的判断点与多边形关系的算法有射线法、面积法、点线判断法和弧长法等，算法复杂度都为O(n)，不过只有射线法可以正确用于凹多边形，其他3个只可以用于凸多边形。 1. 射线法 射线法是使用最广泛的算法...
轮廓相减的两种实现方法
牧羊女
03-13 1032
在优化工程代码效率。从一系列轮廓合集中减去其中的一个轮廓分量，之前都是通过二值图像相减的方式，即把总轮廓绘制在一副图像上Img_1，再把要减去的分量绘制在另一幅图像Img_2上，然后通过图像相减得到差值图像Img_3，再从Img3中找出相减后的结果。今天突然灵机一动，发现这么减来减去简直太浪费资源了，明明一副图像就能搞定呀！只要在一副图像上绘制总轮廓，然后用背景像素绘制要减去的轮廓不就OK了？傻呵...
多边形之间的交差并补....
weixin_30628801的博客
09-30 630
　　以前接触二维图形的操作比较多，多边形之间的交差并补是一个难点，算法也颇为复杂，幸好有一些现成的源代码文件，比如这个gpc.c和gpc.h。 　　首先先将gpc.c和gpc.h加入到工程，我用的是mfc vc6.0（好古老）...需要将gpc.c改成gpc.cpp，然后添加到工程，似乎出现过一些问题，具体忘了，蛮简单最后配置成功，就可以用gpc的算法了。 　　整个文件不算难，很容易看懂，这里...
多边形的布尔运算（intersection交集, union并集, difference差异, xor 异或）
苏一恒
05-07 7838
文章目录前言正文实现思路效果展示缺点代码实现 前言 这是工作中的一个需求，要求使用PixiJS来进行绘制，所以这里就不使用原生Canvas或是其他绘制工具了。但归根结底，原理都是一样的。 正文 多边形的布尔运算（ boolean operation on polygons）包括: intersection交集, union并集, difference差异, xor 异或。 具体表现如，Photos...
计算几何 常用算法模版
UnrealEngine4 、Delta3D、OSG
08-04 4394
/* 计算几何 目录 ㈠ 点的基本运算 1. 平面上两点之间距离 1 2. 判断两点是否重合 1 3. 矢量叉乘 1 4. 矢量点乘 2 5. 判断点是否在线段上 2 6. 求一点饶某点旋转后的坐标 2 7. 求矢量夹角 2 ㈡ 线段及直线的基本运算 1. 点与线段的关系 3 2. 求点到线段所在直线垂线的垂足 4 3. 点到线段的最近点 4 4. 点到线段所在直线的
Halcon形态学操作、区域处理相关常用API
Moresweet 猫甜
04-14 5039
膨胀一般用来填补物体中小的空洞和狭窄的缝隙，使物体的尺寸增大。 膨胀运算需要生成结构内核才能完成，在HALCON中使用gen_circle来生成圆形结构内核，这个函数的参数中： （1）第一个参数Circle为输出的圆形结构区域； （2）第二个参数Row为输入圆形区域中心行坐标； （3）第三个参数是Column为输入圆形区域中心列坐标。 使用gen_rectangle1来生成矩形结构内核，这个函数的参数中： （1）第一个参数Rectangle为输出的矩形结构区域； （2）第二个参数Row1为输入的矩形区域的左
Go初学者坑记之 go mod init 和自定义包的使用
热门推荐
退休码农的自留地
12-07 1万+
入门很容易的 hello world, 到使用自定义包算一个小的进步,然而在使用上竟然浪费了不少时间,上网查了半天,才解决问题. 第一明确 是哪种方式,是go mod 方式 还是 go path 方式, 请自己查一下,本小文直说go mog 方式的小问题. 首先看一下 文档结构 我自己写了个 ToolKit.go, 内容大致如下: 问题是:怎么引用它 //for all kind of tools package Toolkit import ( "net/http" "strings" ) f
C#:System.NotSupportedException: Character set utf8mb3 is not supported by .Net Framework 解决方法
退休码农的自留地
08-21 6639
mysql 升级到8.030 之后，好好的C#程序报如题的错误，各种操作，改mysql的cnf文件，重启，修改表的字符集，然而没用！根据经验需要冷静，休息一下。午休之后，试试科学上网，果然找到问题了。后面的步骤就省略了，下载完成后，再运行，大功告成。2、更新mysql.data 到 8.00。道理不讲了，折腾了一个中午，差点儿晕倒。1、回退到8.028 以及以前的版本。
如何在python中画出七巧板
最新发布
05-14
七巧板的形状是由一系列不同的多边形组成，因此我们需要计算每个多边形的顶点坐标。这可以通过一些已知的公式和方法，在代码中进行实现。例如，我们可以通过给定一个多边形的边长，以及它的旋转角度，来计算出它的六...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值