Suthurland-Hodgman多边形裁剪算法-C++完整实现（计算机图形学作业）

最新推荐文章于 2022-04-12 16:32:29 发布
最新推荐文章于 2022-04-12 16:32:29 发布
阅读量1k 收藏 14
点赞数
分类专栏： 计算机学习 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hanmo22357/article/details/124127563
版权 
#include<iostream>
#include<graphics.h>
#include<conio.h>
#include<windows.h>
#include<vector>
using namespace std;
static int wx1, wy1, wx2, wy2;

//优化后的Bresenham算法，能够处理斜率不存在，斜率为负数，斜率绝对值大于一等情况，并且可以根据需要自动调整两点顺序，具有良好的通用性
//使用只需要输入两点的横纵坐标值即可
void Bresenham(const unsigned& x1, const unsigned& y1, const unsigned& x2, const unsigned& y2)
{
	int dx = x2 - x1, dy = y2 - y1;
	enum MainChangeDirection { x, y };//用一个枚举变量记录直线的主要变化方向（x方向或者y方向）（用枚举变量更加符合语义）
	MainChangeDirection Direction;
	if (abs(dx) >= abs(dy))
		Direction = x;
	else Direction = y;
	if ((Direction == x && x1 > x2) || (Direction == y && y1 > y2))//如果在主要变化方向上的次序相反了，则递归调用自身即可（相当于交换两个点）
	{
		Bresenham(x2, y2, x1, y1);
		return;
	}

	if (dx == 0)//处理斜率不存在的特殊情况
	{
		for (unsigned y = y1; y <= y2; ++y)
		{
			putpixel(x1, y, YELLOW);
		}
		return;
	}

	//对于不同的变化方向以及斜率的正负不同，需要使用不同的数学表达式（自行推导出），也就是需要分情况
	double k = double(dy) / dx;
	if (Direction == x)//处理主要变化方向为x轴的情况
	{
		unsigned x = x1, y = y1;
		if (k >= 0)//主要变化方向为x轴并且斜率大于等于零
		{
			int e = -dx;
			for (; x <= x2; ++x)
			{
				putpixel(x, y, YELLOW);
				e += 2 * dy;
				if (e > 0)
				{
					y++;
					e -= 2 * dx;
				}
			}
		}
		else if (k < 0)//主要变化方向为x轴且斜率小于零
		{
			int e = dx;
			for (; x <= x2; ++x)
			{
				putpixel(x, y, YELLOW);
				e += 2 * dy;
				if (e <= 0)
				{
					y--;
					e += 2 * dx;
				}
			}
		}
	}
	else if (Direction == y)
	{
		unsigned y = y1, x = x1;
		if (k >= 0)//主要变化方向为y轴方向并且斜率大于等于零
		{
			int e = -dy;
			for (; y <= y2; ++y)
			{
				putpixel(x, y, YELLOW);
				e += 2 * dx;
				if (e > 0)
				{
					x++;
					e -= 2 * dy;
				}
			}
		}
		else if (k < 0)//主要变化方向为y轴方向并且斜率小于零
		{
			int e = dy;
			for (; y <= y2; ++y)
			{
				putpixel(x, y, YELLOW);
				e += 2 * dx;
				if (e <= 0)
				{
					x--;
					e += 2 * dy;
				}
			}
		}
	}
	return;
}

//SH算法函数：需要输入多边形顶点的横坐标数组、纵坐标数组以及多边形的顶点个数
void SH_PolygonClip(const int* x, const int* y, const unsigned& num)
{
	//定义两组向量，其中一组向量用于某一阶段的点结果保存，另一组向量用于辅助计算
	vector<int>Xvec, Yvec;
	vector<int>temp_Xvec, temp_Yvec;
	//首先用原有数组中的元素对向量分别进行初始化
	for (unsigned i = 0; i < num; i++)
	{
		Xvec.push_back(x[i]);
		Yvec.push_back(y[i]);
	}

	//接下来分别用四条边界，按照上下左右的顺序对原多边形进行裁剪，每完成一条边界的裁剪便绘制一次裁剪结果
	//首先进行上边界的裁剪
	for (unsigned i = 0; i < Xvec.size() - 1; ++i)
	{
		//对于纵坐标小于上边界的点，将其保留在点集中
		if (Yvec[i] <= wy2)
		{
			temp_Xvec.push_back(Xvec[i]);
			temp_Yvec.push_back(Yvec[i]);
		}
		//如果多边形某一条边上的两点分别处在边界的两侧，则找出该直线与边界的交点，将交点放入向量中
		if ((Yvec[i] - wy2) * (Yvec[i + 1] - wy2) < 0)
		{
			//首先考虑斜率不存在的情况
			if (Xvec[i] == Xvec[i + 1])
			{
				temp_Xvec.push_back(Xvec[i]);
				temp_Yvec.push_back(wy2);
			}
			//接着考虑斜率存在的情况，对于该情况，为了使得结果更加精确，对点的横坐标进行了四舍五入计算
			else
			{
				int new_x = int(((double)(Xvec[i + 1] - Xvec[i]) / (Yvec[i + 1] - Yvec[i])) * (wy2 - Yvec[i]) + Xvec[i]+0.5);
				temp_Xvec.push_back(new_x);
				temp_Yvec.push_back(wy2);
			}
		}
	}
	//接下来处理最后一个顶点以及最后一个顶点和第一个顶点的连线，处理方法与上类似
	if (Yvec[Xvec.size()-1] <= wy2)
	{
		temp_Xvec.push_back(Xvec[Xvec.size() - 1]);
		temp_Yvec.push_back(Yvec[Xvec.size() - 1]);
	}
	if ((Yvec[Xvec.size() - 1] - wy2) * (Yvec[0] - wy2) < 0)
	{
		if (Xvec[Xvec.size() - 1] == Xvec[0])
		{
			temp_Xvec.push_back(Xvec[0]);
			temp_Yvec.push_back(wy2);
		}
		else
		{
			int new_x = int(((double)(Xvec[Xvec.size() - 1] - Xvec[0]) / (Yvec[Yvec.size() - 1] - Yvec[0])) * (wy2 - Yvec[0]) + Xvec[0] + 0.5);
			temp_Xvec.push_back(new_x);
			temp_Yvec.push_back(wy2);
		}
	}
	//将临时结果进行保存从而更新结果向量，同时清空临时向量便于下次重新使用
	Xvec = temp_Xvec;
	Yvec = temp_Yvec;
	temp_Xvec.clear();
	temp_Yvec.clear();
	//绘制裁剪一次之后的效果，此处使用了之前所学习的Bresenham算法进行直线绘制
	initgraph(1000, 640);
	rectangle(wx1, wy2, wx2, wy1);
	for (unsigned i = 0; i < Xvec.size() - 1; i++)
	{
		Bresenham(Xvec[i], Yvec[i], Xvec[i + 1], Yvec[i + 1]);
	}
	Bresenham(Xvec[0], Yvec[0], Xvec[Xvec.size() - 1], Yvec[Yvec.size() - 1]);
	//使程序休眠一段时间，以方便用户看清运行结果
	Sleep(2000);
	closegraph();

	//进行下边界的裁剪，内容与上边界的裁剪类似
	for (unsigned i = 0; i < Xvec.size() - 1; ++i)
	{
		if (Yvec[i] >= wy1)
		{
			temp_Xvec.push_back(Xvec[i]);
			temp_Yvec.push_back(Yvec[i]);
		}
		if ((Yvec[i] - wy1) * (Yvec[i + 1] - wy1) < 0)
		{
			if (Xvec[i] == Xvec[i + 1])
			{
				temp_Xvec.push_back(Xvec[i]);
				temp_Yvec.push_back(wy1);
			}
			else
			{
				int new_x = int(((double)(Xvec[i + 1] - Xvec[i]) / (Yvec[i + 1] - Yvec[i])) * (wy1 - Yvec[i]) + Xvec[i] + 0.5);
				temp_Xvec.push_back(new_x);
				temp_Yvec.push_back(wy1);
			}
		}
	}
	if (Yvec[Xvec.size() - 1] >= wy1)
	{
		temp_Xvec.push_back(Xvec[Xvec.size() - 1]);
		temp_Yvec.push_back(Yvec[Xvec.size() - 1]);
	}
	if ((Yvec[Xvec.size() - 1] - wy1) * (Yvec[0] - wy1) < 0)
	{
		if (Xvec[Xvec.size() - 1] == Xvec[0])
		{
			temp_Xvec.push_back(Xvec[0]);
			temp_Yvec.push_back(wy1);
		}
		else
		{
			int new_x = int(((double)(Xvec[Xvec.size() - 1] - Xvec[0]) / (Yvec[Yvec.size() - 1] - Yvec[0])) * (wy1 - Yvec[0]) + Xvec[0] + 0.5);
			temp_Xvec.push_back(new_x);
			temp_Yvec.push_back(wy1);
		}
	}
	Xvec = temp_Xvec;
	Yvec = temp_Yvec;
	temp_Xvec.clear();
	temp_Yvec.clear();
	initgraph(1000, 640);
	rectangle(wx1, wy2, wx2, wy1);
	for (unsigned i = 0; i < Xvec.size() - 1; i++)
	{
		Bresenham(Xvec[i], Yvec[i], Xvec[i + 1], Yvec[i + 1]);
	}
	Bresenham(Xvec[0], Yvec[0], Xvec[Xvec.size() - 1], Yvec[Yvec.size() - 1]);
	Sleep(2000);
	closegraph();

	//进行左边界的裁剪，内容与上边界的裁剪类似
	for (unsigned i = 0; i < Xvec.size() - 1; ++i)
	{
		if (Xvec[i] >= wx1)
		{
			temp_Xvec.push_back(Xvec[i]);
			temp_Yvec.push_back(Yvec[i]);
		}
		if ((Xvec[i] - wx1) * (Xvec[i + 1] - wx1) < 0)
		{
			double k = (double)(Yvec[i + 1] - Yvec[i]) / (Xvec[i + 1] - Xvec[i]);
			int new_y = int(k * (wx1 - Xvec[i]) + Yvec[i] + 0.5);
			temp_Xvec.push_back(wx1);
			temp_Yvec.push_back(new_y);
		}
	}
	if (Xvec[Xvec.size()-1] >= wx1)
	{
		temp_Xvec.push_back(Xvec[Xvec.size()-1]);
		temp_Yvec.push_back(Yvec[Xvec.size()-1]);
	}
	if ((Xvec[Xvec.size() - 1] - wx1) * (Xvec[0] - wx1) < 0)
	{
		double k = (double)(Yvec[Xvec.size() - 1] - Yvec[0]) / (Xvec[Xvec.size() - 1] - Xvec[0]);
		int new_y = int(k * (wx1 - Xvec[0]) + Yvec[0] + 0.5);
		temp_Xvec.push_back(wx1);
		temp_Yvec.push_back(new_y);
	}
	Xvec = temp_Xvec;
	Yvec = temp_Yvec;
	temp_Xvec.clear();
	temp_Yvec.clear();
	initgraph(1000, 640);
	rectangle(wx1, wy2, wx2, wy1);
	for (unsigned i = 0; i < Xvec.size() - 1; i++)
	{
		Bresenham(Xvec[i], Yvec[i], Xvec[i + 1], Yvec[i + 1]);
	}
	Bresenham(Xvec[0], Yvec[0], Xvec[Xvec.size() - 1], Yvec[Yvec.size() - 1]);
	Sleep(2000);
	closegraph();

	//进行右边界的裁剪，内容与上边界的裁剪类似
	for (unsigned i = 0; i < Xvec.size() - 1; ++i)
	{
		if (Xvec[i] <= wx2)
		{
			temp_Xvec.push_back(Xvec[i]);
			temp_Yvec.push_back(Yvec[i]);
		}
		if ((Xvec[i] - wx2) * (Xvec[i + 1] - wx2) < 0)
		{
			double k = (double)(Yvec[i + 1] - Yvec[i]) / (Xvec[i + 1] - Xvec[i]);
			int new_y = int(k * (wx2 - Xvec[i]) + Yvec[i] + 0.5);
			temp_Xvec.push_back(wx2);
			temp_Yvec.push_back(new_y);
		}
	}
	if (Xvec[Xvec.size() - 1] <= wx2)
	{
		temp_Xvec.push_back(Xvec[Xvec.size() - 1]);
		temp_Yvec.push_back(Yvec[Xvec.size() - 1]);
	}
	if ((Xvec[Xvec.size() - 1] - wx2) * (Xvec[0] - wx2) < 0)
	{
		double k = (double)(Yvec[Xvec.size() - 1] - Yvec[0]) / (Xvec[Xvec.size() - 1] - Xvec[0]);
		int new_y = int(k * (wx2 - Xvec[0]) + Yvec[0] + 0.5);
		temp_Xvec.push_back(wx2);
		temp_Yvec.push_back(new_y);
	}
	Xvec = temp_Xvec;
	Yvec = temp_Yvec;
	temp_Xvec.clear();
	temp_Yvec.clear();
	initgraph(1000, 640);
	rectangle(wx1, wy2, wx2, wy1);
	for (unsigned i = 0; i < Xvec.size()-1; i++)
	{
		Bresenham(Xvec[i],Yvec[i],Xvec[i+1],Yvec[i+1]);
	}
	Bresenham(Xvec[0], Yvec[0], Xvec[Xvec.size() - 1], Yvec[Yvec.size() - 1]);
	_getch();
	closegraph();

	return;
}

int main(void)
{
	unsigned PointNum;
	cout << "请输入多边形的顶点数：";
	cin >> PointNum;
	int* xArray = new int[PointNum];
	int* yArray = new int[PointNum];
	cout << "请输入多边形每个点的横坐标：";
	for (unsigned i = 0; i < PointNum; i++)
	{
		cin >> xArray[i];
	}
	cout << "请输入多边形每个点的纵坐标：";
	for (unsigned i = 0; i < PointNum; i++)
	{
		cin >> yArray[i];
	}
	cout << "请输入窗口左下角点和右上角点的横纵坐标：";
	cin >> wx1 >> wy1 >> wx2 >> wy2;
	cout << "参数确认完毕，按任意键开始程序...(动态绘图完成后按任意键可返回）" << endl;

	initgraph(1000, 640);
	for (unsigned i = 0; i < PointNum-1; i++)
	{
		Bresenham(xArray[i], yArray[i], xArray[i + 1], yArray[i + 1]);
	}
	Bresenham(xArray[PointNum - 1], yArray[PointNum - 1], xArray[0], yArray[0]);
	rectangle(wx1, wy2, wx2, wy1);
	Sleep(2000);
	closegraph();
	SH_PolygonClip(xArray, yArray, PointNum);
	return 0;
}
北岛寒沫
关注
专栏目录
【计算机图形学】c++ OpenGL Sutherlang-Hodgman 多边形裁剪
Arana的博客
05-16 1871
源代码 // 多边形裁剪.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include<GL/glut.h> #include<iostream> #include<stdio.h> #include<stdlib.h> //Sutherlang-Hodgman多边形裁剪 typedef struct { float x, y; }wcPt2D; typedef enum { Left, Right, Bo
计算机图形学例题快速裁剪多边形算法,计算机图形学(简单多边形裁剪算法).doc...
weixin_36399495的博客
07-28 852
计算机图形学(简单多边形裁剪算法)简单多边形裁剪算法摘要：多边形裁剪算法与线性裁剪算法具有更广泛的实用意义，因此它是目前裁剪研究的主要课题。本文主要介绍了一种基于多边形顶点遍历的简单多边形裁剪算法，它有效降低了任意多边形裁剪复杂度。通过记录交点及其前驱、后继信息，生成结果多边形，该算法简化了交点的数据结构，节省了存储空间，降低了算法的时间复杂度，具有简单、易于编程实现、运行效率高的特点。关键词：多...
SuthHodgClip:使用 openGL 和 CC++ 实现多边形裁剪的 Sutherland-Hodgman 算法
07-01
SuthHodgClip
Sutherland-Hodgman裁剪算法(附c++源码)
sinat_33916407的博客
04-03 4103
这是一个关于多边形的裁剪算法，剪裁的是多边形，关于直线的剪裁，博主在https://blog.csdn.net/sinat_33916407/article/details/88918553 里面给出了梁友栋-Barskey裁剪算法的实现，在这里，博主给出的是多边形剪裁方法中的Sutherland-Hodgman方法，亲测可用，按下c键进行剪裁，按下r键会复原原图，按下x键会退出。是用vector...
利用VC++实现Sutherland-Hodgman算法（多边形裁剪）
10-02
经典多边形裁剪算法 Sutherland-Hodgman的VC++实现 经典多边形裁剪算法 Sutherland-Hodgman的VC++实现
多边形裁剪
12-07
自己写的多边形裁剪算法（计算机图形学作业），鼠标左键拖拉改变多边形的顶点坐标实现拖动，鼠标右键拖动实现裁剪窗口的拖动，点击裁剪按钮实现裁剪功能，点击清空缓存按钮实现清空裁剪以便进行下一次的裁剪
计算机图形学OpenGL、codeblock、多边形裁剪、Sutherland_Hodgman算法
12-20
多边形裁剪是计算机图形学中的关键步骤，特别是在3D图形渲染中。当一个三维模型被投影到二维屏幕上时，可能会有部分多边形超出屏幕边界，此时就需要进行裁剪以确保只显示可见的部分。Cohen-Sutherland线段裁剪算法是...
基于MFC的多边形裁剪算法的实现完整项目代码
05-10
本项目“基于MFC的多边形裁剪算法的实现完整项目代码”提供了使用Visual Studio 2017实现多边形裁剪的实例，便于学习和交流。下面我们将详细探讨多边形裁剪算法及其在MFC框架中的应用。 首先，多边形裁剪是基于图形...
MFC实现多边形裁剪 计算机图形学
10-16
本项目利用MFC框架实现了多边形裁剪功能，结合了计算机图形学的基本原理和技术，如直线绘制、区域填充等。 首先，让我们了解MFC。MFC是基于Windows API构建的，它提供了一组类，用于创建用户界面、数据库访问、网络...
多边形裁剪算法
04-19
多边形裁剪算法，还不错，学到挺多的，共享给大家看看
计算机图形学-多边形的裁剪算法
12-20
编程实现直线段的裁剪算法（算法任选）正确的程序可以处理各种位置的线段。
图形学直线裁剪算法(C语言版)
06-01
图形学实验，直线裁剪算法，c语言版，鼠标点击
Sutherland-Hodgeman算法
08-07
Sutherland-Hodgeman算法的C语言实现
计算机图形学简单多边形裁剪程序
06-03
计算机图形学简单多边形裁剪程序，开发环境VC++6.0，语言C++
opengl/c++ 矢量法切割凹多边形并填充（附代码）
weixin_49377880的博客
09-08 1485
opengl的GL_POLYGON只能渲染凸多边形，如果想渲染凹多变性，已经有较为高效的方式。出于学习算法和锻炼写码能力，使用矢量法来切割凹多边形并填充。 对于图类的问题，建立好图形表是解决问题的基础和关键。一开始多次写到一半写不下去了就是因为没用多边形表的惯例来层层分割。 由于本人很菜，代码比较冗余。首先是数据结构，分别是点表，边表，和面表，以及相应的元素的定义，用vector实现。judge是表示线的参数。然后是函数声明。 struct V { ...
Liang-Barsky直线段裁剪算法-C++实现（计算机图形学作业）
hanmo22357的博客
04-12 1430
//梁式直线裁剪算法的程序，由于该方法用编程实现非常简单，在介绍时稍微简略一些 void Liang_Barsky(const int& x1, const int& y1, const int& x2, const int& y2) { //首先分别计算出四个P值和四个Q值，如果满足两种算法停止条件的一种则可以直接终止算法而无序计算U值，从而提高效率节约空间 int p1, p2, p3, p4; int q1, q2, q3, q4; p1 = x1 - x2;
梁友栋-Barskey裁剪算法(附上c++源码)
sinat_33916407的博客
03-30 5038
最近在学习计算机图形学的基本算法，其中就看到了这一个剪裁算法，书上关于这个算法的讲解特别的少，感觉自己看不大懂这个算法，在网上找了一些资料，感觉都没有讲的特别清楚，后来我在一位博主的博客上找到了一篇讲得很好的博客，分享出来给大家：https://blog.csdn.net/soulmeetliang/article/details/79185603 这个博主是用matlab实现的，看懂之后，我决定...
直线裁剪 梁友栋算法C++实现
06-24
4）理解并掌握Liang_Barsky算法的参数化裁剪思想； 3. 实验要求 1）将像素网格表现出来，建立网格坐标系； 2）用橡皮筋的形式输入剪裁线段和裁剪窗口； 3）鼠标移动时，显示鼠标当前位置； 4）对于线段裁剪，线段被窗口的四条边裁剪的过程要显示出来； 6）裁剪过程可以重复进行。
Sutherland-Hodgman算法：凸多边形裁剪在PLC编程中的应用
在《矩形及凸多边形裁剪窗口裁剪 - PLC编程手册》一章中，主要探讨了在计算机图形学中如何利用Sutherland-Hodgman(简称S-H)算法进行矩形和凸多边形的裁剪操作。S-H算法是一种逐边裁剪方法，由I．E．Sutherland和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值