【计算机图形学 】扫描线多边形填充算法 | OpenGL+鼠标交互

最新推荐文章于 2022-11-04 10:39:16 发布
最新推荐文章于 2022-11-04 10:39:16 发布
阅读量8.6k 收藏 184
点赞数 20
分类专栏： 计算机图形学 OpenGL 文章标签： 计算机视觉 opencv
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Rover95/article/details/120801961
版权

文章目录

其他计算机图形学实验

传送门

前言

实现多边形扫描线填充算法，并和鼠标进行交互。
具体原理略过，会贴上完整代码，可直接运行。

环境：
vs2019,OpenGL的库（可以搜索如何用vs使用OpenGL的库，可以使用vs自带的插件或者其他方法，很方便）

要点：
1.NET和AET的创建，改动
2.改变鼠标点击和鼠标拖拽的响应事件。

最终效果：
用鼠标随意画顶点，然后展示填充过程
对应控制台会输出顶点坐标和个数
请添加图片描述

思路借鉴

文章1
文章2

步骤

1.点的结构体

struct point
{
	float x, y;
	point(){}
	point(int xx, int yy):
		x(xx), y(yy) {}
};
vector<point> vertice; //顶点

2. AET 活性边表、NET新边表 的结构体

typedef struct XET
{
	float x;
	float dx;  // 从当前扫描线到下一条扫描线间x的增量，即斜率的倒数
	float ymax; //该边所交的最高扫描线的坐标值ymax
	XET* next;
}AET, NET; //AET 活性边表； NET新边表

3. 扫描线算法实现

void PolyScan()
{
	/*得到最高点的y坐标*/
	int Max_Y = 0;
	for (int i = 0; i < vertice.size(); i++) 
		/*Max_Y = max(Max_Y, vertice[i].y);*/
		if (vertice[i].y > Max_Y)
			Max_Y = vertice[i].y;


	//初始化AET表
	AET* pAET = new AET;
	pAET->next = NULL;

	//初始化NET表
	NET* pNET[800]; //吊桶
	for (int i = 0; i <= Max_Y; i++)
	{
		pNET[i] = new NET;
		pNET[i]->next = NULL;;
	}

	//扫描并且建立NET表
	int len = vertice.size(); //顶点个数
	for (int i = 0; i <= Max_Y; i++)
	{
		for (int j = 0; j < len; j++) //扫描每个点
		{
			if (i == vertice[j].y)
			{
				//如果一个点和前一个点有一条边相连，则该点和后面一个点也相连
				//！这个式子 便于最后一个顶点和第一个点相连 和 防止出现负数
				
				//判断当前点的高低，使ymax、DX、DY的计算有变化
				if (vertice[(j - 1 + len) % len].y > vertice[j].y)
				{
					//前一个点在当前点的上方
					NET* p = new NET;
					p->x = vertice[j].x;
					p->ymax = vertice[(j - 1 + len) % len].y;//与当前扫描线相交的活性边 的 最高点即为相邻顶点的y
					float DX = vertice[(j - 1 + len) % len].x - vertice[j].x;
					float DY = vertice[(j - 1 + len) % len].y - vertice[j].y;
					p->dx = DX / DY;//dx为直线斜率的倒数
					p->next = pNET[i]->next;
					pNET[i]->next = p;
				}
				if (vertice[(j + 1) % len].y > vertice[j].y)
				{
					//后一个点在当前点的上方
					NET* p = new NET;
					p->x = vertice[j].x;
					p->ymax = vertice[(j + 1) % len].y;
					float DX = vertice[(j + 1) % len].x - vertice[j].x;
					float DY = vertice[(j + 1) % len].y - vertice[j].y;
					p->dx = DX / DY;//dx为直线斜率的倒数
					p->next = pNET[i]->next;
					pNET[i]->next = p;
				}
			}
		}
	}

	//建立并且更新活性边表AET
	//各条扫描线i
	for (int i = 0; i <= Max_Y; i++)
	{
		/*把新边表NET[i] 中的边结点用插入排序法插入AET表，使之按x坐标递增顺序排列*/
		
		//计算每条扫描线上不同线产生的新的交点x，更新AET
		NET* p = pAET->next;
		while (p)
		{
			p->x = p->x + p->dx; //更新x坐标
			p = p->next;
		}

		//断表排序,不再开辟空间 
		AET* tq = pAET;
		p = pAET->next;
		tq->next = NULL;
		while (p)//顺着链表往下走
		{
			//找到第一个比它大的数字tq->next->next->x，则从p->next到tq->next都是比p->x小的
			while (tq->next != NULL && tq->next->x <= p->x)
				tq = tq->next;
			//插入p到tq和tq->next之间
			NET* t = p->next;
			p->next = tq->next;
			tq->next = p;
			p = t;

			tq = pAET;//回到头
		}

		/*(改进算法) 取消求交，减少计算量*/
		//先从AET表中删除ymax==i的结点****************************************/
		//像素的取舍问题，保证多边形的“下闭上开”，避免填充扩大化（交点的个数应保证为偶数个）
		AET* q = pAET;
		p = q->next;
		while (p)
		{
			if (p->ymax == i)
			{
				q->next = p->next;
				delete p;
				p = q->next;
			}
			else
			{
				q = q->next;
				p = q->next;
			}
		}

		//若NET中有新点，将其用插入法插入AET，按x递增的顺序排列
		p = pNET[i]->next;
		q = pAET;
		while (p)
		{
			while (q->next && p->x >= q->next->x)
				q = q->next;
			//插入p
			NET* t = p->next;
			p->next = q->next;
			q->next = p;
			p = t;

			q = pAET;//回到头
		}

		//配对后填充颜色
		p = pAET->next;
		while (p && p->next != NULL)
		{
			for (float j = p->x; j <= p->next->x; j++)
			{
				//扫描线画点
				draw_a_point(j, i);
				//cout << "(" << j << ", " << i << ")" << endl;
			}
			p = p->next->next;//考虑端点情况
		}
	}
	glFlush();
}

4. 改变鼠标响应函数

void mymouse(int button, int state, int x, int y)
{
	//左键
	if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN)
	{
		draw_a_point(x, window_height - y);

		point p(x, window_height - y);
		vertice.push_back(p);
		cout << "顶点" << vertice.size() << ": (" << x << ", " << window_height - y << ")" << endl;
	}
	//右键
	if (button == GLUT_RIGHT_BUTTON && state == GLUT_DOWN)
	{
		glClearColor(1, 1, 1, 1);//设置绘制窗口颜色为白色
		glColor3f(0, 1, 1);

		//绘制多边形
		glBegin(GL_LINES);	
		for (int i = 0; i < vertice.size(); i++)
		{
			if (i == vertice.size() - 1)//画完最后一个点，使其闭合
			{
				glVertex2f(vertice[0].x, vertice[0].y);
				glVertex2f(vertice[i].x, vertice[i].y);
			}
			else
			{
				glVertex2f(vertice[i].x, vertice[i].y);
				glVertex2f(vertice[i + 1].x, vertice[i + 1].y);
			}
		}
		glEnd();
		glFlush();
	}

	//鼠标中间
	if (button == GLUT_MIDDLE_BUTTON && state == GLUT_DOWN)
	{
		//cout << "center: (" << x << ", " << y << ")" << endl;
		//BoundaryFill4(x, window_height - y);
		//BoundaryFill4_Stack(x, window_height - y);

		cout << "多边形顶点个数为" << vertice.size() << "。 " << "开始扫描线填充。" << endl;
		PolyScan();
	}
}

完整代码

//扫描线算法
#include<iostream>
#include<gl/glut.h>
#include<algorithm>
#include<vector>
#include<stack>
#include<queue>
using namespace std;
const int window_width = 800, window_height = 600;
const int maxn = 99999;

struct point
{
	float x, y;
	point(){}
	point(int xx, int yy):
		x(xx), y(yy) {}
};
vector<point> vertice; //顶点

typedef struct XET
{
	float x;
	float dx;  // 从当前扫描线到下一条扫描线间x的增量，即斜率的倒数
	float ymax; //该边所交的最高扫描线的坐标值ymax
	XET* next;
}AET, NET; //AET 活性边表； NET新边表

void draw_a_point(int x, int y);
void PolyScan();
void mymouse(int button, int state, int x, int y);
void display();


int main(int argc, char* argv[])
{
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
	glutInitWindowPosition(100, 50);
	glutInitWindowSize(window_width, window_height);
	glutCreateWindow("扫描线填充");

	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluOrtho2D(0, window_width, 0, window_height);

	glClearColor(1, 1, 1, 1);
	glClear(GL_COLOR_BUFFER_BIT);

	glutMouseFunc(&mymouse);
	glutDisplayFunc(&display);

	glutMainLoop();
	return 0;
}

//画点函数
void draw_a_point(int x, int y)
{
	glBegin(GL_POINTS);
	glColor3f(0, 1, 1);
	glVertex2f(x, y);
	glEnd();
	glFlush();
}

void PolyScan()
{
	/*得到最高点的y坐标*/
	int Max_Y = 0;
	for (int i = 0; i < vertice.size(); i++) 
		/*Max_Y = max(Max_Y, vertice[i].y);*/
		if (vertice[i].y > Max_Y)
			Max_Y = vertice[i].y;


	//初始化AET表
	AET* pAET = new AET;
	pAET->next = NULL;

	//初始化NET表
	NET* pNET[800]; //吊桶
	for (int i = 0; i <= Max_Y; i++)
	{
		pNET[i] = new NET;
		pNET[i]->next = NULL;;
	}

	//扫描并且建立NET表
	int len = vertice.size(); //顶点个数
	for (int i = 0; i <= Max_Y; i++)
	{
		for (int j = 0; j < len; j++) //扫描每个点
		{
			if (i == vertice[j].y)
			{
				//如果一个点和前一个点有一条边相连，则该点和后面一个点也相连
				//！这个式子 便于最后一个顶点和第一个点相连 和 防止出现负数
				
				//判断当前点的高低，使ymax、DX、DY的计算有变化
				if (vertice[(j - 1 + len) % len].y > vertice[j].y)
				{
					//前一个点在当前点的上方
					NET* p = new NET;
					p->x = vertice[j].x;
					p->ymax = vertice[(j - 1 + len) % len].y;//与当前扫描线相交的活性边 的 最高点即为相邻顶点的y
					float DX = vertice[(j - 1 + len) % len].x - vertice[j].x;
					float DY = vertice[(j - 1 + len) % len].y - vertice[j].y;
					p->dx = DX / DY;//dx为直线斜率的倒数
					p->next = pNET[i]->next;
					pNET[i]->next = p;
				}
				if (vertice[(j + 1) % len].y > vertice[j].y)
				{
					//后一个点在当前点的上方
					NET* p = new NET;
					p->x = vertice[j].x;
					p->ymax = vertice[(j + 1) % len].y;
					float DX = vertice[(j + 1) % len].x - vertice[j].x;
					float DY = vertice[(j + 1) % len].y - vertice[j].y;
					p->dx = DX / DY;//dx为直线斜率的倒数
					p->next = pNET[i]->next;
					pNET[i]->next = p;
				}
			}
		}
	}

	//建立并且更新活性边表AET
	//各条扫描线i
	for (int i = 0; i <= Max_Y; i++)
	{
		/*把新边表NET[i] 中的边结点用插入排序法插入AET表，使之按x坐标递增顺序排列*/
		
		//计算每条扫描线上不同线产生的新的交点x，更新AET
		NET* p = pAET->next;
		while (p)
		{
			p->x = p->x + p->dx; //更新x坐标
			p = p->next;
		}

		//断表排序,不再开辟空间 
		AET* tq = pAET;
		p = pAET->next;
		tq->next = NULL;
		while (p)//顺着链表往下走
		{
			//找到第一个比它大的数字tq->next->next->x，则从p->next到tq->next都是比p->x小的
			while (tq->next != NULL && tq->next->x <= p->x)
				tq = tq->next;
			//插入p到tq和tq->next之间
			NET* t = p->next;
			p->next = tq->next;
			tq->next = p;
			p = t;

			tq = pAET;//回到头
		}

		/*(改进算法) 取消求交，减少计算量*/
		//先从AET表中删除ymax==i的结点****************************************/
		//像素的取舍问题，保证多边形的“下闭上开”，避免填充扩大化（交点的个数应保证为偶数个）
		AET* q = pAET;
		p = q->next;
		while (p)
		{
			if (p->ymax == i)
			{
				q->next = p->next;
				delete p;
				p = q->next;
			}
			else
			{
				q = q->next;
				p = q->next;
			}
		}

		//若NET中有新点，将其用插入法插入AET，按x递增的顺序排列
		p = pNET[i]->next;
		q = pAET;
		while (p)
		{
			while (q->next && p->x >= q->next->x)
				q = q->next;
			//插入p
			NET* t = p->next;
			p->next = q->next;
			q->next = p;
			p = t;

			q = pAET;//回到头
		}

		//配对后填充颜色
		p = pAET->next;
		while (p && p->next != NULL)
		{
			for (float j = p->x; j <= p->next->x; j++)
			{
				//扫描线画点
				draw_a_point(j, i);
				//cout << "(" << j << ", " << i << ")" << endl;
			}
			p = p->next->next;//考虑端点情况
		}
	}
	glFlush();
}
void mymouse(int button, int state, int x, int y)
{
	//左键
	if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN)
	{
		draw_a_point(x, window_height - y);

		point p(x, window_height - y);
		vertice.push_back(p);
		cout << "顶点" << vertice.size() << ": (" << x << ", " << window_height - y << ")" << endl;
	}
	//右键
	if (button == GLUT_RIGHT_BUTTON && state == GLUT_DOWN)
	{
		glClearColor(1, 1, 1, 1);//设置绘制窗口颜色为白色
		glColor3f(0, 1, 1);

		//绘制多边形
		glBegin(GL_LINES);	
		for (int i = 0; i < vertice.size(); i++)
		{
			if (i == vertice.size() - 1)//画完最后一个点，使其闭合
			{
				glVertex2f(vertice[0].x, vertice[0].y);
				glVertex2f(vertice[i].x, vertice[i].y);
			}
			else
			{
				glVertex2f(vertice[i].x, vertice[i].y);
				glVertex2f(vertice[i + 1].x, vertice[i + 1].y);
			}
		}
		glEnd();
		glFlush();
	}

	//鼠标中间
	if (button == GLUT_MIDDLE_BUTTON && state == GLUT_DOWN)
	{
		//cout << "center: (" << x << ", " << y << ")" << endl;
		//BoundaryFill4(x, window_height - y);
		//BoundaryFill4_Stack(x, window_height - y);

		cout << "多边形顶点个数为" << vertice.size() << "。 " << "开始扫描线填充。" << endl;
		PolyScan();
	}
}
void display()
{
	glClear(GL_COLOR_BUFFER_BIT);
	glColor3f(0.0, 0.4, 0.2);
	glPointSize(1);
	glBegin(GL_POINTS);
	PolyScan();
	glEnd();
	glFlush();
}

总结

扫描线算法部分，建立NET 和 建立并且更新活性边表AET 这两个地方比较复杂，可以带入图中多想

Timer95
关注
  • 20
    点赞
  • 踩
  • 184
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
OpenGL实现多边形扫描转换的扫描线算法
purewinds' column
06-16 9027
  学习过程中的一个小小笔记^_^ 主要内容：1、编写程序实现多边形扫描转换的扫描线算法–– 多边形的输入（鼠标）–– 非自相交多边形–– 三角形的特殊性2、利用OpenGL函数实现柱状图和饼图函数 实现步骤：1、 初始化OpenGL环境2、 构建几何类及其肋间关系，如图：  3、以父类CGraph 指针管理界面上的各种图形，即各种图形由CG
OPENGL扫描线填充算法
12-04
完整的OPENGL的扫描线算法，基于VS2017开发。文件已经打好，自己找个路径放就行
图形学初步----------多边形填充算法
Arcobaleno
11-05 2万+
参考博文： https://blog.csdn.net/xiaowei_cqu/article/details/7693985 https://blog.csdn.net/xiaowei_cqu/article/details/7712451 https://blog.csdn.net/wodownload2/article/details/52154207 https://blog.cs...
c++多边形扫描线填充算法_扫描线填充算法-有序边表法
weixin_39945789的博客
12-01 940
一、定义边的数据结构1、边的ymax2、边的底端x坐标3、斜率的倒数1/m4、指向下条边的指针二、多边形边表（ET）1、与x轴平行的边不计入2、多次相交的点记录方式如下：边表具体记录方式如图：三、活动边表（AET）从多边形的ymin开始，步长为1向上扫描。活动边表记录了扫描线与多边形的相交情况。若当前的的y到达了活动边表内某一边的ymax，把该边删除。若当前的y处有新的边信息，把新边加入。然后重新...
扫描线填充算法：OpenGL GLFW实现交互多边形填充
playerz的博客
11-08 884
代码 #include <GLFW/glfw3.h> #include<iostream> #include<vector> #define WIDTH 960.f // width of main window #define HEIGHT 600.f // height of main window using namespace std; const int MAXN = 600; // >= HEIGHT, 扫描线 // hide the con
计算机图形学 ———— 扫描线多边形填充算法 （讲解）
热门推荐
DUGUjing的博客
10-15 4万+
一.基本原理            扫描线多边形区域填充算法是按扫描线顺序（由下到上），计算扫描线与多边形的相交区间，再用要求的颜色显示这些区间的象素，即完成填充工作。                                                    区间的端点可以通过计算扫描线与多边形边界线的交点获得。            对于一条扫描线，多边形的填充过程可以分为四...
c++多边形扫描线填充算法_计算机图形学——区域填充算法
weixin_39926016的博客
11-24 1611
一、区域填充概念区域：指已经表示成点阵形式的填充图形，是象素的集合。区域填充：将区域内的一点(常称 【种子点】)赋予给定颜色，然后将这种颜色 扩展到整个区域内的过程。区域填充算法要求区域是连通的，因为只有在连通区域中，才可能将种子点的颜色扩展到区域内的其它点。1、区域有两种表示形式1)内点表示：枚举出区域内部的所有象素，内部所有象素着同一个颜色，边界像素着与内部象素不同的颜色。2)边界表示：枚举出...
扫描线填充算法的OpenGL实现
02-28
总结来说，"扫描线填充算法的OpenGL实现"是一个将计算机图形学理论与实际编程相结合的项目，它利用了扫描线填充算法、活化边表数据结构以及GLUT库来创建和显示多边形。这个项目不仅展示了图形处理的基础，还提供了...
多边形填充扫描线算法
11-23
总之，“多边形填充扫描线算法”是计算机图形学中的一个基础概念，通过VS2008和OpenGL，我们可以将理论转化为实际的图形绘制。结合GLUT库，我们能够实现用户交互，使得程序更具实用性和灵活性。这个过程涉及到了图形...
计算机图形学扫描线试验源代码
05-02
在计算机图形学中，扫描线算法是一种广泛应用于2D图形渲染的技术。这个压缩包包含的"计算机图形学扫描线试验源代码"提供了对这一算法的实践演示。 扫描线算法的基本思想是从上到下（或从下到上）遍历图像的每一行，...
openGL-扫描线填充算法
FrankDura的博客
03-16 7141
说明把最近一系列的图形学经典算法实现了一下。课业繁忙，关于该系列的推导随后再写。但是在注释里已经有较为充分的分析。分情况讨论注意对于横线需要特别讨论，但是对于垂直线却不必特别讨论。想一想为什么？代码#include <iostream> #include <GLUT/GLUT.h> #include <map> #include <vector> #include <list> #include <
c语言图形学扫描线填充算法,《计算机图形学》OpenGL实现扫描线填充算法
weixin_33870147的博客
05-23 592
顾名思义啊，就是在OpenGL中用扫描填充算法画一个稍微复杂的图形：#include #include #include #include #define COLOR_NEW 1.0,0.0,0.0#define FALSE 0#define TRUE 1struct Point{int x;int y;Point(int a=0,int b=0){x=a;y=b;}};struct Bian_l...
计算机图形学——扫描线填充算法（有序边表）代码简单易懂可运行
weixin_52036334的博客
11-04 1494
【代码】计算机图形学——扫描线填充算法（有序边表）代码简单易懂可运行。
多边形颜色填充-X扫描线算法
SX2101111的博客
03-28 4897
在光栅显示器上选定一系列的点，将点按顺序连接起来形成一个封闭的多边形，并对多边形内的像素点进行颜色填充。本文主要介绍X扫描线算法以实现多边形内目标像素点的确定。 一.X扫描线算法 首先确定该多边形的和，通过y变量以为起点，以为终点，每次步长为1，与多边形相交求得交点，在交点的区间内所得的整数即为所求像素点。例如下图，，扫描线y=4与多边形交于P1、P2、P3、P4点，4个交点的x坐标分别为3.20、5.33、6.50、8.43，因此所求的目标像素点分别为P1和P2区间[4,4]、[5,4]，P3和P4区
计算机图形学——多边形区域填充算法
阿蓬的个人博客
02-10 8097
计算机图形学——区域填充算法 橡皮筋效果 本次实验的环境是使用vs提供的MFC框架，在鼠标交互输入中使用橡皮筋算法来实现多边形的输入。首先定义相应变量来保存输入的数据。 int m_pNumbers; //输入点的个数 CPoint m_pAccord[N], m_mousePoint; //保存输入的顶点信息和当前的鼠标所处位置 ......
扫描线多边形填充算法及其OpenGL实现
ANI叶轻舟
12-14 7445
算法概述 Scan-line Polygon FillAlgorithm（扫描线多边形填充算法），是一种利用Vertex位置、Y-bucket sort（Y桶排序）和Activated Edge List（活化边表）的多边形填充算法。它透过活化边表对定点的描述，很好的解决了奇异点的问题；同时减少了数据存储量，使得点间的连线得以使用计算的方法得到。 算法过程 1.
计算机图形学：多边形填充算法（算法原理及代码实现）
qq_55982881的博客
02-22 1万+
一、实现方案 扫描线算法： 实现原理： 把图形的填充转换为扫描线从上往下扫描填充，这时我们只需要判断每一条扫描线与图形的交点，而我们可以根据扫描线的连贯性，对交点进行排序，第1个点与第2个点之间，第3个点与第4个点之间..... 依照此原理可以对图形进行扫描线算法扫描转换多边形，其中在判断上述交点时，还会出现扫描线与边重合、扫描线与边的交点为顶点等现象，具体实现步骤如下。 实现步骤： 1、找到多边形的最大Ymax和最小Ymin，在此范围内扫描多边形逐条； 2、一条扫描...
计算机图形学（三）扫描线多边形填充算法讲解与源代码
菜鸟
06-22 3万+
如果喜欢转载请标明出处： 并非菜鸟菜鸟的博客 源代码下载：点击打开链接 在这里先说下算法的实现过程 本人觉得这个算法实现起来还是有点难度的！很多人都不愿意去看太多描述性的文字，所以对这个算法的过程是什么大概也不知道，那么我在这里简要的说一些！ 算法实现过程中应用两个数据结构： 1、边表（ET：Edge Table） 用来对除水平边外的所有边进行登记，来建立边的记录。边的记录定
基于橡皮筋划线后的多边形区域填充算法（有序边表）
weixin_43275631的博客
05-11 340
如图对围出的多边形进行填充：                                         
计算机图形学扫描线种子填充算法java代码
最新发布
05-19
以下是使用Java实现的扫描线种子填充算法： ```java import java.awt.*; import java.util.*; public class ScanlineSeedFill { private int[][] canvas; // 存储像素颜色的二维数组 private int width, height; // 画布宽度和高度 private int fillColor; // 填充的颜色 private int borderColor; // 边框颜色 private int tolerance; // 颜色容差 public ScanlineSeedFill(int[][] canvas, int width, int height, int fillColor, int borderColor, int tolerance) { this.canvas = canvas; this.width = width; this.height = height; this.fillColor = fillColor; this.borderColor = borderColor; this.tolerance = tolerance; } public void seedFill(int x, int y) { if (x < 0 || x >= width || y < 0 || y >= height) { return; // 超出画布范围，返回 } int targetColor = canvas[x][y]; // 目标颜色 if (targetColor == fillColor || targetColor == borderColor) { return; // 已经填充过或者是边框颜色，返回 } Queue<Point> queue = new LinkedList<>(); queue.offer(new Point(x, y)); while (!queue.isEmpty()) { Point p = queue.poll(); int currentX = p.x; int currentY = p.y; if (currentX < 0 || currentX >= width || currentY < 0 || currentY >= height) { continue; } int currentColor = canvas[currentX][currentY]; if (currentColor == targetColor || isSimilarColor(currentColor, targetColor)) { canvas[currentX][currentY] = fillColor; // 填充当前像素 queue.offer(new Point(currentX + 1, currentY)); // 将下一列像素加入队列 queue.offer(new Point(currentX - 1, currentY)); // 将上一列像素加入队列 queue.offer(new Point(currentX, currentY + 1)); // 将下一行像素加入队列 queue.offer(new Point(currentX, currentY - 1)); // 将上一行像素加入队列 } } } private boolean isSimilarColor(int color1, int color2) { Color c1 = new Color(color1); Color c2 = new Color(color2); int diff = Math.abs(c1.getRed() - c2.getRed()) + Math.abs(c1.getGreen() - c2.getGreen()) + Math.abs(c1.getBlue() - c2.getBlue()); return diff <= tolerance; } } ``` 使用示例： ```java public class Main { public static void main(String[] args) { int[][] canvas = new int[][]{ {0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0}, }; int width = 7; int height = 7; int fillColor = 1; int borderColor = 0; int tolerance = 1; ScanlineSeedFill fill = new ScanlineSeedFill(canvas, width, height, fillColor, borderColor, tolerance); fill.seedFill(3, 3); for (int i = 0; i < height; i++) { for (int j = 0; j < width; j++) { System.out.print(canvas[i][j] + " "); } System.out.println(); } } } ``` 输出结果： ``` 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 1 1 1 1 1 0 0 1 1 1 1 1 0 0 1 1 1 1 1 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 ``` 在这个例子中，我们创建了一个宽度和高度都为7的画布，并用0表示白色，1表示黑色。然后我们使用扫描线种子填充算法来填充从(3,3)开始的连通区域。填充颜色为1，边框颜色为0，颜色容差为1。最后输出填充后的画布。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值