精华内容
下载资源
问答
  • Weiler Atherton 任意多边形裁剪 Sutherland Hodgeman 算法解决了裁剪窗口为凸多边形窗口的...Weiler Atherton 任意多边形裁剪算法描述 在算法中裁剪窗口被裁剪多边形可以是任意多边形凸的凹的内角大于 180 o 甚至是带
  • 使用VS 2017实现多边形裁剪算法,此资源包括完整的项目文件,可以直接使用。此代码仅供学习交流使用。
  • 基于MFC的计算机图形学中点裁剪算法多边形裁剪算法
  • 多边形裁剪算法

    2015-04-19 15:30:10
    多边形裁剪算法,还不错,学到挺多的,共享给大家看看
  • 圆对多边形裁剪算法设计与实现Python3.5源码实现
  • 多边形裁剪算法.rar

    2019-06-17 11:02:57
    此代码为多边形裁剪算法,为光栅图形学算法续,此代码可以直接运行
  • 经典多边形裁剪算法 Sutherland-Hodgman的VC++实现 经典多边形裁剪算法 Sutherland-Hodgman的VC++实现
  • 逐次多边形裁剪算法算法的思想发窗口四条边界单一逐次对多边形进行裁剪,每次用窗口的一条边界(包括延长线)对要裁剪的多边形进行裁剪,裁剪时,顺序地测试多边形各顶点,保留边界内侧的顶点,删除外侧的顶点,同时,...
  • 计算机图形学(简单多边形裁剪算法)简单多边形裁剪算法摘要:多边形裁剪算法与线性裁剪算法具有更广泛的实用意义,因此它是目前裁剪研究的主要课题。本文主要介绍了一种基于多边形顶点遍历的简单多边形裁剪算法,它...

    计算机图形学(简单多边形裁剪算法)

    简单多边形裁剪算法

    摘要:多边形裁剪算法与线性裁剪算法具有更广泛的实用意义,因此它是目前裁剪研究的主要课题。本文主要介绍了一种基于多边形顶点遍历的简单多边形裁剪算法,它有效降低了任意多边形裁剪复杂度。通过记录交点及其前驱、后继信息,生成结果多边形,该算法简化了交点的数据结构,节省了存储空间,降低了算法的时间复杂度,具有简单、易于编程实现、运行效率高的特点。

    关键词:多边形裁剪;交点;前驱;后继;矢量数组

    一、技术主题的基本原理

    简单多边形裁剪算法综合考虑现有多边形裁剪算法的优缺点,它是一种基于多边形顶点遍历来实现简单多边形裁剪工作的。其主要的原理是遍历多边形并把多边形分解为边界的线段逐段进行裁剪,输出结果多边形。

    二、发展研究现状

    近年来,随着遥感绘图、CAD辅助设计、图象识别处理技术的发展,图形裁剪算法从最初在二维平面上线和图形的裁剪扩展到三维空间里体和场的裁剪,国内外相继提出不少行之有效的算法,但越来越复杂的图形和计算也对算法的速度和适用性提出了越来越高的要求。因此,不断简化算法的实现过程,完善细节处理,满足大量任意多边形的裁剪也就成了当今算法研究的焦点之一。 CrossPointIndex{

    int nPredecessorlndex=0//前驱序号

    int nSuccessorIndex=0//后继序号

    }

    说明:CrossPointIndex用于记录交点在多边形中的前驱与后继的序号信息,以及记录同一交点在两个多边形中顶点序号。即若P为多边形S与多边形C的交点,为了表示P在S和C中为同一点,则可用CrossPointIndex记录用nPredecessorIndex记录P在S中的序号、用nSuccessorIndex记录P在C中序号。

    3)线段的数据结构如下:

    Segment{

    int nStartIndex=0

    int nEndIndex=0

    int* pIndexes;

    int nIndexCount;

    }

    说明:Segment表示多边形在另一个多边形内(外)的线段,nStartaIndex为Segment起始顶点的序号,nEndIndex为Segment终止顶点的序号,pIndexes为起始顶点与终止顶点之间的顶点序号集合,nIndexCount为pIndexes中元素个数。

    3、算法设计

    1)第一阶段:

    采用射线法计算并判断S(或C)在C(或S)内,并修改S(或C)顶点Vertex的IsInPolygon的值。

    由于射线可以任意选取,为了方便可以将射线定为从被测点开始射向X轴坐标正方向的水平射线。由于多边形的一条边与射线的交点最为1个,因此可以循环遍历每条边并判断边与射线有无交点,若有交点,计数器加1,。最后得到的计数器的值即多边形与射线的交点个数。若交点个数为奇数,则被测点在多边形内部,若交点个数为偶数,则被测点在多边形外部。对于多边形的任意一条边,为了尽量避免求交点时用到乘除法,将判断该边与射线有无交点的算法可以包含3步:

    判断边的两个顶点是否均在被测点左方或者下方或者上方,若是则无交点,返回假并退出;

    若不满足第一条原则,且满足两个顶点均在被测点右方,则一定有顶点,返回真并退出;

    若以上两条都不满足,求出边与射线的交点,比较交点的X坐标与被测点的X坐标,若前者大于后者则返回真并退出,否则返回假并退出。

    设边的两个顶点坐标分别为(x1,y1)和(x2,y2),则边的直线方程可写为:

    X=m(y-y1)+x1

    其中,m=(x2-x1)/(y2-y1)为直线斜率的倒数。使用该方程时需要两次乘除法,效率较低。为了尽量避免求交点,第三部可以采用二分法将边分成两段,对其中两个端点分别跨过射线两侧的边段重新进行以上第一步和第二步的判断,若以上两步中还没有推出,再继续二分,直到能够被第一步和第二步判断并退出。采用二分法则避免了乘除法,算法中只有除2运算和一些判断,适合于硬件处理,二分法的循环次数一般较少,当被测点位于边上时,循环次数组最多。

    其具体的算法如下:(Point为被测点变量,point1、point2为一条边的两个端点变量)

    If(piont2.y

    {

    P1=point2;

    p2=point1

    }

    Else

    {

    p1=point1;

    p2=point2;

    }

    if(p1.y>point.y||p2.y

    Return false;//无交点

    Else If(p1.x

    Return false ;无交点

    Else if (p1.x>point.x&&p2.x>point.x)Return

    展开全文
  • 1000-9825/2003/14(04)0845 ©2003 Journal of Software 软 件 学 报 Vol.14, No.4一个有效的多边形裁剪算法1+ 2 2刘勇奎 , 高 云 , 黄有群1(大连民族学院 计...

    1000-9825/2003/14(04)0845 ©2003 Journal of Software 软 件 学 报 Vol.14, No.4

    一个有效的多边形裁剪算法

    1+ 2 2

    刘勇奎 , 高 云 , 黄有群

    1(大连民族学院 计算机科学与工程系,辽宁 大连 116600)

    2 (沈阳工业大学 信息科学与工程学院,辽宁 沈阳 110023)

    An Efficient Algorithm for Polygon Clipping

    1+ 2 2

    LIU Yong-Kui , GAO Yun , HUANG You-Qun

    1(Department of Computer Science and Engineering, Dalian Nationalities University, Dalian 116600, China)

    2(College of Information Science and Engineering, Shenyang University of Technology, Shenyang 110023, China)

    + Corresponding author: Phn: 86-411-7612616 ext 4442, Fax: 86-411-7612616 ext 4442, E-mail: ykliu@

    Received 2001-07-31; Accepted 2001-10-17

    Liu YK, Gao Y, Huang YQ. An efficient algorithm for polygon clipping . Journal of Software, 2003,14(4):

    845~856.

    Abstract: Polygon clipping is more often used than line clipping in practice, so it is the main subject in clipping

    research now. An efficient algorithm for polygon clipping which processes general polygons including concave

    polygons and polygons with holes inside is presented in this paper. This algorithm can be used to calculate not only

    intersection (clipping) but also set-theoretic differences and union of two polygons. It is based on some new

    techniques proposed in this paper. Firstly, singly linked lists are used as the data structure of this algorithm rather

    than doubly linked lists or trees as other algorithms use, so less memory space and running time are required.

    Secondly, the relationship between the entry and exit points on the two polygons is found, which, with the

    reasonable operations on the lists, reduces the times that the lists are traversed and allows the polygon to be input

    clockwise or counterclockwise. Lastly, findi

    展开全文
  • 用矩形来裁剪任意多边形,暂时没有考虑交点是多边形或矩形顶点的情况。
  • 在 pycharm 加 pyqt5环境中开发,python实现Sutherland-Hodge 逐次裁剪法(多边形裁剪)。 有优美的 UI界面
  • 多边形裁剪算法java

    2021-04-13 10:44:43
    Weiler-Atherton 任意多边形裁剪 Sutherland-Hodgeman 算法解决了裁剪窗口为凸多边形窗口的问题,但一些应用... Sutherland—Hodgman 多边形裁剪算法思想 该算法的基本思想是每次用窗口的一条边界及其延长线来裁剪多...

    Weiler-Atherton 任意多边形裁剪 Sutherland-Hodgeman 算法解决了裁剪窗口为凸多边形窗口的问题,但一些应用需要涉及 任意多边形窗口(含凹多边形窗口)的裁剪。Weiler-......

    多边形裁剪的 Sutherland—Hodgman 算法 1>. Sutherland—Hodgman 多边形裁剪算法思想 该算法的基本思想是每次用窗口的一条边界及其延长线来裁剪多边形的各边。 多边形......

    25 Dec. 2005 文章编号 : 1001 - 9081 (2005) 12Z - 0421 - 03 用 VC + +实现的任意多边形裁剪算法李海姣 ,张维锦 (华东交通大学 土木建筑学院 ,江西 ......

    一个有效的多边形裁剪算法 刘勇奎;高云;黄有群 【期刊名称】《软件学报》 【年(...

    Sutherland—Hodgman多边形裁剪算法思想该算法的基本思想是每次用窗口的一条边界及其延长线来裁剪多边形的各边。多边形通常由它的顶点序列来表示,经过裁剪规则针对某条......

    . 裁剪算法详解在使用计算机处理图形信息时,计算机部存储的图形往往比较大,而屏幕...

    多边形裁剪的 Sutherland— Hodgman 算法 1>. Sutherland— Hodgman 多边形裁剪算法思想 该算法的基本思想是每次用窗口的一条边界及其延长 线来裁剪多边形的各边。 ...

    ·s-a.o唱.cnTel:+86.10.62661041 任意多边形窗口的圆裁剪算法① 杨琴1,李宁2,王亮亮1 1(新疆师范高等专科学校,乌鲁木齐830043)2dE京邮电大学世纪学院移动媒体......

    和待裁剪直线段(或多边形),采用不同颜色突出 显示裁剪结果 三、实验结果 四、实验分析和总结 Sutherland-Hodgman 多边形裁剪算法是将原多边形进行左右下上四次裁剪。...

    指导教师 2014 年 1 月 13 日 Weiler-Atherton 多边形裁剪 Weiler-Atherton 算法是一种通用的多边形算法, 因此该过程可以用标准位 置的裁剪窗口去裁剪多边形填充......

    任意多边形窗口的圆裁剪算法 杭后俊;孙丽萍 【期刊名称】《计算机技术与发展》 【...

    (肛】220【2000)11一1166一03 具有拓扑关系的任意多边形裁剪算法 吴兵 尹伟强 凌海滨 (北京大学计算机研究所,文字信息处理技术国家重点实验室北京Iou87I) 摘要:多......

    刘·计算技术与自动化· 诚等: 一种改进的多边形裁剪算法的设计 一种改进的多边形裁剪算法的设计刘 诚, 王育勤, 王中尚郑州 ( 解放军信息工程大学理学院, 河南......

    所以一般采用先裁剪再扫描转换的方法。 (a)裁剪前 图 1.1 多边形裁剪 (b) 裁剪后 1 直线段裁剪直线段裁剪算法比较简单,但非常重要,是复杂图元裁剪的基础。...

    贵州大学实验报告学院: 计算机科学与信息学院 姓名 实验时间 实验项目名称 实验 掌握直线段的裁剪算法以及多边形的裁剪算法 目的实验要求 Cohen-Sutherland 直线剪裁算法......

    第13卷第12期2008年1 2月 中国图象图形学报 JournalofImageandGraphics V01.13.No.12Dee..2008 一种新的矢量数据多边形的快速裁剪算法 张钧”J’王 鹏” ’......

    平面多边形裁剪算法评述_电子/电路_工程科技_专业资料。裁剪是计算机图形学中许多重要问题的基础,本文总结了多种多边形裁剪算法并加以评述. ......

    1.1 线段裁剪算法 5.1.2 多边形裁剪算法 确定图形中哪些部分落在显示区之...

    3.4 Sutherland-Hodgman 算法进行多边形裁剪 .. 错误!未定义书签。 3.4.1 Sutherland—Hodgman 多边形裁剪算法步骤 错误!未定义书签。 3.5 将画线、 画圆、 ......

    GIS 环境中一种高效的多边形剪裁方法 蔡松露;戚正伟;梁阿磊 【期刊名称】《计算机应用与软件》 【年(卷),期】2010(027)003 【摘要】在 Weiler 算法的基础上提出......

    展开全文
  • 本资源包含了Cohen-Sutherland算法、Liang-Barsky算法实现直线段裁剪以及自创的多边形裁剪(老师都没查出BUG)的cpp源代码和实验报告。重点是多边形裁剪,400多行代码,最终实现了任意多边形裁剪,下载即可运行
  • SutherlandHodgman多边形裁剪算法 C++ 有详细注释
  • 二维图形裁剪算法: 参考博客: https://blog.csdn.net/m0_46359746/article/details/106392352 Liang-Barsky 线段裁剪算法: //Liang-Barsky 线段裁剪算法 class wcPt2D { public: GLfloat x,y; public: /* ...

    二维图形裁剪算法:

    参考博客:

    https://blog.csdn.net/m0_46359746/article/details/106392352

    image-20200930153345235

    Liang-Barsky 线段裁剪算法:

    //Liang-Barsky 线段裁剪算法
    
    class wcPt2D {
    
    public:
    	GLfloat x,y;
    public:
    	/*
    Default Constructor:initalize position 48(0.0,0.0).*/
    	wcPt2D(){
    		x=y=0.0;
    	}
    
    	wcPt2D(GLfloat nx, GLfloat ny): x(nx), y(ny){}
    
    	wcPt2D(const wcPt2D& pCopy){
    		this->x=pCopy.x;
    		this->y=pCopy.y;
    	}
    
    	void setCoords(GLfloat xCoord,GLfloat yCoord){
    		x = xCoord;
    		y = yCoord;
    		return ;
    	}
    
    	wcPt2D& operator= (wcPt2D p2){
    		this->x=p2.getx ();
    		this->y=p2.gety ();
    		return *this;
    	}
    
    
    	GLfloat getx()const{
    		return x;
    	}
    	GLfloat gety ( ) const {
    		return y;
    	}
    };
    
    inline GLint round(const GLfloat a){
    	return GLint(a + 0.5);
    }
    
    GLint clipTest(GLfloat p, GLfloat q, GLfloat * u1, GLfloat *u2){
    	GLfloat r;
    	GLint returnValue=true;
    	if(p<0.0){
    		r=q/p;
    		if(r>*u2){
    			returnValue = false;
    		}else if(r>*u1){
    			*u1=r;
    		}
    	}else{
    		if(p>0.0){
    			r=q/p;
    			if(r<*u1){
    				returnValue=false;
    			}else if(r<*u2){
    				*u2=r;
    			}
    		}else{
    
    			if(q<0.0){
    				returnValue=false;
    			}
    		}
    	}
    	return (returnValue);
    }
    
    
    void lineClipLiangBrask(wcPt2D winMin, wcPt2D winMax, wcPt2D p1, wcPt2D p2){
    	GLfloat u1=0.0, u2=1.0, dx=p2.getx ()-p1.getx (),dy;
    	if(clipTest (-dx, p1.getx ()-winMin.getx (),&u1, &u2)){
    		if(clipTest (dx, winMax.getx ()-p1.getx (),&u1, &u2)){
    			dy=p2.gety ()-p1.gety ();
    			if(clipTest (-dy, p1.gety ()-winMin.gety (), &u1, &u2)){
    				if(clipTest (dy,winMax.gety ()-p1.gety (),&u1, &u2)){
    					if(u2<1.0){
    						p2.setCoords(p1.getx ()+u2*dx,p1.gety ()+u2*dy);
    					}
    					if(u1>0.0){
    						p1.setCoords(p1.getx ()+u1*dx, p1.gety ()+u1*dy);
    					}
    					lineDDA (round(p1.getx ()), round (p1.gety ()),round(p2.getx ()),round(p2.gety ()));
    				}
    			}
    		}
    	}
    
    	return ;
    }
    

    display:

    //	Liang-Barsky线段裁剪算法
    //初始直线
    glColor3f (0.0,0.0,1.0);
    lineBres (0,100,400,300);
    glFlush ();
    
    //可视化边界:
    glColor3f(1.0,0.0,0.0);
    lineBres (100,100,100,300);
    lineBres (100,100,300,100);
    lineBres (300,300,100,300);
    lineBres (300,300,300,100);
    
    
    glColor3f (0.0,1.0,0.0);
    lineClipLiangBrask (wcPt2D(100,100), wcPt2D(300, 300), wcPt2D(0,100),wcPt2D(400, 300));
    glFlush ();
    

    Liang-Barsky 多边形裁剪算法:

    //-----------------------------------------
    //Liang-Barsky 线段裁剪算法
    
    class wcPt2D {
    
    public:
    	GLfloat x,y;
    public:
    	/*
    Default Constructor:initalize position 48(0.0,0.0).*/
    	wcPt2D(){
    		x=y=0.0;
    	}
    
    	wcPt2D(GLfloat nx, GLfloat ny): x(nx), y(ny){}
    
    	wcPt2D(const wcPt2D& pCopy){
    		this->x=pCopy.x;
    		this->y=pCopy.y;
    	}
    
    	void setCoords(GLfloat xCoord,GLfloat yCoord){
    		x = xCoord;
    		y = yCoord;
    		return ;
    	}
    
    	wcPt2D& operator= (wcPt2D p2){
    		this->x=p2.getx ();
    		this->y=p2.gety ();
    		return *this;
    	}
    
    
    	GLfloat getx()const{
    		return x;
    	}
    	GLfloat gety ( ) const {
    		return y;
    	}
    };
    
    inline GLint round(const GLfloat a){
    	return GLint(a + 0.5);
    }
    
    GLint clipTest(GLfloat p, GLfloat q, GLfloat * u1, GLfloat *u2){
    	GLfloat r;
    	GLint returnValue=true;
    	if(p<0.0){
    		r=q/p;
    		if(r>*u2){
    			returnValue = false;
    		}else if(r>*u1){
    			*u1=r;
    		}
    	}else{
    		if(p>0.0){
    			r=q/p;
    			if(r<*u1){
    				returnValue=false;
    			}else if(r<*u2){
    				*u2=r;
    			}
    		}else{
    
    			if(q<0.0){
    				returnValue=false;
    			}
    		}
    	}
    	return (returnValue);
    }
    
    
    void lineClipLiangBrask(wcPt2D winMin, wcPt2D winMax, wcPt2D p1, wcPt2D p2){
    	GLfloat u1=0.0, u2=1.0, dx=p2.getx ()-p1.getx (),dy;
    	if(clipTest (-dx, p1.getx ()-winMin.getx (),&u1, &u2)){
    		if(clipTest (dx, winMax.getx ()-p1.getx (),&u1, &u2)){
    			dy=p2.gety ()-p1.gety ();
    			if(clipTest (-dy, p1.gety ()-winMin.gety (), &u1, &u2)){
    				if(clipTest (dy,winMax.gety ()-p1.gety (),&u1, &u2)){
    					if(u2<1.0){
    						p2.setCoords(p1.getx ()+u2*dx,p1.gety ()+u2*dy);
    					}
    					if(u1>0.0){
    						p1.setCoords(p1.getx ()+u1*dx, p1.gety ()+u1*dy);
    					}
    					lineDDA (round(p1.getx ()), round (p1.gety ()),round(p2.getx ()),round(p2.gety ()));
    					//					return 2;
    				}
    			}
    		}
    	}
    
    	return ;
    }
    
    int lineClipLiangBrask(wcPt2D winMin, wcPt2D winMax, wcPt2D p1, wcPt2D p2, wcPt2D pOut[]){
    	GLfloat u1=0.0, u2=1.0, dx=p2.getx ()-p1.getx (),dy;
    	if(clipTest (-dx, p1.getx ()-winMin.getx (),&u1, &u2)){
    		if(clipTest (dx, winMax.getx ()-p1.getx (),&u1, &u2)){
    			dy=p2.gety ()-p1.gety ();
    			if(clipTest (-dy, p1.gety ()-winMin.gety (), &u1, &u2)){
    				if(clipTest (dy,winMax.gety ()-p1.gety (),&u1, &u2)){
    					if(u2<1.0){
    						p2.setCoords(p1.getx ()+u2*dx,p1.gety ()+u2*dy);
    					}
    					if(u1>0.0){
    						p1.setCoords(p1.getx ()+u1*dx, p1.gety ()+u1*dy);
    					}
    					pOut[0]=p1;
    					pOut[1]=p2;
    //					lineDDA (round(p1.getx ()), round (p1.gety ()),round(p2.getx ()),round(p2.gety ()));
    					return 2;
    				}
    			}
    		}
    	}
    
    	return 0;
    }
    
    void display(){
    	glClear (GL_COLOR_BUFFER_BIT);
    	//可视化边界:
    	const int minX=100, minY=100, maxX=300, maxY=300;
    	glColor3f(1.0,0.0,0.0);
    	lineDDA (minX,minY,minX,maxY);
    	lineDDA (minX,minY,maxX,minY);
    	lineDDA (maxX,maxY,minX,maxY);
    	lineDDA (maxX,maxY,maxX,minY);
    
    	glColor3f(0.0,1.0,0.0);
    	GLint n=5;
    	wcPt2D pIn[n];
    	pIn[0].setCoords (0,200);
    	pIn[1].setCoords (150,250);
    	pIn[2].setCoords (250,250);
    	pIn[3].setCoords (400,200);
    	pIn[4].setCoords (200,50);
    
    	for(int i=0;i<n;++i){
    		lineDDA (pIn[i].x,pIn[i].y,pIn[(i+1)%n].x,pIn[(i+1)%n].y);
    	}
    
    
    	wcPt2D pOut[20];
    	wcPt2D tempPOut[2];
    	int outCount=0;
    	int flag=0;
    	for(int i=0;i<n;++i){
    		flag=lineClipLiangBrask (wcPt2D(minX,minY), wcPt2D(maxX, maxY), pIn[i],pIn[(i+1)%n],tempPOut);
    		if(flag==2){
    			for(int j=0;j<2;++j){
    				pOut[outCount++]=tempPOut[j];
    			}
    		}
    	}
    
    	glColor3f(0.0,0.0,1.0);
    	int i=1;
    	for(;i<=outCount;++i){
    		lineDDA (pOut[i-1].x,pOut[i-1].y,pOut[i%outCount].x,pOut[i%outCount].y);
    	}
    
    	glFlush ();
    
    
    	return ;
    }
    

    效果:

    image-20201009120216266

    Sutherland-Hodgman多边形裁剪算法

    #define NDEBUG
    #ifndef GLUT_DISABLE_ATEXIT_HACK
    #define GLUT_DISABLE_ATEXIT_HACK
    #endif
    #include <windows.h>
    #include <gl/glut.h>
    #include <math.h>
    #include <stdio.h>
    
    const int windowWidge=600, windowHeight=600;
    
    
    void setPixel(GLint xCoord, GLint yCoord){
    	glBegin (GL_POINTS);
    	glVertex2i (xCoord, yCoord);
    	glEnd();
    }
    
    
    //-----------------------------------------
    
    void lineDDA (int x0, int y0, int xEnd, int yEnd){
    	int dx=xEnd-x0,dy=yEnd-y0,steps,k;
    	float xIncrement,yIncrement,x=x0,y=y0;
    	if(fabs(dx)> fabs(dy)){
    		steps = fabs(dx);
    	}else {
    		steps = fabs(dy);
    	}
    	xIncrement = float(dx)/float(steps);
    	yIncrement = float(dy)/ float(steps);
    	setPixel(round(x),round(y));
    	for(k = 0;k< steps;k++){
    		x += xIncrement;
    		y += yIncrement;
    		setPixel(round(x),round(y));
    	}
    	return ;
    }
    
    
    
    //---------------------------------------------
    //Sutherland-Hodgman多边形裁剪算法
    
    class wcPt2D {
    
    public:
    	GLfloat x,y;
    public:
    	/*
    Default Constructor:initalize position 48(0.0,0.0).*/
    	wcPt2D(){
    		x=y=0.0;
    	}
    
    	wcPt2D(GLfloat nx, GLfloat ny): x(nx), y(ny){}
    
    	wcPt2D(const wcPt2D& pCopy){
    		this->x=pCopy.x;
    		this->y=pCopy.y;
    	}
    
    	void setCoords(GLfloat xCoord,GLfloat yCoord){
    		x = xCoord;
    		y = yCoord;
    		return ;
    	}
    
    	wcPt2D& operator= (wcPt2D p2){
    		this->x=p2.getx ();
    		this->y=p2.gety ();
    		return *this;
    	}
    
    
    	GLfloat getx()const{
    		return x;
    	}
    	GLfloat gety ( ) const {
    		return y;
    	}
    };
    
    
    //枚举类的替代, C++中enum的操作与C有很大不同
    const int Left=0, Right=1, Bottom=2, Top=3;
    
    //typedef enum{
    //	Left, Right, Bottom, Top
    //} Boundary;
    
    using namespace std;
    
    const GLint nClip = 4;
    
    
    //判断点p是否在显示框内
    GLint inside(wcPt2D p, int b, wcPt2D wMin, wcPt2D wMax){
    	int flag=true;
    	switch(b){
    		case Left:{
    			if(p.getx ()<wMin.getx ()){
    				flag=false;
    			}
    			break;
    		}
    		case Right:{
    			if(p.getx ()>wMax.getx ()){
    				flag=false;
    			}
    			break;
    		}
    		case Bottom:{
    			if(p.gety ()<wMin.gety ()){
    				flag=false;
    			}
    			break;
    		}
    		case Top:{
    			if(p.gety ()>wMax.gety ()){
    				flag=false;
    			}
    			break;
    		}
    	}
    	return flag;
    }
    
    //判断向量(p1, p2)是否与边界相交
    GLint cross(wcPt2D p1, wcPt2D p2, int winEdge, wcPt2D wMin, wcPt2D wMax){
    	if(inside (p1,winEdge,wMin,wMax)==inside (p2, winEdge, wMin, wMax)){
    		return false;
    	}else{
    		return true;
    	}
    }
    
    //返回向量(p1, p2)与相应边界的交点
    wcPt2D intersect(wcPt2D p1, wcPt2D p2, int winEdge, wcPt2D wMin, wcPt2D wMax){
    	wcPt2D iPt;
    	GLfloat m;
    
    	if(p1.x!= p2.x){
    		m=(p1.gety ()-p2.gety ())/(p1.getx ()-p2.getx ());
    	}
    	switch (winEdge) {
    		case Left:{
    			iPt.x=wMin.x;
    			iPt.y=p2.y+(wMin.x-p2.x)*m;
    			break;
    		}
    		case Right:{
    			iPt.x=wMax.x;
    			iPt.y=p2.y+(wMax.x-p2.x)*m;
    			break;
    		}
    		case Bottom:{
    			iPt.y=wMin.y;
    			if(p1.x!=p2.x){
    				iPt.x=p2.x+(wMin.y-p2.y)/m;
    			}else{
    				iPt.x=p2.x;
    			}
    			break;
    		}
    		case Top:{
    			iPt.y=wMax.y;
    			if(p1.x!=p2.x){
    				iPt.x=p2.x+(wMax.y-p2.y)/m;
    			}else{
    				iPt.x=p2.x;
    			}
    			break;
    		}
    	}
    	return iPt;
    }
    
    void clipPoint(wcPt2D &p, int winEdge, wcPt2D wMin, wcPt2D wMax, wcPt2D * pOut,
    			   int *cnt, wcPt2D first[], wcPt2D *s){
    	wcPt2D iPt;
    
    	//判断first[winEdge]为nullPtr
    	if(first[winEdge].x==0 && first[winEdge].y==0){
    		first[winEdge]=p;
    	}else{
    		if(cross(p,s[winEdge], winEdge, wMin, wMax)){
    			iPt=intersect (p, s[winEdge], winEdge, wMin, wMax);
    			if(winEdge<Top){
    				clipPoint (iPt, winEdge+1, wMin, wMax, pOut, cnt, first, s);
    			}else{
    				//存交点
    				pOut[*cnt] =iPt;
    				(*cnt)++;
    			}
    		}
    	}
    	s[winEdge]=p;
    	if(inside (p,winEdge, wMin, wMax)){
    		if(winEdge<Top){
    			clipPoint (p, winEdge+1, wMin, wMax, pOut, cnt, first, s);
    		}else{
    			pOut[*cnt]=p;
    			(*cnt)++;
    		}
    	}
    }
    
    void closeClip(wcPt2D wMin, wcPt2D wMax, wcPt2D *pOut, GLint *cnt,
    			   wcPt2D first[],wcPt2D *s){
    	wcPt2D pt;
    	int winEdge;
    	for(winEdge=Left; winEdge<=Top;winEdge++){
    		if(cross(s[winEdge],first[winEdge],winEdge, wMin, wMax)){
    			pt=intersect (s[winEdge], first[winEdge], winEdge, wMin, wMax);
    			if(winEdge<Top){
    				clipPoint (pt, winEdge+1, wMin, wMax, pOut, cnt, first, s);
    			}else{
    				pOut[*cnt]=pt;
    				(*cnt)++;
    			}
    		}
    	}
    }
    
    GLint polygonClipSuthHodg(wcPt2D wMin, wcPt2D wMax, GLint n, wcPt2D *pIn, wcPt2D *pOut){
    	wcPt2D first[nClip] , s[nClip];
    	GLint k, cnt=0;
    	for(k=0;k<n;k++){
    		clipPoint (pIn[k],Left, wMin, wMax, pOut, &cnt, first, s);
    	}
    	closeClip (wMin, wMax, pOut, &cnt, first, s);
    	return cnt;
    }
    
    
    //---------------------------------------------
    
    
    //绘制程序
    void display(){
    
    	//Sutherland-Hodgman多边形裁剪算法
    	glClear (GL_COLOR_BUFFER_BIT);
    	//可视化边界:
    	const int minX=100, minY=100, maxX=300, maxY=300;
    	glColor3f(1.0,0.0,0.0);
    	lineDDA (minX,minY,minX,maxY);
    	lineDDA (minX,minY,maxX,minY);
    	lineDDA (maxX,maxY,minX,maxY);
    	lineDDA (maxX,maxY,maxX,minY);
    
    	//定义多边形的颜色和顶点
    	glColor3f(0.0,1.0,0.0);
    	GLint n=6;
    	wcPt2D pIn[n];
    	pIn[0].setCoords (50,200);
    	pIn[1].setCoords (150,250);
    	pIn[2].setCoords (250,250);
    	pIn[3].setCoords (350,200);
    	pIn[4].setCoords (250,50);
    	pIn[5].setCoords (150,50);
    	//绘制原始多边形
    	for(int i=0;i<n;++i){
    		lineDDA (pIn[i].x,pIn[i].y,pIn[(i+1)%n].x,pIn[(i+1)%n].y);
    	}
    
    	//获取裁剪后的点集
    	wcPt2D pOut[20];
    	int count=polygonClipSuthHodg (wcPt2D(minX,minY),wcPt2D(maxX,maxY),n,pIn,pOut);
    
    	//定义裁剪后的多边形颜色
    	glColor3f(0.0,0.0,1.0);
    	//绘制裁剪后的多边形
    	for(int i=1;i<=count;++i){
    		lineDDA (pOut[i-1].x,pOut[i-1].y,pOut[i%count].x,pOut[i%count].y);
    	}
    
    	glFlush ();
    
    
    	return ;
    }
    
    //初始化绘制
    void init(){
    	glClearColor(1.0,1.0,1.0,0.0);//清除颜色设置
    	glMatrixMode(GL_PROJECTION);//设置投影方式
    	gluOrtho2D (0.0,windowWidge*1.0,0.0,windowHeight*1.0);
    	return ;
    }
    
    int main(int argc, char** argv){
    	glutInit(&argc, argv);//初始化glut
    	glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);//设置显示模式为单缓冲,RGB模式
    	glutInitWindowPosition(0,0);//设置窗口位置
    	glutInitWindowSize(windowWidge,windowHeight);//设置窗口大小
    	glutCreateWindow("lineClipLiangBrask");//设置窗口标题
    	init();
    	glutDisplayFunc(display);
    	glutMainLoop();
    	return 0;
    }
    
    

    效果:

    image-20201009153730699

    展开全文
  • 图形学多边形裁剪,在屏幕客户区绘制多边形(可以用鼠标绘制或直接给定坐标),用代码绘制“裁剪窗口”(也可以使用鼠标绘制裁减窗口)按下“鼠标右键”按钮,利用sutherland-Hodgman算法多边形进行裁剪,用不同...
  • ##关于此仓库Vatti多边形裁剪算法实现,执行多边形布尔运算的并集,交集,差和XOR。 虽然此存储库可用于学术目的。 到目前为止,工作已经完成 适用于自相交多边形和带Kong的多边形。 适用于主题或剪辑TODO中的...
  • openGL-多边形裁剪算法

    千次阅读 2018-03-24 14:58:04
    考虑使用4把刀分别裁剪一个图形。核心思想是,有一个点在扫描整个图形的边界。在扫描过程中,如果从刀的内侧(需要自己定义)到刀的外侧那么就记录当前点p0,当再次从外侧进入内测时,将当前点和记录的p0连起来。...
  • //定义两个临时数组,用于每次裁剪后新生成的多边形顶点 UINT m_nA, m_nB; int x, y; long tem1, tem2; int i; //原始多边形顶点个数 //原始多边形顶点数组的第一个顶点和最后一个顶点相同,因此实际顶点个数...
  • 实验四 编程实现Cohen-Sutherland线段裁剪算法或者Sutherland-Hodgman多边形裁剪算法 对各种情况进行测试,验证算法实现的完整性
  • 算法步骤:(1)确定多边形所占有的最大扫描线数,得到多边形顶点的最小和最大y值(ymin和ymax)。(2)从y=ymin到y=ymax,每次用一条扫描线进行填充。填充过程可分为四个步骤:a.求交:计算扫描线与多边形各边的交点;b...
  • 二维图形的裁剪算法研究与改进机械制造及其自动化, 2011, 硕士【摘要】 本文对计算机图形学中的基础裁剪算法进行了研究。针对目前的conhen-sutherland线段裁剪算法不能有效地判断出线段是否完全在窗口外的问题,...
  • 多边形裁剪算法程序 多边形裁剪算法程序 多边形裁剪算法程序
  • mfc 多边形裁剪算法

    千次阅读 2019-05-19 21:11:58
    多边形裁剪 效果截图: 1.头文件定义: enum Boundary{Left, Right, Bottom, Top}; int cj_line_x1;//裁剪直线时原直线的坐标 int cj_line_x2; int cj_line_y1; int cj_line_y2; CPoint cj_win1;//裁剪...
  • 目录什么是多边形裁剪前置知识算法步骤程序框图代码实现 什么是多边形裁剪 通常来说就是利用多边形来裁剪...Weiler-Atherton多边形裁剪算法 这里着重介绍Weiler-Atherton算法,其余不懂的可以先学会再看。 算法步骤
  • 基于MFC的多边形裁剪算法的实现

    千次阅读 多人点赞 2020-05-09 15:53:48
    基于MFCMFCMFC的多边形裁剪算法的实现 一、新建MFCMFCMFC项目 此处就不再赘述,没有MFCMFCMFC基础的可以先看第一个MFCMFCMFC程序。设置项目名为PolygonClippingPolygonClippingPolygonClipping。【注】:以下没有...
  • 编程实现直线段的裁剪算法(算法任选)正确的程序可以处理各种位置的线段。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,957
精华内容 1,582
关键字:

多边形裁剪算法描述