计算机图形学实验三：多边形裁剪

已于 2022-08-13 11:33:19 修改
阅读量160 收藏 1
点赞数
分类专栏： 计算机图形学 文章标签： pytorch 深度学习 python
于 2020-10-01 09:46:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43975891/article/details/108876107
版权

不含凹多边形裁剪算法

#include <iostream>
#include<GL/glut.h>
#include<vector>
using namespace std;
int window_size = 600;
int wmin = 200, wmax = 400;
int hmin = 200, hmax = 400;
int last_x = -1, last_y = -1;
struct Vertex {
	int x, y;
};
struct Edge {
	Vertex point[2];
};


Edge LEFT, RIGHT, TOP, BOTTOM;

vector<Vertex> inputVertex, outputVertex;


void Output(Vertex& p, int outlength, vector<Vertex>& OutVertexarray) {

}


bool Inside(Vertex& TestPt, Edge& ClipBoundary) {//裁剪边为窗口下边
	//判断点是否在裁剪边的可见侧
	if (ClipBoundary.point[1].x > ClipBoundary.point[0].x) {//裁剪边为窗口下边
		if (TestPt.y >= ClipBoundary.point[0].y) {
			return true;
		}
	}
	else if (ClipBoundary.point[1].x < ClipBoundary.point[0].x) {//裁剪边为窗口上边
		if (TestPt.y <= ClipBoundary.point[0].y) {
			return true;
		}
	}
	else if (ClipBoundary.point[1].y > ClipBoundary.point[0].y) {//裁剪边为窗口右边
		if (TestPt.x <= ClipBoundary.point[0].x) {
			return true;
		}
	}
	else if (ClipBoundary.point[1].y < ClipBoundary.point[0].y) {//裁剪边为窗口左边
		if (TestPt.x >= ClipBoundary.point[0].x) {
			return true;
		}
	}
	return false;

}




void Intersect(Vertex& S, Vertex& P, Edge& ClipBoundary, Vertex& IntersectPt) {
	if (ClipBoundary.point[0].y == ClipBoundary.point[1].y) {//水平裁剪边
		IntersectPt.y = ClipBoundary.point[1].y;
		IntersectPt.x = S.x + (ClipBoundary.point[0].y - S.y) * (P.x - S.x) / (P.y - S.y);
	}
	else {//垂直裁剪边
		IntersectPt.x = ClipBoundary.point[0].x;
		IntersectPt.y = S.y + (ClipBoundary.point[0].x - S.x) * (P.y - S.y) / (P.x - S.x);
	}
}
void SutherlandHogmanClip(vector<Vertex>& InVertexArray, vector<Vertex>& OutVertexArray, Edge ClipBoundary, int Inlength);
void showResult(vector<Vertex>& VertexArray);
void polygonClip() {
	//4把刀
	//1、左侧边
	LEFT.point[0].x = wmin;
	LEFT.point[0].y = hmax;
	LEFT.point[1].x = wmin;
	LEFT.point[1].y = hmin;
	SutherlandHogmanClip(inputVertex, outputVertex, LEFT, inputVertex.size());
	//2、下侧边
	BOTTOM.point[0].x = wmin;
	BOTTOM.point[0].y = hmin;
	BOTTOM.point[1].x = wmax;
	BOTTOM.point[1].y = hmin;
	inputVertex.clear();
	SutherlandHogmanClip(outputVertex, inputVertex, BOTTOM, outputVertex.size());
	//右侧边
	RIGHT.point[0].x = wmax;
	RIGHT.point[0].y = hmin;
	RIGHT.point[1].x = wmax;
	RIGHT.point[1].y = hmax;
	outputVertex.clear();
	SutherlandHogmanClip(inputVertex, outputVertex, RIGHT, inputVertex.size());
	//上侧边
	TOP.point[0].x = wmax;
	TOP.point[0].y = hmax;
	TOP.point[1].x = wmin;
	TOP.point[1].y = hmax;
	inputVertex.clear();
	SutherlandHogmanClip(outputVertex, inputVertex, TOP, outputVertex.size());


	showResult(inputVertex);
}
void showResult(vector<Vertex>& VertexArray) {
	//把裁剪后的结果显示出来
	glColor3f(0, 255, 0);
	int len = VertexArray.size();
	for (int i = 0; i < VertexArray.size(); i++) {
		cout << "裁剪后点的坐标为（" << VertexArray[i].x << "," << VertexArray[i].y << ")" << endl;
		glLineWidth(5);
		glBegin(GL_LINES);

		glVertex2i(VertexArray[i].x, VertexArray[i].y);
		glVertex2i(VertexArray[(i + 1) % len].x, VertexArray[(i + 1) % len].y);
		glEnd();
		glBegin(GL_POINTS);
		glVertex2i(VertexArray[i].x, VertexArray[i].y);
		glVertex2i(VertexArray[(i + 1) % len].x, VertexArray[(i + 1) % len].y);
		glEnd();
		glLineWidth(1);
	}
	glFlush();
}




void SutherlandHogmanClip(vector<Vertex>& InVertexArray, vector<Vertex>& OutVertexArray, Edge ClipBoundary, int Inlength) {
	Vertex S, P, ip;
	S = InVertexArray[Inlength - 1];
	for (int j = 0; j < Inlength; j++) {
		P = InVertexArray[j];
		if (Inside(P, ClipBoundary)) {
			if (Inside(S, ClipBoundary)) {
				cout << "情况1" << endl;
				//SP在窗口内,情况（1）
				OutVertexArray.push_back(P);
				//Output(P, Outlength, OutVertexArray);
			}
			else {//S在窗口外，情况（4）
				cout << "情况4" << endl;
				Intersect(S, P, ClipBoundary, ip);
				OutVertexArray.push_back(ip);
				OutVertexArray.push_back(P);
				//Output(ip, Outlength, OutVertexArray);
				//Output(P, Outlength, OutVertexArray);
			}
		}
		else if (Inside(S, ClipBoundary)) {
			cout << "情况3" << endl;
			//S在窗口内，P在窗口外，情况（3）
			Intersect(S, P, ClipBoundary, ip);
			OutVertexArray.push_back(ip);
			cout << "ip的坐标为" << ip.x << " , " << ip.y << endl;
			cout << "刚才入数组的点的坐标为" << OutVertexArray.back().x << " , " << outputVertex.back().y << endl;
			//Output(ip, Outlength, OutVertexArray);
		}
		else {
			cout << "情况2" << endl;
		}
		S = P;
	}
}

void drawpoint(int x, int y) {
	glColor3f(1, 0, 0);
	glBegin(GL_POINTS);
	glVertex2f(x, y);
	glEnd();
	glFlush();
}
void mykeyboard(unsigned char key, int x, int y) {
	if (key == 'f' && inputVertex.size()) {
		glColor3f(0, 0, 255);
		glBegin(GL_LINES);
		glVertex2d(last_x, last_y);
		glVertex2d(inputVertex[0].x, inputVertex[0].y);
		glEnd();
		glFlush();
	}
	if (key == 'c') {
		polygonClip();
	}
}
void myDisplay();
void mymouse(int button, int state, int x, int y) {
	if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN) {
		inputVertex.push_back({ x,y });
		drawpoint(x, y);
		if (last_x >= 0 && last_y >= 0) {
			cout << "可以画线" << endl;
			glColor3f(0, 0, 255);
			glBegin(GL_LINES);
			glVertex2i(last_x, last_y);
			glVertex2i(x, y);
			glEnd();
			glFlush();
		}
		cout << "刚才加入的坐标是" << x << "," << y << endl;
		last_x = x; last_y = y;
	}
	if (button == GLUT_RIGHT_BUTTON && state == GLUT_DOWN) {
		cout << "点击了鼠标右键" << endl;
		myDisplay();
		inputVertex.clear(); outputVertex.clear();
		last_x = -1; last_y = -1;
	}
}


void myDisplay() {
	cout << "调用了一次回调函数" << endl;
	glClearColor(1, 1, 1, 0);
	glClear(GL_COLOR_BUFFER_BIT);
	//绘制裁剪区域
	glColor3f(0, 1, 1);
	glBegin(GL_LINES);
	//1、L
	glVertex2i(wmin, hmin);
	glVertex2i(wmin, hmax);
	//2、B
	glVertex2i(wmin, hmin);
	glVertex2i(wmax, hmin);
	//3、R
	glVertex2i(wmax, hmin);
	glVertex2i(wmax, hmax);
	//4、T
	glVertex2i(wmin, hmax);
	glVertex2i(wmax, hmax);
	glEnd();
	glFlush();
}
void init() {
	glClearColor(1, 1, 1, 0);
	glClear(GL_COLOR_BUFFER_BIT);
	glPointSize(7);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	gluOrtho2D(0, window_size, window_size, 0);
	myDisplay();
}
int main(int argc, char* argv[]) {
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);
	glutInitWindowPosition(300, 100);
	glutInitWindowSize(window_size, window_size);
	glutCreateWindow("多边形裁剪算法");
	init();
	glutMouseFunc(mymouse);
	glutKeyboardFunc(mykeyboard);
	glutDisplayFunc(myDisplay);
	//glutMotionFunc(dragMouse);
	glutMainLoop();
	return 0;
}

含有凹多边形裁剪算法

#include <iostream>
#include<GL/glut.h>
#include<vector>
#include<cstring>
using namespace std;
const int window_size = 600;
int wmin = 200, wmax = 400;
int hmin = 200, hmax = 400;
int last_x = -1, last_y = -1;
struct Vertex {
	int x, y;
};
struct Edge {
	Vertex point[2];
};
int vis[window_size][window_size];

Edge LEFT, RIGHT, TOP, BOTTOM;

vector<Vertex> inputVertex, outputVertex;



bool Inside(Vertex& TestPt, Edge& ClipBoundary) {//裁剪边为窗口下边
	//判断点是否在裁剪边的可见侧
	if (ClipBoundary.point[1].x > ClipBoundary.point[0].x) {//裁剪边为窗口下边
		if (TestPt.y >= ClipBoundary.point[0].y) {
			return true;
		}
	}
	else if (ClipBoundary.point[1].x < ClipBoundary.point[0].x) {//裁剪边为窗口上边
		if (TestPt.y <= ClipBoundary.point[0].y) {
			return true;
		}
	}
	else if (ClipBoundary.point[1].y > ClipBoundary.point[0].y) {//裁剪边为窗口右边
		if (TestPt.x <= ClipBoundary.point[0].x) {
			return true;
		}
	}
	else if (ClipBoundary.point[1].y < ClipBoundary.point[0].y) {//裁剪边为窗口左边
		if (TestPt.x >= ClipBoundary.point[0].x) {
			return true;
		}
	}
	return false;

}

void Intersect(Vertex& S, Vertex& P, Edge& ClipBoundary, Vertex& IntersectPt) {
	if (ClipBoundary.point[0].y == ClipBoundary.point[1].y) {//水平裁剪边
		IntersectPt.y = ClipBoundary.point[1].y;
		IntersectPt.x = S.x + (ClipBoundary.point[0].y - S.y) * (P.x - S.x) / (P.y - S.y);
	}
	else {//垂直裁剪边
		IntersectPt.x = ClipBoundary.point[0].x;
		IntersectPt.y = S.y + (ClipBoundary.point[0].x - S.x) * (P.y - S.y) / (P.x - S.x);
	}
}
void SutherlandHogmanClip(vector<Vertex>& InVertexArray, vector<Vertex>& OutVertexArray, Edge ClipBoundary, int Inlength);
void showResult(vector<Vertex>& VertexArray);
void polygonClip() {
	//4把刀
	//1、左侧边
	LEFT.point[0].x = wmin;
	LEFT.point[0].y = hmax;
	LEFT.point[1].x = wmin;
	LEFT.point[1].y = hmin;
	SutherlandHogmanClip(inputVertex, outputVertex, LEFT, inputVertex.size());
	//2、下侧边
	BOTTOM.point[0].x = wmin;
	BOTTOM.point[0].y = hmin;
	BOTTOM.point[1].x = wmax;
	BOTTOM.point[1].y = hmin;
	inputVertex.clear();
	SutherlandHogmanClip(outputVertex, inputVertex, BOTTOM, outputVertex.size());
	//右侧边
	RIGHT.point[0].x = wmax;
	RIGHT.point[0].y = hmin;
	RIGHT.point[1].x = wmax;
	RIGHT.point[1].y = hmax;
	outputVertex.clear();
	SutherlandHogmanClip(inputVertex, outputVertex, RIGHT, inputVertex.size());
	//上侧边
	TOP.point[0].x = wmax;
	TOP.point[0].y = hmax;
	TOP.point[1].x = wmin;
	TOP.point[1].y = hmax;
	inputVertex.clear();
	SutherlandHogmanClip(outputVertex, inputVertex, TOP, outputVertex.size());


	showResult(inputVertex);
}
void drawpixel(int x, int y) {
	glPointSize(2);
	vis[x][y]++;
	if (vis[x][y] % 2 == 1) {//奇数次 显示
		glColor3ub(20, 160, 93);
		glBegin(GL_POINTS);
		glVertex2i(x, y);
		glEnd();
		glFlush();
	}
	else {//偶数次 不显示
		glColor3ub(255, 205, 68);
		glBegin(GL_POINTS);
		glVertex2i(x, y);
		glEnd();
		glFlush();

	}

}
void Bresenham(int x0, int y0, int x1, int y1) {
	cout << "B" << endl;
	if (x0 > x1)swap(x0, x1), swap(y0, y1);//(x0,y0)->(x1,y1);
	bool negk = y1 < y0;//负斜率,沿x轴对称，画点时用-y
	if (negk) y0 = -y0, y1 = -y1;
	bool steepk = y1 - y0 > x1 - x0;// 斜率 |k|>1，交换x和y的位置
	if (steepk) swap(x0, y0), swap(x1, y1);
	int x = x0, y = y0, dx = x1 - x0, dy = y1 - y0;
	int e = -dx;
	for (int i = 0; i <= dx; i ++) {
		drawpixel(steepk ? y : x, negk ? (steepk ? -x : -y) : (steepk ? x : y));
		x += 1; e += 2 * dy ;
		if (e >= 0) y += 1, e -= 2  * dx;
	}
}


void showResult(vector<Vertex>& VertexArray) {
	//把裁剪后的结果显示出来
	glColor3ub(20, 160, 93);
	int len = VertexArray.size();
	for (int i = 0; i < VertexArray.size(); i++) {
		cout << "裁剪后点的坐标为（" << VertexArray[i].x << "," << VertexArray[i].y << ")" << endl;
		Bresenham(VertexArray[i].x, VertexArray[i].y,VertexArray[(i + 1) % len].x, VertexArray[(i + 1) % len].y);		
		glColor3ub(20, 160, 93);
		glPointSize(7);
		glBegin(GL_POINTS);
		glVertex2i(VertexArray[i].x, VertexArray[i].y);
		glVertex2i(VertexArray[(i + 1) % len].x, VertexArray[(i + 1) % len].y);
		glEnd();
		glLineWidth(1);
	}
	glFlush();
}




void SutherlandHogmanClip(vector<Vertex>& InVertexArray, vector<Vertex>& OutVertexArray, Edge ClipBoundary, int Inlength) {
	Vertex S, P, ip;
	S = InVertexArray[Inlength - 1];
	for (int j = 0; j < Inlength; j++) {
		P = InVertexArray[j];
		if (Inside(P, ClipBoundary)) {
			if (Inside(S, ClipBoundary)) {
				cout << "情况1" << endl;
				//SP在窗口内,情况（1）
				OutVertexArray.push_back(P);
				//Output(P, Outlength, OutVertexArray);
			}
			else {//S在窗口外，情况（4）
				cout << "情况4" << endl;
				Intersect(S, P, ClipBoundary, ip);
				OutVertexArray.push_back(ip);
				OutVertexArray.push_back(P);
				//Output(ip, Outlength, OutVertexArray);
				//Output(P, Outlength, OutVertexArray);
			}
		}
		else if (Inside(S, ClipBoundary)) {
			cout << "情况3" << endl;
			//S在窗口内，P在窗口外，情况（3）
			Intersect(S, P, ClipBoundary, ip);
			OutVertexArray.push_back(ip);
			cout << "ip的坐标为" << ip.x << " , " << ip.y << endl;
			cout << "刚才入数组的点的坐标为" << OutVertexArray.back().x << " , " << outputVertex.back().y << endl;
			//Output(ip, Outlength, OutVertexArray);
		}
		else {
			cout << "情况2" << endl;
		}
		S = P;
	}
}

void drawpoint(int x, int y) {
	glColor3ub(211, 82, 70);
	glBegin(GL_POINTS);
	glVertex2f(x, y);
	glEnd();
	glFlush();
}
void mykeyboard(unsigned char key, int x, int y) {
	if (key == 'f' && inputVertex.size()) {
		glColor3ub(75, 140, 255);
		glBegin(GL_LINES);
		glVertex2d(last_x, last_y);
		glVertex2d(inputVertex[0].x, inputVertex[0].y);
		glEnd();
		glFlush();
	}
	if (key == 'c') {
		polygonClip();
	}
}
void myDisplay();
void mymouse(int button, int state, int x, int y) {
	if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN) {
		inputVertex.push_back({ x,y });
		drawpoint(x, y);
		if (last_x >= 0 && last_y >= 0) {
			cout << "可以画线" << endl;
			glColor3ub(75, 140, 255);
			glBegin(GL_LINES);
			glVertex2i(last_x, last_y);
			glVertex2i(x, y);
			glEnd();
			glFlush();
		}
		cout << "刚才加入的坐标是" << x << "," << y << endl;
		last_x = x; last_y = y;
	}
	if (button == GLUT_RIGHT_BUTTON && state == GLUT_DOWN) {
		cout << "点击了鼠标右键" << endl;
		myDisplay();
		inputVertex.clear(); outputVertex.clear();
		memset(vis, 0, sizeof vis);
		last_x = -1; last_y = -1;
	}
}


void myDisplay() {
	cout << "调用了一次回调函数" << endl;
	glClearColor(1, 1, 1, 0);
	glClear(GL_COLOR_BUFFER_BIT);
	//绘制裁剪区域
	glColor3ub(255, 205, 68);
	glLineWidth(2);
	glBegin(GL_LINES);
	//1、L
	glVertex2i(wmin, hmin);
	glVertex2i(wmin, hmax);
	//2、B
	glVertex2i(wmin, hmin);
	glVertex2i(wmax, hmin);
	//3、R
	glVertex2i(wmax, hmin);
	glVertex2i(wmax, hmax);
	//4、T
	glVertex2i(wmin, hmax);
	glVertex2i(wmax, hmax);
	glEnd();
	glFlush();
}
void init() {
	glClearColor(1, 1, 1, 0);
	glClear(GL_COLOR_BUFFER_BIT);
	glPointSize(7);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	gluOrtho2D(0, window_size, window_size, 0);
	myDisplay();
}
int main(int argc, char* argv[]) {
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);
	glutInitWindowPosition(300, 100);
	glutInitWindowSize(window_size, window_size);
	glutCreateWindow("多边形裁剪算法");
	init();
	glutMouseFunc(mymouse);
	glutKeyboardFunc(mykeyboard);
	glutDisplayFunc(myDisplay);
	//glutMotionFunc(dragMouse);
	glutMainLoop();
	return 0;
}
Catmull
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
计算机图形学中的多边形裁剪
11-25
窗口是固定的，如果需要随意给定的窗口，可以对代码稍作修改，用ButtonDown和ButtonUp实现
计算机图形学 多边形裁剪
12-04
使用C#实现计算机图形学中的多边形裁剪算法，界面友好，功能完善
计算机图形学——多边形裁剪（待改良可运行）
gygygyyyyyy的博客
07-07 1257
用窗口的四条边的边界分别对所画多边形进行裁剪，每次裁剪后的结果都会生成一个新的多边形，再将这一多边形作为输入多边形再以裁剪窗口其他边界裁剪，最终达到裁剪多边形的目的。上述多边形裁剪对于凸多边形适用，但对于部分凹多边形会出现错误如下图，向外凹陷地位置裁剪结果包含了一条本不应该有的线，对于该问题由于时间问题，还没有完成，但已经形成一定可行的改进思路。 首先还是要先求出多边形与裁剪区域的交点，同时类似于梁友栋算法的入边出边，把交点分成进入点和出点，然后将交点和原来的顶点按照多边形的顺序存储到同一个数组里，同
计算机图形学-多边形裁剪
qq_43535469的博客
06-17 594
Suther land-Hodgeman多边形裁剪 核心思想 将多边形作为一个整体 每次用窗口的一条边对要裁剪的多边形和中间结果多边形进行裁剪 分治思想 先用窗口的左边界对多边形进行裁剪 就会得到1 ，2两个点 然后和多边形其他点作为下一个输入 四种情况 交点I和定点P被加入 2. 顶点P加入 因为S在之前会被加入 也就是判断S那条直线时就会被加入 3. S和I加入 4. S和P都不加入 例子 不足之处 对于凹多边形会产生多余线段 ...
计算机图形学直线和多边形裁剪
05-14
本资源包含了Cohen-Sutherland算法、Liang-Barsky算法实现直线段裁剪以及自创的多边形裁剪（老师都没查出BUG）的cpp源代码和实验报告。重点是多边形裁剪，400多行代码，最终实现了任意多边形裁剪，下载即可运行
MFC实现多边形裁剪 计算机图形学
10-16
在计算机图形学领域，多边形裁剪是一个重要的技术，用于在二维或三维空间中处理图形，确保只有在视窗内的部分被显示出来。MFC（Microsoft Foundation Classes）是微软提供的一种面向对象的C++库，它使得Windows应用...
上海大学计算机图形学实验（Qt版）
03-12
计算机图形学（基于Qt5.14.0） 通过鼠标交互输入算法所需数据 实现二维基本图元直线段生成的DDA算法,中点算法和Bresenham算法； 实现二维基本图元圆弧生成的中点算法； 实现对线型线宽属性的控制。 实现二维扫描转换...
计算机图形学实验报告.doc
07-10
计算机图形学实验报告 在计算机科学中，计算机图形学是一门关键的学科，它涉及到用计算机来生成和处理图像。本实验报告详细介绍了通过编程语言实现的一些基本图形绘制技术，主要包括中点算法、扫描线算法、Cohen-...
MFC计算机图形学实验4：基本图形变换（报告）
最新发布
01-11
【计算机图形学实验4：基本图形变换】 在本次实验中，我们主要关注的是二维图形的几何变换以及图形的裁剪处理。实验的核心是利用Visual C++的MFC框架进行编程，目的是深入理解图形编程和MFC的应用。 1. **实验目的...
计算机图形学实现多边形裁剪
12-29
#include <graphics.h>， line(left,top,right,top); line(left,bottom,right,bottom); line(left,top,left,bottom); line(right,top,right,bottom); //绘制边框和裁剪图形
多边形裁剪（计算机图形学）
03-21
计算机图形学之多边形裁剪算法，本程序中包括直线画法，直线裁剪，多边形画法和多边形裁剪过程，可以实现。
多边形裁剪算法 计算机图形学
06-09
逐次多边形裁剪算法算法的思想发窗口四条边界单一逐次对多边形进行裁剪，每次用窗口的一条边界(包括延长线)对要裁剪的多边形进行裁剪，裁剪时，顺序地测试多边形各顶点，保留边界内侧的顶点，删除外侧的顶点，同时，适时地插入新的顶点：即交点和窗口顶点，从而得到一个新的多边形顶点序列。然后以此新的顶点序列作为输入，相对第二条窗边界线进行裁剪，又得到一个更新的多边形顶点序列依次下去，相对于第三条、第四条边界线进行裁剪，最后输出的多边形顶点序列即为所求的裁剪好了的多边形。
计算机图形学简单多边形裁剪程序
06-03
计算机图形学简单多边形裁剪程序，开发环境VC++6.0，语言C++
计算机图形学 多边形裁剪完整代码 WinTC
09-10
计算机图形学作业，不需修改直接在WINtc下运行
计算机图形学の多边形裁剪算法(openGL)
Janus
10-09 2663
二维图形裁剪算法: 参考博客: https://blog.csdn.net/m0_46359746/article/details/106392352 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; } wc
计算机图形学学习笔记(6.2): 多边形裁剪
大鹏的blog
04-10 2049
多边形裁剪 在实际问题中，我们往往需要处理的是用矩形裁剪一个多边形，找到多边形落在屏幕区域内的部分。如下图： 一般有两种算法来处理多边形裁剪问题：Sutherland-Hodgeman算法和Weiler-Atherton算法。 下面介绍比较高效的Weiler-Atherton算法的主要步骤。 Weiler-Atherton算法 假定按顺时针方向处理顶点，且将多边形定义为Ps，窗口矩形...
计算机图形学11：二维观察之多边形的裁剪
你的问题在于，读书太少而想得太多。
03-19 2346
计算机图形学：二维观察之多边形的裁剪——附原理及详细代码
多边形裁剪_2021秋季《计算机图形学》_基于《计算机图形学（第四版）》D.H.&M.P.B.&W.R.C.
rd142857的博客
11-08 967
一、实验目的 使用Sutherland-Hodgman算法实现多边形裁剪 二、实验环境 Visual Studio 2019 Windows 10 三、算法分析与设计 顺时针地将多边形的每一条边的两个端点传入一组裁剪器，在这组裁剪器完成对一对顶点的处理后，将输出队列传入下一组裁剪器，下一组剪子对下一条边的顶点进行处理。 对于每一对待裁剪的顶点，它们与当前裁剪器的位置关系有下列四种可能： 两个点都在内部：此时只向输出队列加入第二个点 第一个点在外部，第二个点在内部：加入该边与裁剪器的交点和第二个点
计算机图形学实验报告：基础图形与多边形处理
本实验报告是针对计算机科学与技术学院2016-2017学年第一学期《计算机图形学》课程的学习成果，主要针对四个核心实验内容展开，分别是基本图形的生成、二维多边形的填充与裁剪，以及三维图形的变换，包括三视图、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值