细胞自动机与森林火灾与燃烧模拟

news2024/10/5 17:27:06

基于 元胞自动机-森林火灾模拟_vonneumann邻域-CSDN博客

 进行略微修改，解决固定方向着火问题，用了一个meshv2数组记录下一状态，避免旧状态重叠数据失效。

参数调整

澳洲森林火灾蔓延数学建模，基于元胞自动机模拟多模式下火灾蔓延（附部分源码）海啸传播模型_51CTO博客_森林火灾蔓延数学模型

生命游戏 - CodeBus 

// 生命游戏学习

#include <easyx/easyx.h>
#include <conio.h>
#include <time.h>


int world[102][102];								// 二维世界，每个格子是一个细胞
IMAGE imgLive, imgEmpty;


// 方形世界
void SquareWorld() {
	memset(world, 0, 102 * 102 * sizeof(int));		// 分配内存

	for (int i = 1; i <= 100; i++) {
		world[i][1] = world[i][100] = 1;
	}
	for (int j = 1; j <= 100; j++) {
		world[1][j] = world[100][j] = 1;
	}
}
// 设置界面
void Init() {
	initgraph(640, 480);

	srand((unsigned)time(NULL));		// 设置随机种子

	Resize(&imgLive, 4, 4);				// 一个格子放置一个细胞，一个细胞占4像素
	Resize(&imgEmpty, 4, 4);
	SetWorkingImage(&imgLive);			// 在imgLive上绘制
	setfillcolor(GREEN);
	fillellipse(0, 0, 3, 3);			// 给格子涂色
	SetWorkingImage(&imgEmpty);			// 在imgEmpty上绘制
	setfillcolor(DARKGRAY);
	rectangle(1, 1, 2, 2);				// 给格子涂色

	SetWorkingImage();

	SquareWorld();						// 产生默认的细胞以方形分布的世界
}
// 绘制世界
void PaintWorld() {
	for (int i = 1; i <= 100; i++)
		for (int j = 1; j <= 100; j++)
			putimage(16 + j * 4, 56 + i * 4, world[i][j] == 1 ? &imgLive : &imgEmpty);		// 格子是1，就房子imgLive,否则就贴图贴入imgEmpty
}


// 进化
void Evolution() {
	int tmp[102][102]={0};			// 临时数组  一定要初始化为0，否则会图像不对称，因为有数据残留
	int sum;						// 九宫格中的活细胞格个数


	for (int i = 1; i <= 100; i++) {				//	一个细胞在下一个时刻的生死取决于相邻八个方格中的活细胞数量，
		for (int j = 1; j <= 100; j++) {
			sum = world[i - 1][j - 1] + world[i - 1][j + 0] + world[i - 1][j + 1] +			// 序号与排版对应，i-1就是上一行，j-1就是最左列，
			      world[i + 0][j - 1] +						+ world[i + 0][j + 1] +			// i是本行，j是本列
			      world[i + 1][j - 1] + world[i + 1][j + 0] + world[i + 1][j + 1];			// i+1是下一行，j+1是最右列


			switch (sum) {
				case 3:
					tmp[i][j] = 1;					// 若周围有 3 个活细胞，则该方格产生一个活细胞（模拟繁殖）
					break;
				case 2:
					tmp[i][j] = world[i][j];		// 若周围有 2 个或 3 个活细胞，保持原样。
					break;
				default:
					tmp [i][j] = 0;					// 若周围少于 2 个活细胞，则该方格的细胞死亡（模拟人口稀疏）,若周围多于 3 个活细胞，则该方格的细胞死亡（模拟极度拥挤）
					break;
			}
		}
	}
	// tmp 产生原因：隔断新旧世界数据
	// 因为 sum 需要的是旧世界周围的数据，如果直接更新，导致旧世界数据不知，直接拿新世界的数据采样，结果更不可理解，于是使用 tmp 数组记录

// 将临时数组恢复为世界
	memcpy(world, tmp, 102 * 102 * sizeof(int));	// 就是复制粘贴，主要是int 而不是 __int8
}

int main() {
	Init();
	int speed = 10;									// 游戏刷新速度10毫秒

	while (1) {
		Evolution();
		PaintWorld();
		Sleep(speed);
	}

	return 0;
}

 

// 联系方式 b站 民用级脑的研发记录
// 细胞自动机森林火灾模型演示，
// 开发环境 小熊猫c++ 2.25.1 
// 基于 //https://blog.csdn.net/weixin_43524214/article/details/105099165
// 使用 easyx 图形库
#include <stdio.h>
#include <stdlib.h>
#include <easyx/graphics.h>
#include <time.h>
#include <math.h>

// 定义树木状态，给数字贴上意义，用于快速理解代码
#define no_tree 0
#define burning 2
#define nor_tree 1


#define WIDTH 600		// 宽度
#define HEIGHT 600		// 高度
#define treeSize 4		// 树木大小
#define treeNum 150		// 树木个数
#define Row 150			// 150 行
#define Col 150			// 150 列
#define burning_rate	0.0001			// 初始燃烧概率0.01%
#define proTree_rate	0.02			// 空地长出新的树木的概率：10%
#define unsafe_rate		0.00005			// 新长出树木又失火的概率 0，0005%
#define N 10000

/*
演化规则如下：
（1）若某树木元胞的4个邻居中有燃烧着的，那么该元胞下一时刻的状态是燃烧；
（2）一个燃烧着的元胞，在下一时刻变成空位；
（3）所有树木元胞（状态为2）以一个低概率开始燃烧（模拟闪电造成森林火灾）；
（4）所有空位元胞以一个低概率变为树木（模拟新树木的生长）。
*/

int treeState_Matrix[treeNum][treeNum];	// 树木格子，一个格子就是一棵树

struct POS {
	int x;
	int y;
};

// 画边界,画黑色线
void InitBoard() {
	setlinecolor(RGB(0, 0, 0));					// 黑线
	for (int i = 0; i < treeNum; i++) {			// 每个格子横纵线
		line(0, i * treeSize, WIDTH, i * treeSize);
		line(i * treeSize, 0, i * treeSize, HEIGHT);
	}
}
// 随机产生树木
void InitTree(int treeState_Matrix[treeNum][treeNum]) {
	int i, j, count = 0;
	float randVal;													// 记录概率
	for (i = 0; i < Row; i++) {
		for (j = 0; j < Col; j++) {
			randVal = rand() % (N + 1) / (float)(N + 1);			// % 取余数用于获取小于N+1的数字，（float)强制转换为小数，解决整数除整数只取商的默认情况导致的数据为0问题。
			if (randVal >= 0.40) {									// 随机数大于0.40，就生成树木，格子里记录为1
				treeState_Matrix[i][j] = 1;							// [i][j]代表当前树木的行列
				count++;
			} else {
				treeState_Matrix[i][j] = 0;							// 随机数小，就没有树
			}
		}
	}
}

// 画树，就是从数字数组到图片的查找过程
void drawTree(int treeState_Matrix[treeNum][treeNum]) {
	int i, j;
	for (i = 0; i < Row; i++) {
		for (j = 0; j < Col; j++) {
			if (treeState_Matrix[i][j] == 1) {				// 没燃烧的树是 1
				setfillcolor(RGB(0, 255, 0));					// 绿色
			} else if (treeState_Matrix[i][j] == 2) {				// 燃烧的树木记录为2
				setfillcolor(RGB(255, 0, 0));					// 红色
			} else {
				setfillcolor(RGB(0, 0, 0));					// 记录为0就是没有树，用黑色填空
			}
			fillrectangle(j * treeSize, i * treeSize, j * treeSize + treeSize, i * treeSize + treeSize);			// 数组 i 选择哪一行，就是控制选择高度 j 对应哪一列，就是对应宽 x坐标
		}
	}
}

// 随机一个燃烧位置,同随机产生树木
void InitRandTreePos() {
	int i, j, count = 0;
	float randVal;
	for (i = 0; i < Row; i++) {
		for (j = 0; j < Col; j++) {
			if (treeState_Matrix[i][j] == 1) {
				randVal = rand() % (N + 1) / (float)(N + 1);
				if (randVal < burning_rate) {
					treeState_Matrix[i][j] = 2;				// 树木网格里第i行第j列记录为2，对应红色，着火
					count++;
				}
			}
		}
	}
	printf("着了%d 棵树\n", count);
}
// 检查随机数,随机小于就着火
int isRight(float state) {
	float randVal = rand() % (N + 1) / (float)(N + 1);
	if (randVal < state) {
		return 1;
	}
	return 0;
}

// 根据旧网格存储新网格数据
void getNextTreeState(int treeState_Matrix[treeNum][treeNum]) {
	int meshv2[treeNum][treeNum] = {0};
	int i, j, state = 0;
	for (i = 0; i < treeNum; i++) {
		for (j = 0; j < treeNum; j++) {
			state = treeState_Matrix[i][j];
			if (state == 1) {								// 检查上下左右
				if (0 ||									(treeState_Matrix[i - 1][j - 0] == 2) ||
				    (treeState_Matrix[i - 0][j - 1] == 2) ||										(treeState_Matrix[i + 0][j + 1] == 2) ||
				   0 ||									 (treeState_Matrix[i + 1][j + 0] == 2)
				   ) {
					meshv2[i][j] = 2;						// 于是被其他着火的树木点着
				}else{
					meshv2[i][j]=1;							// 否则不着火
				}
			} else if (state == 2) {								// 现在着火，下次就空
				meshv2[i][j] = 0;
			} else if (state == 0) {								// 是空的就看看会不会长树
				if (isRight(proTree_rate)) {						// 小于概率就长树木
					meshv2[i][j] = 1;
				}
				if (isRight(unsafe_rate)) {					// 新的树木再着火概率
					meshv2[i][j] = 2;
				}
			}
		}
	}
	memcpy(treeState_Matrix, meshv2, treeNum* treeNum* sizeof(int));
}

//主函数：程序入口
int main(int args, char* argv) {
	initgraph(WIDTH, HEIGHT, SHOWCONSOLE);				//初始化窗体：500*500
	HWND hwnd = GetHWnd();								//获取窗体句柄
	SetWindowText(hwnd, _T("林森火灾模拟"));				//设置窗体标题
	SetWindowPos(hwnd, NULL, 600, 200, HEIGHT, WIDTH, 0);//设置窗体位置
	//1、初始化网格布局
	InitBoard();
	srand((int)time(NULL));								//随机数种子
	//2、初始化数目状态矩阵
	InitTree(treeState_Matrix);
	//3、绘制树木
	drawTree(treeState_Matrix);
	//4、初始化燃烧树木的位置
	InitRandTreePos();
	//5、绘制森林-树木
	drawTree(treeState_Matrix);

	//开启批量绘图模式
	BeginBatchDraw();
	while (true) { //进入循环迭代
		//6、获取下一时刻的树木状态矩阵
		getNextTreeState(treeState_Matrix);
		//7、仍然有可能产生新的火源
//		burn_again();									// 被整合进getNextTreeState
		//8、重新绘制森林-树木
		drawTree(treeState_Matrix);
		//显示绘图结果
		FlushBatchDraw(); // 显示绘制
		//停顿0.001s
		Sleep(1);
//		printf("ok\n");
	}
	EndBatchDraw();										//结束批量绘图模式
	closegraph();										//关闭设备窗口
	return 0;
}

getNextTreeState 微调参数

右边着火比左边快，往左跑

// 联系方式 b站 民用级脑的研发记录
// 细胞自动机森林火灾模型演示，
// 开发环境 小熊猫c++ 2.25.1 
// 基于 //https://blog.csdn.net/weixin_43524214/article/details/105099165
// 使用 easyx 图形库
#include <stdio.h>
#include <stdlib.h>
#include <easyx/graphics.h>
#include <time.h>
#include <math.h>

// 定义树木状态，给数字贴上意义，用于快速理解代码
#define no_tree 0
#define burning 2
#define nor_tree 1


#define WIDTH 600		// 宽度
#define HEIGHT 600		// 高度
#define treeSize 4		// 树木大小
#define treeNum 150		// 树木个数
#define Row 150			// 150 行
#define Col 150			// 150 列
#define burning_rate	0.0001			// 初始燃烧概率0.01%
#define proTree_rate	0.02			// 空地长出新的树木的概率：10%
#define unsafe_rate		0.00005			// 新长出树木又失火的概率 0，0005%
#define N 10000

/*
演化规则如下：
（1）若某树木元胞的4个邻居中有燃烧着的，那么该元胞下一时刻的状态是燃烧；
（2）一个燃烧着的元胞，在下一时刻变成空位；
（3）所有树木元胞（状态为2）以一个低概率开始燃烧（模拟闪电造成森林火灾）；
（4）所有空位元胞以一个低概率变为树木（模拟新树木的生长）。
*/

int treeState_Matrix[treeNum][treeNum];	// 树木格子，一个格子就是一棵树

struct POS {
	int x;
	int y;
};

// 画边界,画黑色线
void InitBoard() {
	setlinecolor(RGB(0, 0, 0));					// 黑线
	for (int i = 0; i < treeNum; i++) {			// 每个格子横纵线
		line(0, i * treeSize, WIDTH, i * treeSize);
		line(i * treeSize, 0, i * treeSize, HEIGHT);
	}
}
// 随机产生树木
void InitTree(int treeState_Matrix[treeNum][treeNum]) {
	int i, j, count = 0;
	float randVal;													// 记录概率
	for (i = 0; i < Row; i++) {
		for (j = 0; j < Col; j++) {
			randVal = rand() % (N + 1) / (float)(N + 1);			// % 取余数用于获取小于N+1的数字，（float)强制转换为小数，解决整数除整数只取商的默认情况导致的数据为0问题。
			if (randVal >= 0.40) {									// 随机数大于0.40，就生成树木，格子里记录为1
				treeState_Matrix[i][j] = 1;							// [i][j]代表当前树木的行列
				count++;
			} else {
				treeState_Matrix[i][j] = 0;							// 随机数小，就没有树
			}
		}
	}
}

// 画树，就是从数字数组到图片的查找过程
void drawTree(int treeState_Matrix[treeNum][treeNum]) {
	int i, j;
	for (i = 0; i < Row; i++) {
		for (j = 0; j < Col; j++) {
			if (treeState_Matrix[i][j] == 1) {				// 没燃烧的树是 1
				setfillcolor(RGB(0, 255, 0));					// 绿色
			} else if (treeState_Matrix[i][j] == 2) {				// 燃烧的树木记录为2
				setfillcolor(RGB(255, 0, 0));					// 红色
			} else {
				setfillcolor(RGB(0, 0, 0));					// 记录为0就是没有树，用黑色填空
			}
			fillrectangle(j * treeSize, i * treeSize, j * treeSize + treeSize, i * treeSize + treeSize);			// 数组 i 选择哪一行，就是控制选择高度 j 对应哪一列，就是对应宽 x坐标
		}
	}
}

// 随机一个燃烧位置,同随机产生树木
void InitRandTreePos() {
	int i, j, count = 0;
	float randVal;
	for (i = 0; i < Row; i++) {
		for (j = 0; j < Col; j++) {
			if (treeState_Matrix[i][j] == 1) {
				randVal = rand() % (N + 1) / (float)(N + 1);
				if (randVal < burning_rate) {
					treeState_Matrix[i][j] = 2;				// 树木网格里第i行第j列记录为2，对应红色，着火
					count++;
				}
			}
		}
	}
	printf("着了%d 棵树\n", count);
}
// 检查随机数,随机小于就着火
int isRight(float state) {
	float randVal = rand() % (N + 1) / (float)(N + 1);
	if (randVal < state) {
		return 1;
	}
	return 0;
}

//参数调整自 https://blog.51cto.com/u_15458165/4807865
// 根据旧网格存储新网格数据
void getNextTreeState(int treeState_Matrix[treeNum][treeNum]) {
	int meshv2[treeNum][treeNum] = {0};
	int i, j, state = 0;
	for (i = 0; i < treeNum; i++) {
		for (j = 0; j < treeNum; j++) {
			state = treeState_Matrix[i][j];
			if (state == 1) {								// 检查上下左右
				if (0 ||									(treeState_Matrix[i - 1][j - 0] == 2) ||
					(treeState_Matrix[i - 0][j - 1] == 2) ||										(treeState_Matrix[i + 0][j + 1] == 2) ||(treeState_Matrix[i+0][j+2]==2)||		// 右边火势大，隔两个也能着火，于是往左跑的快
					0 ||									 (treeState_Matrix[i + 1][j + 0] == 2)
					) {
					meshv2[i][j] = 2;						// 于是被其他着火的树木点着
				}else{
					meshv2[i][j]=1;							// 否则不着火
				}
			} else if (state == 2) {								// 现在着火，下次就空
				meshv2[i][j] = 0;
			} else if (state == 0) {								// 是空的就看看会不会长树
				if (isRight(proTree_rate)) {						// 小于概率就长树木
					meshv2[i][j] = 1;
				}
				if (isRight(unsafe_rate)) {					// 新的树木再着火概率
					meshv2[i][j] = 2;
				}
			}
		}
	}
	memcpy(treeState_Matrix, meshv2, treeNum* treeNum* sizeof(int));
}

//主函数：程序入口
int main(int args, char* argv) {
	initgraph(WIDTH, HEIGHT, SHOWCONSOLE);				//初始化窗体：500*500
	HWND hwnd = GetHWnd();								//获取窗体句柄
	SetWindowText(hwnd, _T("林森火灾模拟"));				//设置窗体标题
	SetWindowPos(hwnd, NULL, 600, 200, HEIGHT, WIDTH, 0);//设置窗体位置
	//1、初始化网格布局
	InitBoard();
	srand((int)time(NULL));								//随机数种子
	//2、初始化数目状态矩阵
	InitTree(treeState_Matrix);
	//3、绘制树木
	drawTree(treeState_Matrix);
	//4、初始化燃烧树木的位置
	InitRandTreePos();
	//5、绘制森林-树木
	drawTree(treeState_Matrix);
	
	//开启批量绘图模式
	BeginBatchDraw();
	while (true) { //进入循环迭代
		//6、获取下一时刻的树木状态矩阵
		getNextTreeState(treeState_Matrix);
		//7、仍然有可能产生新的火源
//		burn_again();									// 被整合进getNextTreeState
		//8、重新绘制森林-树木
		drawTree(treeState_Matrix);
		//显示绘图结果
		FlushBatchDraw(); // 显示绘制
		//停顿0.001s
		Sleep(1);
//		printf("ok\n");
	}
	EndBatchDraw();										//结束批量绘图模式
	closegraph();										//关闭设备窗口
	return 0;
}

getNextTreeState 微调参数

往下吹风

// 联系方式 b站 民用级脑的研发记录
// 细胞自动机森林火灾模型演示，
// 开发环境 小熊猫c++ 2.25.1 
// 基于 //https://blog.csdn.net/weixin_43524214/article/details/105099165
// 使用 easyx 图形库
#include <stdio.h>
#include <stdlib.h>
#include <easyx/graphics.h>
#include <time.h>
#include <math.h>

// 定义树木状态，给数字贴上意义，用于快速理解代码
#define no_tree 0
#define burning 2
#define nor_tree 1


#define WIDTH 600		// 宽度
#define HEIGHT 600		// 高度
#define treeSize 4		// 树木大小
#define treeNum 150		// 树木个数
#define Row 150			// 150 行
#define Col 150			// 150 列
#define burning_rate	0.0001			// 初始燃烧概率0.01%
#define proTree_rate	0.02			// 空地长出新的树木的概率：10%
#define unsafe_rate		0.00005			// 新长出树木又失火的概率 0，0005%
#define N 10000

/*
演化规则如下：
（1）若某树木元胞的4个邻居中有燃烧着的，那么该元胞下一时刻的状态是燃烧；
（2）一个燃烧着的元胞，在下一时刻变成空位；
（3）所有树木元胞（状态为2）以一个低概率开始燃烧（模拟闪电造成森林火灾）；
（4）所有空位元胞以一个低概率变为树木（模拟新树木的生长）。
*/

int treeState_Matrix[treeNum][treeNum];	// 树木格子，一个格子就是一棵树

struct POS {
	int x;
	int y;
};

// 画边界,画黑色线
void InitBoard() {
	setlinecolor(RGB(0, 0, 0));					// 黑线
	for (int i = 0; i < treeNum; i++) {			// 每个格子横纵线
		line(0, i * treeSize, WIDTH, i * treeSize);
		line(i * treeSize, 0, i * treeSize, HEIGHT);
	}
}
// 随机产生树木
void InitTree(int treeState_Matrix[treeNum][treeNum]) {
	int i, j, count = 0;
	float randVal;													// 记录概率
	for (i = 0; i < Row; i++) {
		for (j = 0; j < Col; j++) {
			randVal = rand() % (N + 1) / (float)(N + 1);			// % 取余数用于获取小于N+1的数字，（float)强制转换为小数，解决整数除整数只取商的默认情况导致的数据为0问题。
			if (randVal >= 0.40) {									// 随机数大于0.40，就生成树木，格子里记录为1
				treeState_Matrix[i][j] = 1;							// [i][j]代表当前树木的行列
				count++;
			} else {
				treeState_Matrix[i][j] = 0;							// 随机数小，就没有树
			}
		}
	}
}

// 画树，就是从数字数组到图片的查找过程
void drawTree(int treeState_Matrix[treeNum][treeNum]) {
	int i, j;
	for (i = 0; i < Row; i++) {
		for (j = 0; j < Col; j++) {
			if (treeState_Matrix[i][j] == 1) {				// 没燃烧的树是 1
				setfillcolor(RGB(0, 255, 0));					// 绿色
			} else if (treeState_Matrix[i][j] == 2) {				// 燃烧的树木记录为2
				setfillcolor(RGB(255, 0, 0));					// 红色
			} else {
				setfillcolor(RGB(0, 0, 0));					// 记录为0就是没有树，用黑色填空
			}
			fillrectangle(j * treeSize, i * treeSize, j * treeSize + treeSize, i * treeSize + treeSize);			// 数组 i 选择哪一行，就是控制选择高度 j 对应哪一列，就是对应宽 x坐标
		}
	}
}

// 随机一个燃烧位置,同随机产生树木
void InitRandTreePos() {
	int i, j, count = 0;
	float randVal;
	for (i = 0; i < Row; i++) {
		for (j = 0; j < Col; j++) {
			if (treeState_Matrix[i][j] == 1) {
				randVal = rand() % (N + 1) / (float)(N + 1);
				if (randVal < burning_rate) {
					treeState_Matrix[i][j] = 2;				// 树木网格里第i行第j列记录为2，对应红色，着火
					count++;
				}
			}
		}
	}
	printf("着了%d 棵树\n", count);
}
// 检查随机数,随机小于就着火
int isRight(float state) {
	float randVal = rand() % (N + 1) / (float)(N + 1);
	if (randVal < state) {
		return 1;
	}
	return 0;
}

// 根据旧网格存储新网格数据
void getNextTreeState(int treeState_Matrix[treeNum][treeNum]) {
	int meshv2[treeNum][treeNum] = {0};
	int i, j, state = 0;
	for (i = 0; i < treeNum; i++) {
		for (j = 0; j < treeNum; j++) {
			state = treeState_Matrix[i][j];
			if (state == 1) {								// 检查上下左右
				if (0 ||									(treeState_Matrix[i - 1][j - 0] == 2) ||
					(treeState_Matrix[i - 0][j - 1] == 2) ||										(treeState_Matrix[i + 0][j + 1] == 2) ||0			// 模拟往下吹风情况，因为上面的着火树，下面着火，下面着火，上面不一定着火，吹不上去，风是往下吹
//					0 ||									 (treeState_Matrix[i + 1][j + 0] == 2)
					) {
					meshv2[i][j] = 2;						// 于是被其他着火的树木点着
				}else{
					meshv2[i][j]=1;							// 否则不着火
				}
			} else if (state == 2) {								// 现在着火，下次就空
				meshv2[i][j] = 0;
			} else if (state == 0) {								// 是空的就看看会不会长树
				if (isRight(proTree_rate)) {						// 小于概率就长树木
					meshv2[i][j] = 1;
				}
				if (isRight(unsafe_rate)) {					// 新的树木再着火概率
					meshv2[i][j] = 2;
				}
			}
		}
	}
	memcpy(treeState_Matrix, meshv2, treeNum* treeNum* sizeof(int));
}

//主函数：程序入口
int main(int args, char* argv) {
	initgraph(WIDTH, HEIGHT, SHOWCONSOLE);				//初始化窗体：500*500
	HWND hwnd = GetHWnd();								//获取窗体句柄
	SetWindowText(hwnd, _T("林森火灾模拟"));				//设置窗体标题
	SetWindowPos(hwnd, NULL, 600, 200, HEIGHT, WIDTH, 0);//设置窗体位置
	//1、初始化网格布局
	InitBoard();
	srand((int)time(NULL));								//随机数种子
	//2、初始化数目状态矩阵
	InitTree(treeState_Matrix);
	//3、绘制树木
	drawTree(treeState_Matrix);
	//4、初始化燃烧树木的位置
	InitRandTreePos();
	//5、绘制森林-树木
	drawTree(treeState_Matrix);
	
	//开启批量绘图模式
	BeginBatchDraw();
	while (true) { //进入循环迭代
		//6、获取下一时刻的树木状态矩阵
		getNextTreeState(treeState_Matrix);
		//7、仍然有可能产生新的火源
//		burn_again();									// 被整合进getNextTreeState
		//8、重新绘制森林-树木
		drawTree(treeState_Matrix);
		//显示绘图结果
		FlushBatchDraw(); // 显示绘制
		//停顿0.001s
		Sleep(1);
//		printf("ok\n");
	}
	EndBatchDraw();										//结束批量绘图模式
	closegraph();										//关闭设备窗口
	return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1642819.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

大语言模型从Scaling Laws到MoE

大语言模型从Scaling Laws到MoE

1、摩尔定律和伸缩法则 摩尔定律&#xff08;Moores law&#xff09;是由英特尔&#xff08;Intel&#xff09;创始人之一戈登摩尔提出的。其内容为&#xff1a;集成电路上可容纳的晶体管数目&#xff0c;约每隔两年便会增加一倍&#xff1b;而经常被引用的“18个月”&#xf…
阅读更多...
【C++题解】1659. 是否含有数字5

【C++题解】1659. 是否含有数字5

问题&#xff1a;1659. 是否含有数字5 类型&#xff1a;分支结构 题目描述&#xff1a; 请从键盘读入一个五位整数 n&#xff0c;判断其是否含有数字 5&#xff0c;如果含有数字 5 &#xff0c;请输出这个 5 位数各个位的和&#xff1b;如果不含数字 5 &#xff0c;请直接输出…
阅读更多...
IoTDB 入门教程 基础篇⑧——数据库管理工具 | IDEA 连接 IoTDB

IoTDB 入门教程 基础篇⑧——数据库管理工具 | IDEA 连接 IoTDB

文章目录 一、前文二、下载iotdb-jdbc三、IDEA驱动四、IDEA连接数据库五、数据库应用六、其他 一、前文 IoTDB入门教程——导读 二、下载iotdb-jdbc 下载地址org/apache/iotdb/iotdb-jdbc&#xff1a;https://maven.proxy.ustclug.org/maven2/org/apache/iotdb/iotdb-jdbc/ 本…
阅读更多...
记录vue报错问题 in ./node_modules/axios/lib/platform/index.js

记录vue报错问题 in ./node_modules/axios/lib/platform/index.js

今天这个问题困扰了我许久 报错内容如下&#xff1a; 最初一直以为是我没装axios&#xff0c;又重新装了一次&#xff0c;后面才发现是axios版本原因&#xff0c;真的总是被版本的原因困住真的很烦 解决方法如下&#xff1a; 将axios的版本改为1.5.0 1、打开项目的文件夹“…
阅读更多...
探索LLM在广告领域的应用——大语言模型的新商业模式和新个性化广告的潜力

探索LLM在广告领域的应用——大语言模型的新商业模式和新个性化广告的潜力

概述 在网络搜索引擎的领域中&#xff0c;广告不仅仅是一个补充元素&#xff0c;而是构成了数字体验的核心部分。随着互联网经济的蓬勃发展&#xff0c;广告市场的规模已经达到了数万亿美元&#xff0c;并且还在持续扩张。广告的经济价值不断上升&#xff0c;它已经成为支撑大…
阅读更多...
C++奇迹之旅：STL初步学习

C++奇迹之旅：STL初步学习

文章目录 &#x1f4dd;什么是STL&#x1f320; STL的版本&#x1f309;STL的六大组件 &#x1f320;STL的重要性&#x1f309;如何学习STL&#x1f320;STL的缺陷&#x1f6a9;总结 &#x1f4dd;什么是STL STL(standard template libaray-标准模板库)&#xff1a;是C标准库的…
阅读更多...
ubuntu安装LVGL/lv_img_conv并在thinkphp中进行调用生成bin文件

ubuntu安装LVGL/lv_img_conv并在thinkphp中进行调用生成bin文件

项目需求&#xff1a;需要处理图片成为bin文件&#xff0c;并以二进制的方式传给蓝牙设备&#xff0c;当前仅介绍如何安装&#xff0c;对lvgl功能和简介不做过多描述 项目库地址&#xff1a;https://github.com/lvgl/lv_img_conv 安装过程比较简单 一&#xff0c;确保node.j…
阅读更多...
ubuntu20中ros与anaconda的python版本冲突问题

ubuntu20中ros与anaconda的python版本冲突问题

系统环境 原本系统是ubuntu20 noetic&#xff0c;python都在/usr/bin中&#xff0c;一共是两个版本的python&#xff0c;一个是python3.8&#xff0c;另一个是python2.7。 问题发现 当安装anaconda后&#xff0c;并且将anaconda的bin目录加入到系统环境中时候&#xff0c;…
阅读更多...
Unity 性能优化之动态批处理（四）

Unity 性能优化之动态批处理（四）

提示&#xff1a;仅供参考&#xff0c;有误之处&#xff0c;麻烦大佬指出&#xff0c;不胜感激&#xff01; 文章目录 前言一、动态合批是什么&#xff1f;二、使用动态批处理1.打开动态合批2.满足条件 三、检查动态合批是否成功五、动态合批弊端总结 前言 动态批处理是常用优…
阅读更多...
《QT实用小工具·五十四》果冻弹出效果的动画按钮

《QT实用小工具·五十四》果冻弹出效果的动画按钮

1、概述 源码放在文章末尾 该项目实现动画按钮&#xff0c;鼠标放在按钮上可以弹性拉出的三个按钮&#xff0c;使用贝塞尔曲线实现&#xff0c;项目demo显示如下所示&#xff1a; 项目部分代码如下所示&#xff1a; #ifndef WATERCIRCLEBUTTON_H #define WATERCIRCLEBUTTON…
阅读更多...
TOOL使用fiddler导出的har文件导入到postman测试接口

TOOL使用fiddler导出的har文件导入到postman测试接口

在fiddler操作 export → File → Export Sessions → alls-->http arch v1.1 导出的har文件直接拖入到浏览器的调试工具中&#xff0c; 然后复制为curl&#xff0c;导入到postman中即可&#xff01;
阅读更多...
菜鸡学习netty源码（四）—— EventLoop

菜鸡学习netty源码（四）—— EventLoop

1.概述 我们前面进行过分析，channel为netty网络操作的抽象类，EventLoop负责处理注册到其上的Channel处理的I/O事件；EventLoopGroup是一个EventLoop的分组，它可以获取到一个或者多个的EventLoop对象。 2.类关系图 NioEventLoopGroup的类继承图，蓝色部分为对应的java类，绿…
阅读更多...
IoTDB 入门教程 基础篇⑦——数据库管理工具 | DBeaver 连接 IoTDB

IoTDB 入门教程 基础篇⑦——数据库管理工具 | DBeaver 连接 IoTDB

文章目录 一、前文二、下载iotdb-jdbc三、安装DBeaver3.1 DBeaver 下载3.2 DBeaver 安装 四、安装驱动五、连接数据库六、参考 一、前文 IoTDB入门教程——导读 二、下载iotdb-jdbc 下载地址org/apache/iotdb/iotdb-jdbc&#xff1a;https://maven.proxy.ustclug.org/maven2/o…
阅读更多...
AI大模型探索之路-训练篇13：大语言模型Transformer库-Evaluate组件实践

AI大模型探索之路-训练篇13：大语言模型Transformer库-Evaluate组件实践

系列篇章&#x1f4a5; AI大模型探索之路-训练篇1&#xff1a;大语言模型微调基础认知 AI大模型探索之路-训练篇2&#xff1a;大语言模型预训练基础认知 AI大模型探索之路-训练篇3&#xff1a;大语言模型全景解读 AI大模型探索之路-训练篇4&#xff1a;大语言模型训练数据集概…
阅读更多...
2021-11-10 51蛋骗鸡单数码0-9按键条件速度逢9蜂鸣

2021-11-10 51蛋骗鸡单数码0-9按键条件速度逢9蜂鸣

缘由用Proteus设计单片机控制1只数码管&#xff0c;循环显示0~9。循环显示间隔可手动按钮调整。每当到9时&#xff0c;发出声音提示-编程语言-CSDN问答 #include "REG52.h" #include<intrins.h> sbit K1 P3^0; sbit K2 P3^1; sbit K3 P3^2; sbit K4 P3^3;…
阅读更多...
论文笔记：（Security 22） 关于“二进制函数相似性检测”的调研

论文笔记：（Security 22） 关于“二进制函数相似性检测”的调研

个人博客链接 注&#xff1a;部分内容参考自GPT生成的内容 [Security 22] 关于”二进制函数相似性检测“的调研&#xff08;个人阅读笔记&#xff09; 论文&#xff1a;《How Machine Learning Is Solving the Binary Function Similarity Problem》&#xff08;Usenix Securi…
阅读更多...
【面试经典 150 | 数组】文本左右对齐

【面试经典 150 | 数组】文本左右对齐

文章目录 写在前面Tag题目来源解题思路方法一&#xff1a;模拟 写在最后 写在前面 本专栏专注于分析与讲解【面试经典150】算法&#xff0c;两到三天更新一篇文章&#xff0c;欢迎催更…… 专栏内容以分析题目为主&#xff0c;并附带一些对于本题涉及到的数据结构等内容进行回顾…
阅读更多...
Git系列：config 配置

Git系列：config 配置

&#x1f49d;&#x1f49d;&#x1f49d;欢迎莅临我的博客&#xff0c;很高兴能够在这里和您见面&#xff01;希望您在这里可以感受到一份轻松愉快的氛围&#xff0c;不仅可以获得有趣的内容和知识&#xff0c;也可以畅所欲言、分享您的想法和见解。 推荐:「stormsha的主页」…
阅读更多...
自定义数据上的YOLOv9分割训练

自定义数据上的YOLOv9分割训练

原文地址&#xff1a;yolov9-segmentation-training-on-custom-data 2024 年 4 月 16 日 在飞速发展的计算机视觉领域&#xff0c;物体分割在从图像中提取有意义的信息方面起着举足轻重的作用。在众多分割算法中&#xff0c;YOLOv9 是一种稳健且适应性强的解决方案&#xff0…
阅读更多...
车载电子电器架构 —— 关于bus off汇总

车载电子电器架构 —— 关于bus off汇总

车载电子电器架构 —— 关于bus off汇总 我是穿拖鞋的汉子，魔都中坚持长期主义的汽车电子工程师。 老规矩，分享一段喜欢的文字，避免自己成为高知识低文化的工程师： 屏蔽力是信息过载时代一个人的特殊竞争力，任何消耗你的人和事，多看一眼都是你的不对。非必要不费力证明…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023