多边形裁剪
多边形裁剪地Sutherland—Hodgman算法(计算机图形学)

多形裁剪的 Sutherland —Hodgman算法1>. Sutherland—Hodgman多形裁剪算法思想算法的根本思想是每次用窗口的一条界及其延来裁剪多形的各。
多形往常由它的点序列来表示,裁剪某条界裁剪后,果形成新的点序列,又留待下条界行裁剪,⋯,直到窗口的全部界都裁剪完,算法形成最后的点序列,才是果多形〔它可能组成一个或多个多形〕。
当多形一个点 Pi 相于窗口某条界及其延行剪裁,不外乎以下四种状况〔即裁剪〕:1、点 Pi 在内,前一点 Pi-1也在内,将 Pi 入新的点序列;2、点 Pi 在内,前一点 Pi-1在外,先求交点Q,再将 Q、Pi 挨次入新的点序列;3、点 Pi 在外,前一点 Pi-1在内,先求交点Q,再将 Q入新的点序列;4、点 Pi 与前一点 Pi-1 均在外,点序列中不增添新的点。
2>. Sutherland—Hodgman多形裁剪算法步考多形相于一条界及其延行裁剪的算法:1.从主函数获得待裁剪多形的点序列 P[][2] 、点序列数 n、窗口一条界参数 xl 〔假定矩形窗口的左界〕;2.初:将点序列中的最后一个点前一点S;置初始志 flag :if(S在界内)flag=0;else flag=1;新的点序列数j=0 ;3.多形各点行裁剪理,果放入新的多形点序列Q[][2]中:for( 第一个点直到最后一个点,逐个理〕{if(Pi 在界内 ){if(flag!=0){flag=0;求交点并放入新的多形点序列Qj 中;j++ ;}将目前点放入新的多形点序列 Qj 中: Qj=Pi ; j++ ;}else{if(flag==0){flag=1;求交点并放入新的多形点序列Qj 中;j++ ;}}将目前极点赋给S: S=Pi;}4.做返回准备:将新的多边形极点序列Q又逐个放回原多边形极点序列P 中: P=Q;将新的多边形极点数j 放回原多边形极点数n 中: n=j ;////////////////////////////////////////////////////////////////////////////////////////-----多边形裁剪的Sutherland—Hodgman算法---------///////////////////////////////////////////////////////////////////////////////////////void CMyClip_AView::ClipedgeL(CPoint polypoint[], CPoint clipwindow[],UINT polynum)/* 此中参数 polypoint[] 为多边形极点 ,clipwindow[] 为裁剪窗口极点 ,polynum 为多边形极点数量 */{//找出裁剪窗口界限long xl,xr,yt,yb;UINT i;xl=clipwindow[0].x;xr=clipwindow[0].x;yt=clipwindow[0].y;yb=clipwindow[0].y;for(i=1;i<=4;i++){if(xl>clipwindow[i].x)xl=clipwindow[i].x;if(xr<clipwindow[i].x)xr=clipwindow[i].x;if(yb>clipwindow[i].y)yb=clipwindow[i].y;if(yt<clipwindow[i].y)yt=clipwindow[i].y;}//CPoint B[Polygon_Num],C[Polygon_Num];UINT m_nA,m_nB;int x,y;long tem1,tem2;m_nA=polynum;/*记录原始多边形极点极点个数*/m_nB=0;/* 记录重生成多边形极点极点个数*/for(i=0;i<m_nA;i++){if(polypoint[i].x<xl&& polypoint[i+1].x<xl)/* 判断的多边形边两个端点都在外面,不做办理*/{continue;/*假如是这类状况,那么就对持续对下一条多边形边作判断,也就是说下边的判断不用做了*/}if(polypoint[i].x>=xl&& polypoint[i+1].x>=xl)/* 边两个端点都在内部,保留*//* 由于每个保留的点在数组中只出现一次,且下一次判断时第二个端点必定会要取到,所以只保留的两个点中的第一个*/{B[m_nB].x =polypoint[i].x ;B[m_nB].y =polypoint[i].y ;m_nB=m_nB+1;continue;}if(polypoint[i].x<xl&& polypoint[i+1].x>=xl)/*边两个端点起点在外面,终点在内部,求交点,而后交点,终点都应当送入暂时数组*/{/*保留交点*/x=xl;tem1=(xl-polypoint[i].x);//tem2=(xl-x1)*dy/dx+y1;//y/x=dy/dx---->y=x*dy/dxtem2=tem1*(polypoint[i+1].y-polypoint[i].y)/(polypoint[i+1].x-polypoint[i].x)+polypoint[i].y;y=tem2;B[m_nB].x =x;B[m_nB].y =y;m_nB=m_nB+1;continue;}if(polypoint[i].x>=xl && polypoint[i+1].x<xl)/*起点在内部,终点在外,求交点,而后起点,交点送入暂时数组*/{/*保留内部点*/B[m_nB].x =polypoint[i].x ;B[m_nB].y =polypoint[i].y ;m_nB=m_nB+1;/* 保留交点 */x=xl;tem1=(xl-polypoint[i].x);tem2=tem1*(polypoint[i+1].y-polypoint[i].y)/(pol ypoint[i+1].x-polypoint[i].x)+polypoint[i].y;y=tem2;B[m_nB].x =x;B[m_nB].y =y;m_nB=m_nB+1;continue;}}//把第一个点的数据拷贝到最后//形成裁剪后的多边形if(i==m_nA){B[m_nB]=B[0];}//下 ------------------m_nA=0;for(i=0;i<m_nB;i++){if(B[i].y<yb && B[i+1].y<yb)//两个点全在下方{continue;//下一条边}if(B[i].y>=yb && B[i+1].y>=yb)//p1,p2 都在 yb 上方{C[m_nA].x =B[i].x;C[m_nA].y =B[i].y;m_nA++;continue;}if(B[i].y<yb && B[i+1].y>=yb)//p1 在下, P2 在上 , 留交点,外->内{y=yb;tem1=yb-B[i].y;//tem2=x1+(yb-y1)*dx/dytem2=tem1*(B[i+1].x-B[i].x)/(B[i+1].y-B[i].y)+ B[i].x;x=tem2;C[m_nA].x =x;C[m_nA].y =y;m_nA++;continue;}if(B[i].y>=yb && B[i+1].y<yb)//p1在上方,P2 在下方,留P1 和交点, 内-外{//save p1C[m_nA].x=B[i].x;C[m_nA].y=B[i].y;m_nA++;//留交点y=yb;tem1=yb-B[i].y;//tem2=x1+(yb-y1)*dx/dytem2=tem1*(B[i+1].x-B[i].x)/(B[i+1].y-B[i].y)+B[i].x;x=tem2;C[m_nA].x =x;C[m_nA].y =y;m_nA++;continue;}}//形成第二次裁剪多边形if(i==m_nB){C[m_nA]=C[0];}//右 ------------------m_nB=0;for(i=0;i<m_nA;i++){if(C[i].x>xr && C[i+1].x>xr)//P1 , P2 都在右方 --go next{continue;}if(C[i].x<=xr && C[i+1].x<=xr)//P1 , P2 都在左方,留P1{B[m_nB].x =C[i].x;B[m_nB].y =C[i].y;m_nB++;continue;}if(C[i].x>xr && C[i+1].x<=xr)//P1在右方,P2在左方,留交点{x=xr;tem1=C[i].x-xr;tem2=C[i].y-tem1*(C[i+1].y-C[i].y)/(C[i+1].x-C[i ].x);y=tem2;B[m_nB].x =x;B[m_nB].y =y;m_nB++;continue;}if(C[i].x<=xr && C[i+1].x>xr)//P1在内, P2 在外,留P1 和交点{//save p1B[m_nB].x =C[i].x;B[m_nB].y =C[i].y;m_nB++;//save交点x=xr;tem1=C[i].x-xr;tem2=C[i].y-tem1*(C[i+1].y-C[i].y)/(C[i+1].x-C[i ].x);y=tem2;B[m_nB].x =x;B[m_nB].y =y;m_nB++;continue;}}//三次裁剪后的新多边形if(i==m_nA){B[m_nB]=B[0];多边形裁剪地Sutherland—Hodgman算法(计算机图形学)适用文档}//上 -------------------m_nA=0;for(i=0;i<m_nB;i++){if(B[i].y>yt && B[i+1].y>yt)//p1,p2 都在上方 ,next{continue;}if(B[i].y<=yt && B[i+1].y<=yt)//p1,p2 都在下方 , 留 P1{C[m_nA].x =B[i].x;C[m_nA].y =B[i].y;m_nA++;continue;}if(B[i].y>yt && B[i+1].y<=yt)//P1在上方,P2在下方外->内, 留交点{y=yt;tem1=B[i].y-yt;//tem2=x1+(yb-y1)*dx/dytem2=B[i].x-tem1*(B[i+1].x-B[i].x)/(B[i+1].y-B[i ].y);x=tem2;C[m_nA].x =x;C[m_nA].y =y;m_nA++;continue;}if(B[i].y<=yt && B[i+1].y>yt)//P1在下方,P2在上方,内->外,留P1 和交点{//save p1,,,C[m_nA].x =B[i].x;C[m_nA].y =B[i].y;m_nA++;//save交点y=yt;tem1=B[i].y-yt;多边形裁剪地Sutherland—Hodgman算法(计算机图形学)适用文档//tem2=x1+(yb-y1)*dx/dytem2=B[i].x-tem1*(B[i+1].x-B[i].x)/(B[i+1].y-B[i ].y);x=tem2;C[m_nA].x =x;C[m_nA].y =y;m_nA++;continue;}}//形成裁剪后的多边形if(i==m_nB){C[m_nA]=C[0];}CClientDC dc(this);CPen tempen;tempen.CreatePen(PS_SOLID,1,RGB(255,0,0));dc.SelectObject(tempen);dc.MoveTo(C[0]);for(i=1;i<=m_nA;i++){dc.LineTo(C[i]);}}//.....。
CAD多边形修剪技巧分享

CAD多边形修剪技巧分享CAD软件作为设计师和工程师们常用的工具之一,具有强大的绘图和建模功能。
在CAD中,多边形修剪是一项常见的操作,可以用来裁剪和修改多边形的形状。
本文将分享一些CAD多边形修剪的技巧,帮助读者更高效地进行多边形编辑。
首先,我们需要了解CAD中的一些基本术语。
多边形是由一系列的线段组成的封闭图形,其边数量可以是任意的。
边是连接图形的线段,在CAD中用于分割和定义多边形的形状。
顶点是多边形的角点,也是线段的连接点。
通过理解这些术语,我们可以更好地进行多边形修剪操作。
接下来,我们将介绍一些CAD中常用的多边形修剪工具和技巧。
首先是裁剪多边形的方法。
在CAD中,可以使用Trim命令进行多边形的裁剪。
选择该命令后,先选择需要裁剪的多边形,然后选择裁剪区域。
CAD会自动将裁剪区域内的部分删除,只保留裁剪范围外的部分。
这样可以快速而准确地修改多边形的形状。
除了使用Trim命令,我们还可以使用Hatch命令进行多边形修剪。
Hatch命令可以用来填充多边形内的区域,但在设置填充样式时,我们可以选择只填充多边形的部分区域。
通过选择正确的填充样式和区域,我们可以轻松地实现多边形的修剪效果。
此外,CAD还提供了一种快速修剪多边形的方法,即使用Polyline命令。
Polyline命令可以创建一个由多条线段组成的多边形。
在创建多边形时,我们可以选择闭合线段,形成一个封闭的多边形。
接着,选择Line命令,将线段与多边形交叉,然后使用Trim命令修剪多边形。
这种方法可以在不使用裁剪工具的情况下,快速实现多边形的修剪操作。
此外,为了更好地进行多边形修剪,我们还可以使用CAD软件中的一些辅助工具和技巧。
例如,使用Object Snap功能可以使我们更准确地选择多边形的顶点和线段。
通过启用Midpoint(中点)或Endpoint(端点)等选项,我们可以将光标捕捉到具体位置,从而精确地选择需要修剪的部分。
另外,通过使用CAD软件中的层命令,我们可以将多边形的修剪和修改操作分布在不同的图层上。
多边形裁剪报告范文

多边形裁剪报告范文多边形裁剪是计算机图形学中的一项重要技术,用于确定多边形在一个给定的裁剪窗口内的可见部分。
多边形裁剪在许多应用中都有广泛的应用,例如计算机辅助设计、游戏开发和计算机动画等。
本报告将介绍多边形裁剪的原理、算法和优化技术等内容。
多边形裁剪的基本原理是确定多边形在裁剪窗口的哪一部分是可见的,然后通过一些几何运算来截取多边形的可见部分。
多边形裁剪有两个主要的方法:线段裁剪和多边形裁剪。
线段裁剪是指对多边形的边进行裁剪,而多边形裁剪是指对整个多边形进行裁剪。
多边形裁剪的算法有许多种,其中比较常用的有Cohen-Sutherland裁剪算法和Liang-Barsky裁剪算法。
Cohen-Sutherland算法是一种用于线段裁剪的算法,它通过判断线段与裁剪窗口的位置关系来确定线段是否需要裁剪。
Liang-Barsky算法是一种用于多边形裁剪的算法,它通过计算多边形边界与裁剪窗口的交点来确定多边形需要裁剪的部分。
除了基本的多边形裁剪算法外,还有一些优化技术可以提高多边形裁剪的效率。
其中之一是使用边界框来提前判断多边形是否与裁剪窗口相交,从而减少不必要的计算量。
另一个优化技术是使用扫描线算法来处理多边形内部的裁剪,以提高裁剪效率。
此外,还可以利用并行计算来加速多边形裁剪的过程。
多边形裁剪的应用非常广泛。
在计算机辅助设计中,多边形裁剪可以用于剪裁复杂的几何图形,以提高绘制的效果和性能。
在游戏开发中,多边形裁剪可以用于处理游戏中的可见性问题,从而提高游戏的渲染效果和帧率。
在计算机动画中,多边形裁剪可以用于对动画中的对象进行裁剪,以实现更逼真的效果。
综上所述,多边形裁剪是计算机图形学中的一个重要技术,用于确定多边形在给定的裁剪窗口内的可见部分。
它有多种算法和优化技术可供选择,可以应用于各种领域,如计算机辅助设计、游戏开发和计算机动画等。
多边形裁剪的研究和应用将为计算机图形学的发展提供重要支持。
weiler-atherton多边形裁剪算法

weiler-atherton多边形裁剪算法weileratherton多边形裁剪算法,又称为weiler-atherton算法,是一种用于对多边形进行裁剪的算法。
它可以被用于计算机图形学中的裁剪任务,如可视化、图像处理和计算机辅助设计等领域。
本文将详细介绍weileratherton多边形裁剪算法的原理、步骤和实现方法。
1. 算法原理:weileratherton多边形裁剪算法是基于边界点的引入和处理的。
该算法将两个多边形相互之间进行裁剪,并生成裁剪结果。
算法使用四个边界点集合,分别为输入多边形的边界点集合(输入多边形顶点经过一系列处理得到),裁剪多边形的外部边界点集合和内部边界点集合,以及裁剪结果的边界点集合。
2. 算法步骤:weileratherton多边形裁剪算法的具体步骤如下:(1) 初始化:创建输入多边形的边界点集合、裁剪多边形的外部边界点集合和内部边界点集合,并将输入多边形的边界点添加至外部边界点集合中。
(2) 遍历输入多边形的每条边:对于输入多边形的每条边,判断其与裁剪多边形的相交情况。
(3) 相交情况处理:若相交情况为内部相交或外部相交,则根据交点生成新的内部边界点,并添加至相应的边界点集合中。
(4) 构造裁剪结果:根据输入多边形的边界点集合和裁剪多边形的内部边界点集合,生成裁剪结果的边界点集合。
(5) 根据边界点集合构造裁剪结果:根据裁剪结果的边界点集合,绘制裁剪结果多边形。
3. 算法实现:weileratherton多边形裁剪算法的实现可以使用编程语言来完成。
一种常用的实现方法是通过遍历输入多边形的每个边,利用线段与裁剪多边形的边界的相交情况判断是否产生交点,并根据交点生成新的边界点。
具体的实现步骤如下:(1) 初始化输入和裁剪多边形的边界点集合。
(2) 遍历输入多边形的每条边,对于每条边,判断其与裁剪多边形的每条边的相交情况。
(3) 根据相交情况,判断是否生成交点,如果有生成交点,则根据交点生成新的边界点,并添加至相应的边界点集合中。
具有拓扑关系的任意多边形裁剪算法

具有拓扑关系的任意多边形裁剪算法拓扑关系是指在空间中,几何对象之间的相对位置和连接关系。
任意多边形裁剪算法是指对于两个多边形A和B,确定A相对于B的位置关系,并将A裁剪成相对于B的部分。
常用的具有拓扑关系的任意多边形裁剪算法有Sutherland-Hodgman算法和Weiler-Atherton算法。
Sutherland-Hodgman算法是一种简单而直观的裁剪算法,它以多边形A为基础,对多边形A的每条边进行裁剪,最终得到所需的裁剪结果。
算法步骤如下:1.对于裁剪窗口的每条边界,确定其相对于多边形A的左侧。
2.对多边形A的每条边进行裁剪处理,生成新的顶点序列。
3.重复步骤2,直到对所有的边界完成处理。
4.返回裁剪结果。
其中,对于多边形A的每条边进行裁剪处理的具体步骤如下:1.对于多边形A的每条边,判断边的起点和终点是否在裁剪窗口内。
2.如果起点和终点都在窗口内,则将边加入新的顶点序列。
3.如果起点在窗口内,而终点在窗口外,则计算边与窗口边界的交点,并将交点加入新的顶点序列。
4.如果起点在窗口外,而终点在窗口内,则计算边与窗口边界的交点,并将交点作为起点加入新的顶点序列。
5.如果起点和终点都在窗口外,则忽略这条边。
Sutherland-Hodgman算法的优点在于简单易懂,对于凸多边形和凹多边形都适用,但由于其每条边都需要进行裁剪处理,效率较低。
Weiler-Atherton算法是一种基于点集的裁剪算法,它将两个多边形视为点的集合,并通过点集之间的拓扑关系进行裁剪操作。
算法步骤如下:1.对于多边形A和多边形B,找到它们的交点。
2.根据交点和各自的顺时针或逆时针顺序,将交点按序列分别加入多边形A和多边形B的顶点序列。
3.对多边形A和多边形B的顶点序列进行裁剪处理,得到裁剪结果。
Weiler-Atherton算法的优点在于避免了对每条边进行裁剪的操作,对于复杂多边形的裁剪效果好,但实现较为复杂。
以上是具有拓扑关系的任意多边形裁剪算法的简要介绍。
weiler-atherton多边形裁剪算法 -回复

weiler-atherton多边形裁剪算法-回复什么是Weiler-Atherton多边形裁剪算法?Weiler-Atherton多边形裁剪算法是一种用于计算两个多边形的相交部分的算法。
该算法可以确定两个多边形之间的交集,并生成裁剪后的多边形。
该算法是由Weiler于1977年提出,并由Atherton稍后改进而得名。
它是一种基于点的算法,通过遍历多边形的顶点和边缘来确定它们之间的交集。
Weiler-Atherton多边形裁剪算法非常适用于计算计算机图形学中的裁剪操作,例如裁剪线段、多边形或曲线。
它可以用于裁剪2D和3D场景中的对象,以提高性能并减少渲染的计算量。
下面将为您详细介绍Weiler-Atherton多边形裁剪算法的具体步骤。
步骤1:确定裁剪区域首先,需要定义一个裁剪区域,它是一个多边形,用于裁剪目标多边形。
裁剪区域可以是任何形状,包括凸多边形和凹多边形。
步骤2:确定多边形边缘与裁剪区域的交点接下来,需要遍历目标多边形的所有边缘,并找出它们与裁剪区域的交点。
对于每个边缘,需要检查它是否与裁剪区域相交,并找出相交点的坐标。
步骤3:确定裁剪区域边缘与多边形的交点然后,需要遍历裁剪区域的所有边缘,并找出它们与目标多边形的交点。
同样地,对于每个边缘,需要检查它是否与目标多边形相交,并找出相交点的坐标。
步骤4:确定裁剪多边形的内、外部点在这一步中,需要根据目标多边形和裁剪区域的交点,确定哪些点位于裁剪多边形的内部,哪些点位于外部。
一种常用的方法是使用奇偶规则,根据交点的数量判断点位于多边形内部还是外部。
步骤5:生成裁剪多边形最后,根据确定的内、外部点,生成裁剪后的多边形。
可以通过连接内部点和交点来生成裁剪后的多边形。
需要注意的是,由于Weiler-Atherton多边形裁剪算法是基于点的,因此在处理封闭多边形时需要考虑交点的顺序。
如果交点的顺序不正确,可能会导致生成的裁剪多边形出现错误。
总结Weiler-Atherton多边形裁剪算法是一种用于计算两个多边形相交部分的算法。
具有拓扑关系的任意多边形裁剪算法

具有拓扑关系的任意多边形裁剪算法中国的地理空间数据处理发展迅速,形状分析技术受到技术界的广泛应用。
多边形裁剪是一种常见的形状分析技术,它可以用来从空间数据集中提取出多边形范围内的空间对象,以便进行深入分析和分类处理,同时也可以用来测量多边形的面积和周长等。
具有拓扑关系的多边形裁剪算法是多边形裁剪的一种,它可以从拓扑关系的多边形中提取出正确的多边形边界,而不用考虑多边形的内部点和边的连接关系。
这种算法的特点是,可以对多边形的边缘点和其他类型的点进行分类,考虑到其它多边形的拓扑关系,分析出能够完整描述多边形的边界,从而为后续空间数据处理提供了一种有效的算法。
具有拓扑关系的多边形裁剪算法的基本原理是:首先通过计算多边形内部点和边缘点之间的拓扑关系,对所有多边形内点进行分类;然后针对每个分类,采用多边形切割算法,将一个多边形分割成多个小的多边形,每个小的多边形的定义由多边形的点和边组成;最后,根据分类后的多边形点和边之间的拓扑关系,对经过分割的多个多边形边界重新进行切割,完成裁剪。
该算法与其他常见的多边形裁剪算法相比,有着明显的优势。
第一,由于该算法采用多边形分割算法和拓扑关系分析算法相结合,它能够有效地处理多边形内部点和边缘点之间的拓扑关系,从而达到较高的准确性和可靠性;第二,该算法的实现不需要大量的预处理,复杂度较低,从而大大减少了算法执行时间;第三,该算法能够有效处理多边形中出现的不闭合、重叠等异常状况,从而得到更加准确的结果。
实际应用中,该算法可以用来自动提取多边形边界,从而检测出满足特定要求的多边形,从而为后续多边形分析和处理提供可靠的基础数据。
此外,该算法也可以用来检测多边形的内部是否存在大量的噪声,以便及时采取措施将其消除,保证多边形的精确性和准确性。
总之,具有拓扑关系的多边形裁剪算法是一种有效而可靠的多边形裁剪算法,可以有效地从复杂的多边形中提取出正确的多边形边界,为地理空间数据处理提供有效的技术支持。
weiler-atherton多边形裁剪算法 -回复

weiler-atherton多边形裁剪算法-回复标题:深入理解Weiler-Atherton多边形裁剪算法一、引言在计算机图形学中,多边形裁剪是一个常见的操作,用于处理复杂的几何形状。
其中,Weiler-Atherton多边形裁剪算法是一种广泛应用的算法,它能够有效地处理任意两个二维多边形之间的相交、相减和相加操作。
本文将详细解析Weiler-Atherton多边形裁剪算法的步骤和原理。
二、预备知识在深入探讨Weiler-Atherton算法之前,我们需要了解一些基本的预备知识。
1. 多边形表示:多边形通常通过其顶点序列来表示,每个顶点由其在笛卡尔坐标系中的(x, y)坐标确定。
2. 十字产品:在二维空间中,两个向量的十字产品可以用来判断它们的方向关系。
如果结果为正,那么一个向量在另一个向量的逆时针方向;如果结果为负,那么一个向量在另一个向量的顺时针方向;如果结果为零,那么两个向量平行或重合。
三、Weiler-Atherton多边形裁剪算法概述Weiler-Atherton算法主要包括以下四个步骤:1. 分析阶段:确定输入多边形的边缘和顶点的关系。
2. 前处理阶段:生成新的边和顶点,以准备后续的裁剪操作。
3. 裁剪阶段:根据分析阶段的结果,进行实际的裁剪操作。
4. 后处理阶段:清理和优化输出的多边形。
四、详细步骤解析1. 分析阶段:在这个阶段,我们需要对输入的两个多边形A和B的所有边进行遍历,确定每条边与其他边的关系。
具体来说,我们需要找到以下四种情况:- 共线边:两条边平行或重合。
- 相交边:两条边在某个点相交。
- 包含边:一条边完全包含在另一条边上。
- 不相交边:两条边不相交且不共线。
对于每种情况,我们都需要记录下相应的信息,以便在后续阶段使用。
2. 前处理阶段:在这个阶段,我们需要根据分析阶段的结果生成新的边和顶点。
具体来说,我们需要执行以下操作:- 对于每一对相交的边,我们在相交点处生成一个新的顶点,并连接这个新顶点与原来的两个顶点,形成两条新的边。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
#python实现可视化的多边形裁剪
import matplotlib.pyplot as plt
import copy
import math
from tkinter import *
def cross_point(line1,line2,winx,winy):#计算交点函数
year1 = copy.deepcopy(line1)
pop1 = copy.deepcopy(line2)
winx1 = copy.deepcopy(winx)
winy1 = copy.deepcopy(winy)
node_class = []
minx = min(winx)
maxx = max(winx)
miny = min(winy)
maxy = max(winy)
count = 0
for i in range(len(line1)-1):
count1=0
x1=line1[i]#取四点坐标
y1=line2[i]
x2=line1[i+1]
y2=line2[i+1]
k1=(y2-y1)*1.0/(x2-x1)#计算k1,由于点均为整数,需要进行浮点数转化
b1=y1*1.0-x1*k1*1.0#整型转浮点型是关键
nodey = k1*minx*1.0+b1*1.0
if (y1<=nodey<=y2 or y2<=nodey<=y1) and (miny<=nodey<=maxy) and ([maxx,nodey] not in node_class):
node_class.append([minx,nodey])
count=count+1
count1=count1+1
nodey1 = k1*maxx*1.0+b1*1.0
if (y1<=nodey1<=y2 or y2<=nodey1<=y1) and (miny<=nodey1<=maxy) and ([maxx,nodey1] not in node_class):
node_class.append([maxx,nodey1])
count=count+1
count1=count1+1
nodex = (miny*0.1 - b1*0.1)/(k1*0.1)
if (minx<=nodex<=maxx) and (x1<=nodex<=x2 or x2<=nodex<=x1) and ([nodex,miny] not in node_class):
node_class.append([nodex,miny])
count=count+1
count1=count1+1
nodex1 = (maxy*0.1 - b1*0.1)/(k1*0.1)
if (minx<=nodex1<=maxx) and (x1<=nodex1<=x2 or x2<=nodex1<=x1) and ([nodex1,maxy] not in node_class):
node_class.append([nodex1,maxy])
count=count+1
count1=count1+1
print(count1)
if count1 == 1:
year1.insert(i+count,node_class[count-1][0])
pop1.insert(i+count,node_class[count-1][1])
if count1 ==2:
if (math.fabs(node_class[count-2][0]-x1)>math.fabs(node_class[count-1][0]-x1)): n = node_class[count-2]
node_class[count-2] = node_class[count-1]
node_class[count-1] = n
year1.insert(i+count-1,round(node_class[count-2][0],5))
pop1.insert(i+count-1,node_class[count-2][1])
year1.insert(i+count,node_class[count-1][0])
pop1.insert(i+count,node_class[count-1][1])
print(year1,pop1,node_class)
return year1,pop1
def line(year,pop,year1,pop1,x,y):
minx = min(x)
maxx = max(x)
miny = min(y)
maxy = max(y)
print(minx,maxx,miny,maxy)
linex = []
liney = []
b=[]
for i in range (len(year1)-1):
if (minx<=year1[i]<=maxx) and (miny<=pop1[i]<=maxy):
b.append(i)
linex.append(year1[i])
liney.append(pop1[i])
linex.append(year1[b[0]])
liney.append(pop1[b[0]])
print(linex,liney)
return linex,liney
def run1(n,m,a,b):
n = int(n)
m = int(m)
a = int(a)
b = int(b)
year = [4,20,25,15,7,4]
pop = [2,3,1,6,5,2]
year1 = []
year2 = []
x = [n+a,n,n,n+a,n+a]
y = [m+b,m+b,m,m,m+b]
year1,pop1 = cross_point(year,pop,x,y)
linex,liney=line(year,pop,year1,pop1,x,y)
plt.plot(year,pop)
plt.plot(x,y,'r')
plt.plot(linex,liney,'b')
plt.show()
root = Tk()
root.geometry('500x240')
root.title('多边形裁剪')
lb1 = Label(root, text='请输入裁剪框右下角坐标,宽,高') lb1.place(relx=0.1, rely=0.1, relwidth=0.8, relheight=0.1)
inp1 = Entry(root)
inp1.place(relx=0.1, rely=0.2, relwidth=0.15, relheight=0.1) inp2 = Entry(root)
inp2.place(relx=0.3, rely=0.2, relwidth=0.15, relheight=0.1) inp3 = Entry(root)
inp3.place(relx=0.5, rely=0.2, relwidth=0.15, relheight=0.1) inp4 = Entry(root)
inp4.place(relx=0.7, rely=0.2, relwidth=0.15, relheight=0.1) # 方法-直接调用run1()
btn1 = Button(root, text='裁剪', command=lambda:run1(inp1.get(), inp2.get(),inp3.get(),inp4.get()))
btn1.place(relx=0.35, rely=0.4, relwidth=0.3, relheight=0.1)
root.mainloop()。