精华内容
下载资源
问答
  • 多边形裁剪算法

    2012-04-21 14:29:21
    多边形裁剪算法
  • 多边形裁剪算法程序 多边形裁剪算法程序 多边形裁剪算法程序
  • 基于MFC的计算机图形学中点裁剪算法多边形裁剪算法
  • 多边形裁剪算法.rar

    2019-06-17 11:02:57
    此代码为多边形裁剪算法,为光栅图形学算法续,此代码可以直接运行
  • 几何算法源码(包括多边形填充算法, 多边形裁剪算法
  • SutherlandHodgman多边形裁剪算法 C++ 有详细注释
  • Weiler Atherton 任意多边形裁剪 Sutherland Hodgeman 算法解决了裁剪窗口为凸多边形窗口的问题 但一些应用需要涉及 任意多边形窗口含凹多边形窗口的裁剪 Weiler-Atherton 多边形裁剪算法正是满足这种要 求的算法 一...
  • 通用多边形裁剪算法

    2014-03-13 16:23:55
    通用多边形裁剪算法 Project: Generic Polygon Clipper A new algorithm for calculating the difference, intersection, exclusive-or or union of arbitrary polygon sets.
  • 使用VS 2017实现多边形裁剪算法,此资源包括完整的项目文件,可以直接使用。此代码仅供学习交流使用。
  • VC6.0多边形裁剪算法

    热门讨论 2009-05-23 01:23:46
    计算机图形学里的多边形裁剪算法,很好用 VC6.0的编译环境
  • 圆对多边形裁剪算法设计与实现为题的本科生毕业论文
  • 圆对多边形裁剪算法设计与实现Python3.5源码实现
  • 逐次多边形裁剪算法算法的思想发窗口四条边界单一逐次对多边形进行裁剪,每次用窗口的一条边界(包括延长线)对要裁剪的多边形进行裁剪,裁剪时,顺序地测试多边形各顶点,保留边界内侧的顶点,删除外侧的顶点,同时,...
  • 基于MFC的多边形裁剪算法的实现

    千次阅读 2020-05-09 15:53:48
    基于MFCMFCMFC的多边形裁剪算法的实现 一、新建MFCMFCMFC项目 此处就不再赘述,没有MFCMFCMFC基础的可以先看第一个MFCMFCMFC程序。设置项目名为PolygonClippingPolygonClippingPolygonClipping。【注】:以下没有...

    基于MFCMFC的多边形裁剪算法的实现

    一、新建MFCMFC项目

    此处就不再赘述,没有MFCMFC基础的可以先看第一个MFCMFC程序。设置项目名为PolygonClippingPolygonClipping【注】:以下没有特殊说明的,均在PolygonClippingView.cppPolygonClippingView.cpp文件下编程。

    二、宏定义设置

    在适当位置设置宏。

    #define LEFT 1
    #define RIGHT 2
    #define BOTTOM 4
    #define TOP 8
    #define XL 100
    #define XR 300
    #define YT 150
    #define YB 300
    

    三、全局变量初始化

    在适当位置设置全局变量。

    const UINT N = 8;
    CPoint pt[N], pts[N], ptse[N], p[N], ptset1[N];
    int flag=0;
    

    三、窗口初始化

    void CPolygonClippingView::OnDraw(CDC* pDC)
    {
    	CPolygonClippingDoc* pDoc = GetDocument();
    	ASSERT_VALID(pDoc);
    	if (!pDoc)
    		return;
    
    	// TODO: 在此处为本机数据添加绘制代码
    	CPen newpen(PS_SOLID, 1, RGB(255, 0, 0));
    	CPen *old = pDC->SelectObject(&newpen);
    	pDC->Rectangle(CRect(XL, YT, XR, YB));
    	ptset1[0] = CPoint(20, 150);
    	ptset1[1] = CPoint(120, 110);
    	ptset1[2] = CPoint(250, 150);
    	ptset1[3] = CPoint(200, 230);
    	ptset1[4] = CPoint(20, 150);
    	pDC->TextOutW(0, 50, L"双击鼠标左键 , 出现要剪切的多边形 ");
    	pDC->SelectObject(old);
    }
    

    四、多边形初始化

    类向导添加消息中的WM_LBUTTONDBLCLKWM\_LBUTTONDBLCLK处理函数。

    void CPolygonClippingView::OnLButtonDblClk(UINT nFlags, CPoint point)
    {
    	// TODO: 在此添加消息处理程序代码和/或调用默认值
    	CDC* pDC = GetDC();
    	CPen newpen(PS_SOLID, 1, RGB(0, 0, 0));
    	CPen *old = pDC->SelectObject(&newpen);
    	flag = 1;
    	pDC->MoveTo(ptset1[0]);
    	for (int i = 1; i < 5; i++)
    		pDC->LineTo(ptset1[i]);
    	CView::OnLButtonDblClk(nFlags, point);
    }
    

    五、多边形裁剪算法实现

    设置IDIDID_ClippolygonID\_Clippolygon,添加事件处理程序。

    void CPolygonClippingView::OnClippolygon()
    {
    	// TODO: 在此添加命令处理程序代码
    	CDC* pDC = GetDC();
    	CPen newpen(PS_SOLID, 1, RGB(0, 0, 0));
    	CPen *old = pDC->SelectObject(&newpen);
    	if (flag != 1)
    	{
    		MessageBox(L"请先双击鼠标左键", L"警告!");
    	}
    	else
    	{
    		int i, k;
    		int code1, code2;
    		int M = 5;
    		RedrawWindow();
    		k = 0;
    		for (i = 0; i < M; i++)
    		{
    			int c = 0;
    			if (ptset1[i].x < XL)
    				c = 1;
    			else if (ptset1[i].x > XL)
    				c = 0;
    			code1 = c;
    			c = 0;
    			if (ptset1[i + 1].x < XL)
    				c = 1;
    			else if (ptset1[i + 1].x > XL)
    				c = 0;
    			code2 = c;
    			if (code1 != 0 && code2 == 0)
    			{
    				pt[k].x = XL;
    				pt[k].y = ptset1[i].y + (ptset1[i + 1].y - ptset1[i].y)*(XL - ptset1[i].x) / (ptset1[i + 1].x - ptset1[i].x);
    				pt[k + 1].x = ptset1[i + 1].x;
    				pt[k + 1].y = ptset1[i + 1].y;
    				k = k + 2;
    			}
    			if (code1 == 0 && code2 == 0)
    			{
    				if (k == 0)
    				{
    					pt[k].x = ptset1[i].x;
    					pt[k].y = ptset1[i].y;
    					pt[k + 1].x = ptset1[i + 1].x;
    					pt[k + 1].y = ptset1[i + 1].y;
    					k = k + 2;
    				}
    				else
    				{
    					pt[k].x = ptset1[i + 1].x;
    					pt[k].y = ptset1[i + 1].y;
    					k = k + 1;
    				}
    			}
    			if (code1 == 0 && code2 != 0)
    			{
    				pt[k].x = XL;
    				pt[k].y = ptset1[i].y + (ptset1[i + 1].y - ptset1[i].y)*(XL - ptset1[i].x) / (ptset1[i + 1].x - ptset1[i].x);
    				k++;
    			}
    		}
    		pt[k].x = pt[0].x;
    		pt[k].y = pt[0].y;
    		M = k + 1;
    		k = 0;
    		for (i = 0; i < M; i++)
    		{
    			int c = 0;
    			if (pt[i].x < XR)
    				c = 0;
    			else if (pt[i].x > XR)
    				c = 2;
    			code1 = c;
    			c = 0;
    			if (pt[i + 1].x < XR)
    				c = 0;
    			else if (pt[i + 1].x > XR)
    				c = 2;
    			code2 = c;
    			if (code1 == 0 && code2 == 0)
    			{
    				if (k == 0)
    				{
    					pts[k].x = pt[i].x;
    					pts[k].y = pt[i].y;
    					pts[k + 1].x = pt[i + 1].x;
    					pts[k + 1].y = pt[i + 1].y;
    					k = k + 2;
    				}
    				else
    				{
    					pts[k].x = pt[i + 1].x;
    					pts[k].y = pt[i + 1].y;
    					k++;
    				}
    			}
    			if (code1 != 0 && code2 == 0)
    			{
    				pts[k].x = XR;
    				pts[k].y = pt[i].y + (pt[i + 1].y - pt[i].y)*(XR - pt[i].x) / (pt[i + 1].x - pt[i].x);
    				pts[k + 1].x = pt[i + 1].x;
    				pts[k + 1].y = pt[i + 1].y;
    				k = k + 2;
    			}
    		}
    		if (code1 == 0 && code2 != 0)
    		{
    			pts[k].x = XR;
    			pts[k].y = pt[i].y + (pt[i + 1].y - pt[i].y)*(XR - pt[i].x) / (pt[i + 1].x - pt[i].x);
    			k = k + 1;
    		}
    		pts[k] = pts[0];
    		M = k + 1;
    		k = 0;
    		for (i = 0; i < M; i++)
    		{
    			int c = 0;
    			if (pts[i].y > YB)
    				c = 4;
    			else if (pts[i].y < YB)
    				c = 0;
    			code1 = c;
    			c = 0;
    			if (pts[i + 1].y > YB)
    				c = 4;
    			else if (pts[i + 1].y < YB)
    				c = 0;
    			code2 = c;
    			if (code1 == 0 && code2 == 0)
    			{
    				if (k == 0)
    				{
    					ptse[k].x = pts[i].x;
    					ptse[k].y = pts[i].y;
    					ptse[k + 1].x = pts[i + 1].x;
    					ptse[k + 1].y = pts[i + 1].y;
    					k = k + 2;
    				}
    				else
    				{
    					ptse[k].x = pts[i + 1].x;
    					ptse[k].y = pts[i + 1].y;
    					k = k + 1;
    				}
    			}
    			if (code1 != 0 && code2 == 0)
    			{
    				ptse[k].y = YB;
    				ptse[k].x = pts[i].x + (pts[i + 1].x - pts[i].x)*(YB - pts[i].y) / (pts[i + 1].y - pts[i + 1].y);
    				ptse[k + 1].x = pts[i + 1].x;
    				ptse[k + 1].y = pts[i + 1].y;
    				k = k + 2;
    			}
    		}
    		if (code1 == 0 && code2 != 0)
    		{
    			ptse[k].y = YB;
    			ptse[k].x = pts[i].x + (pts[i + 1].x - pts[i].x)*(YB - pts[i].y) / (pts[i + 1].y - pts[i + 1].y);
    			k = k + 1;
    		}
    		ptse[k] = ptse[0];
    		M = k + 1;
    		k = 0;
    		for (i = 0; i < M; i++)
    		{
    			int c = 0;
    			if (ptse[i].y > YT)
    				c = 0;
    			else if (ptse[i].y < YT)
    				c = 1;
    			code1 = c;
    			c = 0;
    			if (ptse[i + 1].y > YT)
    				c = 0;
    			else if (ptse[i + 1].y < YT)
    				c = 1;
    			code2 = c;
    			if (code1 != 0 && code2 == 0)
    			{
    				p[k].y = YT;
    				p[k].x = ptse[i].x + (ptse[i + 1].x - ptse[i].x)*(YT - ptse[i].y) / (ptse[i + 1].y - ptse[i].y);
    				p[k + 1].x = ptse[i + 1].x;
    				p[k + 1].y = ptse[i + 1].y;
    				k = k + 2;
    			}
    			if (code1 == 0 && code2 == 0)
    			{
    				if (k == 0)
    				{
    					p[k].x = ptse[i].x;
    					p[k].y = ptse[i].y;
    					p[k + 1].x = ptse[i + 1].x;
    					p[k + 1].y = ptse[i + 1].y;
    					k = k + 2;
    				}
    				else
    				{
    					p[k].x = ptse[i + 1].x;
    					p[k].y = ptse[i + 1].y;
    					k = k + 1;
    				}
    			}
    			if (code1 == 0 && code2 != 0)
    			{
    				p[k].y = YT;
    				p[k].x = ptse[i].x + (ptse[i + 1].x - ptse[i].x)*(YT - ptse[i].y) / (ptse[i + 1].y - ptse[i].y);
    				k++;
    			}
    		}
    		p[k] = p[0];
    		M = k + 1;
    		pDC->MoveTo(p[0]);
    		for (int j = 1; j <= M; j++)
    		{
    			pDC->LineTo(p[j]);
    		}
    	}
    }
    

    六、实现效果

    在这里插入图片描述

    展开全文
  • Weiler-Atherton多边形裁剪算法

    千次阅读 2015-08-21 17:00:17
    这是一个通用的多边形裁剪算法,既可以裁剪凸多边形也可以裁剪凹多边。 通过下图来描述算法的执行过程 图中DCBA为裁剪窗口,dcba为要裁剪的多边形。在算法执行之前将多边形和裁剪窗口的交点分别加入他们的...

    来自:http://blog.csdn.net/liaojinyu282/article/details/6011177

    这是一个通用的多边形裁剪算法,既可以裁剪凸多边形也可以裁剪凹多边。

    通过下图来描述算法的执行过程

    img79

    图中DCBA为裁剪窗口,dcba为要裁剪的多边形。在算法执行之前将多边形和裁剪窗口的交点分别加入他们的顶点序列。即图中的123456。

    则多边形序列为:a,6,5,d,4,3,c,2,b,1

    裁剪窗口序列为:A,5,4,D,C,1,B,2,3,6

    从多边形顶点a开始按逆时针方向遍历多边形顶点。到达多边形与裁剪边界的交点6,此时线段是从裁剪区的外部进入裁剪区内部

    (即交点6一个entering intersection),则在多边形序列上继续遍历直到找到第一个从边界“出去”的点或者一个已经遍历过的点,图中所示为交点5(称交点5为一个exiting intersection);

    此时线段从裁剪区内出去,这时在裁剪窗口序列的当前顶点开始逆时针遍历(此时为交点5),到达交点4,线段d4指向多边形内部,交点4是一个entering intersection;

    转换到多边形序列继续遍历,到交点3,交点3是一个exiting intersection;

    转换到裁剪窗口序列逆时针遍历,到交点6,发现6已经访问过,得到顶点序列6543,即为一个要绘制的多边形;

    这时退回到最后一个exiting intersection,即顶点3,在多边形序列上遍历,找到一个   entering intersection,即点2,然后按照上述过程得到一个顶点序列2b1B,此时多边形所有的点均已访问,算法结束;

    整个算法就是先计算多边形和裁剪窗口的顶点序列,然后根据交点是一个entering intersection还是exiting intersection选择在不同的顶点序列上遍历,直到所有的点都访问完

    输入给出多边形序列和裁剪窗口的序列,首先要一个预处理将他们的交点按依序插入各自的序列,一个比较直接的办法,可以直接按逆时针遍历这两个序列,每次取2个点组成一个线段与另一个序列的每条边比较计算交点,得出一个要插入的点集,然后按照该点集中的每个点到线段起点的距离按序插入,离起点近的就先插入;

     

    参考 :

    《计算机图形学》 赫恩

    http://www.cs.fit.edu/~wds/classes/graphics/Clip/clip/clip.html

    http://en.wikipedia.org/wiki/Weiler–Atherton_clipping_algorithm


    展开全文
  • 二维图形的裁剪算法研究与改进 机械制造及其自动化 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;//裁剪...

    多边形裁剪

    效果截图:

    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;//裁剪窗口坐标,矩形窗口的对角坐标
        CPoint cj_win2;

    //多边形裁剪
        int dbx_count;
        CPoint ps[5];//这里以画五个顶点的多变形为例,而且不必初始化

    以上定义的一定要在构造函数里初始化,不然会报错

    具体实现:

    //判断点在裁剪框内外
    int CquhongjuanView::Inside(POINT p, Boundary b, POINT wMin, POINT wMax)
    	{   
    		switch (b)
    		{
    		case Left:
    			if (p.x<wMin.x) return (false);
    			break;
    		case Right:
    			if (p.x>wMax.x) return (false);
    			break;
    		case Bottom:
    			if (p.y<wMin.y) return (false);
    			break;
    		case Top:
    			if (p.y>wMax.y) return (false);
    			break;
    		}
    		return true;
    	}/*Inside*/
    
    	/* 求相交的点 */
    	POINT CquhongjuanView::Intersect(POINT p1, POINT p2, Boundary b, POINT  wMin, POINT wMax)
    	{
    		POINT iPt;
    		float m;
    		if (p1.x != p2.x) m = (p2.y - p1.y)*1.0 / (p2.x - p1.x);
    		switch (b) {
    		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;
    	}/*Intersect*/
    
    	//按边裁剪
    	int Cquhongjuaniew::edgeCliper(Boundary b, POINT wMin, POINT wMax, POINT *pIn, int cnt, POINT *pOut) {
    
    		POINT s;
    		int i, Outcnt = 0;
    		s = pIn[0];
    		for (i = 1; i <= cnt; i++)
    		{
    			if (!Inside(s, b, wMin, wMax) && Inside(pIn[i], b, wMin, wMax))
    			{
    				pOut[Outcnt] = Intersect(s, pIn[i], b, wMin, wMax);
    				Outcnt++;
    				pOut[Outcnt] = pIn[i];
    				Outcnt++;
    			}
    			else if (Inside(s, b, wMin, wMax) && Inside(pIn[i], b, wMin, wMax))
    			{
    				pOut[Outcnt] = pIn[i];
    				Outcnt++;
    			}
    			else if (Inside(s, b, wMin, wMax) && (!Inside(pIn[i], b, wMin, wMax)))
    			{
    				pOut[Outcnt] = Intersect(s, pIn[i], b, wMin, wMax);
    				Outcnt++;
    			}
    			s = pIn[i];
    		}
    		return Outcnt;
    	}/*edgeCliper*/
    
    	/*   多边形裁剪  */
    	void CquhongjuanView::clipPolygon(CDC * pDC){
    
    		int i, cnt, Outcnt, b;
         //多写了第一个点是为了使得最后一个点与第一个点连起来
    		POINT points[6] = { { ps[0].x,ps[0].y },{  ps[1].x,ps[1].y },{  ps[2].x,ps[2].y },{  ps[3].x,ps[3].y },
    		{  ps[4].x,ps[4].y },{ ps[0].x,ps[0].y} };
    
    		cnt = 5;
    
    		POINT pOut[20], pIn[20];
    		POINT wMin = { 100,100 }, wMax = { 300,300 };
    
    
    
    		for (i = 0; i < 4 * cnt; i++)
    		{
    			pIn[i].x = 0;
    			pIn[i].y = 0;
    			pOut[i].x = 0;
    			pOut[i].y = 0;
    		}
    		for (i = 0; i <= cnt; i++) pIn[i] = points[i];
    
    		for (b = 0; b < 4; b++)
    		{
    			Outcnt = edgeCliper(Boundary(b), wMin, wMax, pIn, cnt, pOut);
    			for (i = 0; i < Outcnt; i++)  
    				pIn[i] = pOut[i];
    			pIn[Outcnt] = pOut[0];
    			cnt = Outcnt;
    		}
    
    		pDC->Rectangle(wMin.x, wMin.y, wMax.x, wMax.y);
    		pDC->Polygon(pOut, cnt);
    		return;
    	}/* clipPolygon */
    
    /*  显示未裁剪的多边形和框 */
    	void CquhongjuanView::showUnclipPolygon(CDC * pDC){
    
    		POINT points[5] = { { ps[0].x,ps[0].y },{  ps[1].x,ps[1].y },{  ps[2].x,ps[2].y },{  ps[3].x,ps[3].y },
    		{  ps[4].x,ps[4].y } };
    		//POINT points[8];
    		
    		POINT wMin = { 100,100 }, wMax = { 300,300 };
    
    		CBrush * pOldBrush = (CBrush *)pDC->SelectStockObject(NULL_BRUSH);
    		pDC->Rectangle(wMin.x, wMin.y, wMax.x, wMax.y);
    		pDC->Polygon(points, 5);
    		pDC->SelectObject(pOldBrush);
    
    	}

    可能有些定义不明确,可以根据上下文语境推测,主要是这个做起来有点烦,就懒得写了,体谅一下

    ps:mfc相关直线、圆、椭圆、多边形、多边形填充、裁剪直线可以关注我的博客

    展开全文
  • 1、编写程序实现Sutherland-Hodgeman 多边形裁剪算法。 #include<GL/glut.h> #include<iostream> #include<stdio.h> #include<stdlib.h> typedef struct { float x, y; }wcPt2D; typedef...

    1、编写程序实现Sutherland-Hodgeman 多边形裁剪算法。

    #include<GL/glut.h>
    #include<iostream>
    #include<stdio.h>
    #include<stdlib.h>
    
    typedef struct
    {
    	float x, y;
    }wcPt2D;
    
    typedef enum
    {
    	Left, Right, Bottom, Top
    }Boundary;
    
    int Inside(wcPt2D p, Boundary b, wcPt2D wMin, wcPt2D wMax)
    {
    	switch (b)
    	{
    	case Left:
    		if (p.x < wMin.x) return (false);
    		break;
    	case Right:
    		if (p.x > wMax.x) return (false);
    		break;
    	case Bottom:
    		if (p.y < wMin.y) return (false);
    		break;
    	case Top:
    		if (p.y > wMax.y) return (false);
    		break;
    	}
    	return true;
    }
    
    int Cross(wcPt2D p1, wcPt2D p2, Boundary b, wcPt2D wMin, wcPt2D wMax)
    {
    	if (Inside(p1, b, wMin, wMax) == Inside(p2, b, wMin, wMax))
    		return (false);
    	else
    		return true;
    }
    
    wcPt2D Intersect(wcPt2D p1, wcPt2D p2, Boundary b, wcPt2D	wMin, wcPt2D wMax)
    {
    	wcPt2D iPt;
    	float m;
    	if (p1.x != p2.x) m = (p2.y - p1.y) / (p2.x - p1.x);
    	switch (b) {
    	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;
    }
    int edgeCliper(Boundary b, wcPt2D wMin, wcPt2D wMax, wcPt2D *pIn, int cnt, wcPt2D *pOut)
    {
    	wcPt2D s;
    	int i, Outcnt = 0;
    	s = pIn[0];
    	for (i = 1; i <= cnt; i++)
    	{
    		if (!Inside(s, b, wMin, wMax) && Inside(pIn[i], b, wMin, wMax))
    		{
    			pOut[Outcnt] = Intersect(s, pIn[i], b, wMin, wMax);
    			Outcnt++;
    			pOut[Outcnt] = pIn[i];
    			Outcnt++;
    		}
    		else if (Inside(s, b, wMin, wMax) && Inside(pIn[i], b, wMin, wMax))
    		{
    			pOut[Outcnt] = pIn[i];
    			Outcnt++;
    		}
    		else if (Inside(s, b, wMin, wMax) && (!Inside(pIn[i], b, wMin, wMax)))
    		{
    			pOut[Outcnt] = Intersect(s, pIn[i], b, wMin, wMax);
    			Outcnt++;
    		}
    		s = pIn[i];
    	}
    	return (Outcnt);
    }
    
    void  init(void)
    {
    	glClearColor(1.0, 1.0, 1.0, 0.0);
    	glMatrixMode(GL_PROJECTION);
    	glLoadIdentity();
    	gluOrtho2D(-400.0, 400.0, -300.0, 300.0);
    }
    
    void ClipPolygonSuthHodg(void)
    {
    	glClear(GL_COLOR_BUFFER_BIT);
    	glMatrixMode(GL_MODELVIEW);
    	int i, cnt, Outcnt, b;
    	wcPt2D points[8] = { {-250,-80},{-250,100},{-120,100},{-120,50},{0,50},{0,-50},{-50,-80},{-250,-80} };
    	cnt = 7;
    	wcPt2D pOut[28], pIn[28];
    	wcPt2D wMin = { -200,0 }, wMax = { 50,200 };
    	for (i = 0; i < 4 * cnt; i++)
    	{
    		pIn[i].x = 0.0;
    		pIn[i].y = 0.0;
    		pOut[i].x = 0.0;
    		pOut[i].y = 0.0;
    	}
    	for (i = 0; i <= cnt; i++) pIn[i] = points[i];
    	glColor3f(0.0, 0.0, 0.0);
    	glBegin(GL_LINE_LOOP);
    	glVertex2f(wMin.x, wMin.y);
    	glVertex2f(wMax.x, wMin.y);
    	glVertex2f(wMax.x, wMax.y);
    	glVertex2f(wMin.x, wMax.y);
    	glEnd();
    	glLineWidth(2.0);
    	glBegin(GL_LINE_LOOP);
    	for (i = 0; i < cnt; i++)
    		glVertex2f(pIn[i].x, pIn[i].y);
    	glEnd();
    	for (b = 0; b < 4; b++)
    	{
    		Outcnt = edgeCliper(Boundary(b), wMin, wMax, pIn, cnt, pOut);
    		for (i = 0; i < Outcnt; i++)
    			pIn[i] = pOut[i];
    		pIn[Outcnt] = pOut[0];
    		cnt = Outcnt;
    	}
    	glColor3f(1.0, 0.0, 0.0);
    	glBegin(GL_LINE_LOOP);
    	for (i = 0; i < cnt; i++)
    		glVertex2f(pOut[i].x, pOut[i].y);
    	glEnd();
    	glFlush();
    }
    void main(int argc, char **argv)
    {
    	glutInit(&argc, argv);
    	glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
    	glutInitWindowPosition(50, 100);
    	glutInitWindowSize(800, 600);
    	glutCreateWindow("An Example OpenGL Program");
    	init();
    	glutDisplayFunc(ClipPolygonSuthHodg);
    	glutMainLoop();
    }
    

    在这里插入图片描述

    学习总结:
    ① OpenGL提供了一系列函数指定一个点。它们都以 glVertex 开头,后面跟一个数字和1~2个字母。例如:glVertex2d、glVertex2f、glVertex3f、glVertex3fv等等,数字表示参数的个数,2表示有两个参数,3表示3个,4表示4个。字母表示参数的类型。
    s 表示 16位整数(OpenGL 中将这个类型定义为GLshort),
    i 表示32位整数(OpenGL 中将这个类型定义为 GLint 和GLsizei ),
    f 表示32 位浮点数(OpenGL 中将这个类型定义为GLfloat 和GLclampf),
    d 表示 64 位浮点数(OpenGL 中将这个类型定义为GLdouble 和GLclampd )。
    v 表示传递的几个参数将使用指针的方式。
    这些函数除了参数的类型和个数不同以外,功能是相同的。例如,以下五个代码段的功能是等效的:
    glVertex2i ( 1, 3 );
    glVertex2f ( 1.0f, 3.0f );
    glVertex3f ( 1.0f, 3.0f, 0.0f );
    glVertex4f ( 1.0f, 3.0f, 0.0f, 1.0f );
    GLfloat VertexArr3[] = {1.0f, 3.0f, 0.0f}; glVertex3fv ( VertexArr3 );
    可用 glVertex* 来表示这一系列函数。注意:OpenGL 的很多函数都是采用这样的形式,一个相同的前缀再加上参数说明标记。
    ②函数原型:
    void glBegin(GLenummode)
    void glEnd(void)
    参数说明:
      mode:创建图元的类型。可以是以下数值
      GL_POINTS:把每一个顶点作为一个点进行处理,顶点n即定义了点n,共绘制N个点
      GL_LINES:把每一个顶点作为一个独立的线段,顶点2n-1和2n之间共定义了n条线段,总共绘制N/2条线段
      GL_LINE_STRIP:绘制从第一个顶点到最后一个顶点依次相连的一组线段,第n和n+1个顶点定义了线段n,总共绘制n-1条线段
      GL_LINE_LOOP:绘制从第一个顶点到最后一个顶点依次相连的一组线段,然后最后一个顶点和第一个顶点相连,第n和n+1个顶点定义了线段n,总共绘制n条线段
      GL_TRIANGLES:把每个顶点作为一个独立的三角形,顶点3n-2、3n-1和3n定义了第n个三角形,总共绘制N/3个三角形
      GL_TRIANGLE_STRIP:绘制一组相连的三角形,对于奇数n,顶点n、n+1和n+2定义了第n个三角形;对于偶数n,顶点n+1、n和n+2定义了第n个三角形,总共绘制N-2个三角形
      GL_TRIANGLE_FAN:绘制一组相连的三角形,三角形是由第一个顶点及其后给定的顶点确定,顶点1、n+1和n+2定义了第n个三角形,总共绘制N-2个三角形
      GL_QUADS:绘制由四个顶点组成的一组单独的四边形。顶点4n-3、4n-2、4n-1和4n定义了第n个四边形。总共绘制N/4个四边形
      GL_QUAD_STRIP:绘制一组相连的四边形。每个四边形是由一对顶点及其后给定的一对顶点共同确定的。顶点2n-1、2n、2n+2和2n+1定义了第n个四边形,总共绘制N/2-1个四边形
    GL_POLYGON:绘制一个凸多边形。顶点1到n定义了这个多边形。
    ③函数原型:void glLoadIdentity( void);
    错误解释:将当前的用户坐标系的原点移到了屏幕中心:类似于一个复位操作
    正确解释:glLoadIdentity该函数的功能是重置当前指定的矩阵为单位矩阵.

    展开全文
  • } } //裁剪算法 public static List Sutherland_Hodgeman(List points,List vectors){ List result = new ArrayList(); List cur = new ArrayList(); int vectorsSize = vectors.size(); int ...

空空如也

空空如也

1 2 3 4 5 ... 18
收藏数 346
精华内容 138
关键字:

多边形裁剪算法