多边形裁剪_2021秋季《计算机图形学》_基于《计算机图形学（第四版）》D.H.&M.P.B.&W.R.C.

一、实验目的

• 使用Sutherland-Hodgman算法实现多边形裁剪

二、实验环境

• Visual Studio 2019
• Windows 10

三、算法分析与设计

顺时针地将多边形的每一条边的两个端点传入一组裁剪器，在这组裁剪器完成对一对顶点的处理后，将输出队列传入下一组裁剪器，下一组剪子对下一条边的顶点进行处理。

对于每一对待裁剪的顶点，它们与当前裁剪器的位置关系有下列四种可能：

1. 两个点都在内部：此时只向输出队列加入第二个点
2. 第一个点在外部，第二个点在内部：加入该边与裁剪器的交点和第二个点
3. 第一个点在内部，第二个点在外部：加入交点
4. 两个点都在外部：不加入任何点
   

于是有两个待解决的问题：

1. 判断点在裁剪器的内部或外部

   本题中多边形顶点以顺时针顺序输入，于是点在裁剪器的右侧表示在该边的内部。

   记点坐标为$(x,y)$，裁剪器起点为$(x_1,y_1)$，终点为$(x_2,y_2)$，则根据公式
   $$pos=(x_2-x_1)(y-y_1)-(y_2-y_1)(x-x_1)$$

   $$\{\begin{array}{ll}pos<0:& 点在裁剪器右侧，即内部\\ pos=0:& 点在裁剪器上\\ pos>0:& 点在裁剪器左侧，即外部\end{array}$$

   可以判断。

2. 判断两条线段的交点

   记第一条线段的顶点坐标为$(x_1,y_1),(x_2,y_2)$，记第二条线段的顶点坐标为$(x_3,y_3),(x_4,y_4)$，则根据公式
   $$\begin{gathered} x=\frac{(x_1{y}_2-y_1{x}_2)(x_3-x_4)-(x_1-x_2)(x_3{y}_4-y_3{x}_4)}{(x_1-x_2)(y_3-y_4)-(y_1-y_2)(x_3-x_4)} \\ y=\frac{(x_1{y}_2-y_1{x}_2)(y_3-y_4)-(y_1-y_2)(x_3{y}_4-y_3{x}_4)}{(x_1-x_2)(y_3-y_4)-(y_1-y_2)(x_3-x_4)} \end{gathered}$$

五、实验结果

六、附录

#include<bits/stdc++.h>
#include<GLFW/glfw3.h>
using namespace std;

#define MAX_POINTS 20

int x_intersect(int x1, int y1, int x2, int y2,
	int x3, int y3, int x4, int y4)
{
	int num = (x1 * y2 - y1 * x2) * (x3 - x4) -
		(x1 - x2) * (x3 * y4 - y3 * x4);
	int den = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4);
	return num / den;
}

int y_intersect(int x1, int y1, int x2, int y2,
	int x3, int y3, int x4, int y4)
{
	int num = (x1 * y2 - y1 * x2) * (y3 - y4) -
		(y1 - y2) * (x3 * y4 - y3 * x4);
	int den = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4);
	return num / den;
}

void clip(int poly_points[][2], int& poly_size,
	int x1, int y1, int x2, int y2)
{
	// 不断更新输出队列
	int new_points[MAX_POINTS][2], new_poly_size = 0;

	for (int i = 0; i < poly_size; i++)
	{
		int k = (i + 1) % poly_size;
		int ix = poly_points[i][0], iy = poly_points[i][1];
		int kx = poly_points[k][0], ky = poly_points[k][1];

		// 计算i和k在当前裁剪线的内/外侧
		// pos<0：左侧；pos>0：右侧
		// 由于按顺时针读入端点，左侧意味着外侧，右侧意味着内测
		int i_pos = (x2 - x1) * (iy - y1) - (y2 - y1) * (ix - x1);
		int k_pos = (x2 - x1) * (ky - y1) - (y2 - y1) * (kx - x1);

		// 两个点都在内部，只加入第二个点
		if (i_pos < 0 && k_pos < 0)
		{
			new_points[new_poly_size][0] = kx;
			new_points[new_poly_size][1] = ky;
			new_poly_size++;
		}

		// 只有i在外面，加入交点和第二个点
		else if (i_pos >= 0 && k_pos < 0)
		{
			new_points[new_poly_size][0] = x_intersect(x1, y1, x2, y2, ix, iy, kx, ky);
			new_points[new_poly_size][1] = y_intersect(x1, y1, x2, y2, ix, iy, kx, ky);
			new_poly_size++;

			new_points[new_poly_size][0] = kx;
			new_points[new_poly_size][1] = ky;
			new_poly_size++;
		}

		// 只有k在外面，只加入交点
		else if (i_pos < 0 && k_pos >= 0)
		{
			new_points[new_poly_size][0] = x_intersect(x1, y1, x2, y2, ix, iy, kx, ky);
			new_points[new_poly_size][1] = y_intersect(x1, y1, x2, y2, ix, iy, kx, ky);
			new_poly_size++;
		}

		// i和k都在外面
		else
		{

		}
	}

	// 更新多边形
	poly_size = new_poly_size;
	for (int i = 0; i < poly_size; i++)
	{
		poly_points[i][0] = new_points[i][0];
		poly_points[i][1] = new_points[i][1];
	}
}

void suthHodgClip(int poly_points[][2], int& poly_size,
	int clipper_points[][2], int clipper_size)
{
	for (int i = 0; i < clipper_size; i++)
	{
		int k = (i + 1) % clipper_size;

		clip(poly_points, poly_size, clipper_points[i][0],
			clipper_points[i][1], clipper_points[k][0],
			clipper_points[k][1]);
	}

	for (int i = 0; i < poly_size; i++)
		cout << '(' << poly_points[i][0] <<
		", " << poly_points[i][1] << ") ";
}

int main()
{
	// 初始化多边形
	int poly_size = 3;
	int poly_size_copy = poly_size;
	int poly_points[MAX_POINTS][2] = { {-500,-300}, {0,300},
							{500,0} };
	int poly_copy[][2] = { {-500,-300}, {0,300},
							{500,0} };

	// 初始化裁剪器
	int clipper_size = 4;
	int clipper_points[][2] = { {-150,-150}, {-150,200},
							{200,200}, {200,-150} };

	suthHodgClip(poly_points, poly_size, clipper_points,
		clipper_size);

	GLFWwindow* window;

	/* Initialize the library */
	if (!glfwInit())
		return -1;

	/* Create a windowed mode window and its OpenGL context */
	window = glfwCreateWindow(960, 960, "polygonClipping", NULL, NULL);
	if (!window)
	{
		glfwTerminate();
		return -1;
	}

	/* Make the window's context current */
	glfwMakeContextCurrent(window);

	/* Loop until the user closes the window */
	while (!glfwWindowShouldClose(window))
	{
		/* Render here */
		glClear(GL_COLOR_BUFFER_BIT);

		glBegin(GL_POLYGON);
		glColor3f(255.0f, 255.0f, 255.0f);
		for (int i = 0; i < poly_size_copy; i++)
			glVertex2f(poly_copy[i][0] * 0.001, poly_copy[i][1] * 0.001);
		glEnd();

		
		glBegin(GL_LINE_STRIP);
		glColor3f(255.0f, 0.0f, 0.0f);
		for (int i = 0; i <= clipper_size; i++)
			glVertex2f(clipper_points[i%clipper_size][0] * 0.001, clipper_points[i%clipper_size][1] * 0.001);
		glEnd();

		glBegin(GL_POLYGON);
		glColor3f(255.0f, 0.0f, 255.0f);
		for (int i = 0; i < poly_size; i++)
			glVertex2f(poly_points[i][0] * 0.001, poly_points[i][1] * 0.001);
		glEnd();

		/* Swap front and back buffers */
		glfwSwapBuffers(window);


		/* Poll for and process events */
		glfwPollEvents();
	}

	glfwTerminate();

	return 0;
}