From 9aeddde25c1cb2a54ef5196ba2667fd6e661f3c6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=8D=9A?= <1486806484@qq.com>
Date: Wed, 28 Jun 2023 09:22:56 +0800
Subject: [PATCH] update

---
 src/林火预测/pixel.cpp                    |  19 +++
 src/林火预测/pixel.h                      |  29 ++++
 .../风速补正综合指标法/model.cpp     | 149 ++++++++++++++++++
 3 files changed, 197 insertions(+)
 create mode 100644 src/林火预测/pixel.cpp
 create mode 100644 src/林火预测/pixel.h
 create mode 100644 src/林火预测/风速补正综合指标法/model.cpp

diff --git a/src/林火预测/pixel.cpp b/src/林火预测/pixel.cpp
new file mode 100644
index 0000000..20440aa
--- /dev/null
+++ b/src/林火预测/pixel.cpp
@@ -0,0 +1,19 @@
+#include "pixel.h"
+#include <iostream>
+
+using namespace std;
+
+int main() {
+    // ������ʵ����������������������ͼ������ռ�������
+    PixelRatioConverter p(5, 10, 100, 200);
+
+    // ��ȡ���ر���ϵ��
+    double ratio = p.getPixelRatio();
+    cout << "���ر���ϵ����" << ratio << endl;
+
+    // ������һ��������ͼ������ռ�������
+    int next_pixel_area = p.getNextPixelArea(15);
+    cout << "��һ��������ͼ������ռ���������" << next_pixel_area << endl;
+
+    return 0;
+}
\ No newline at end of file
diff --git a/src/林火预测/pixel.h b/src/林火预测/pixel.h
new file mode 100644
index 0000000..5a590a6
--- /dev/null
+++ b/src/林火预测/pixel.h
@@ -0,0 +1,29 @@
+class PixelRatioConverter {
+public:
+    // ���캯��������������ʵ�е����������������ͼ������ռ�������
+    PixelRatioConverter(double real_area1, double real_area2, int pixel_area1, int pixel_area2) {
+        this->real_area1 = real_area1;
+        this->real_area2 = real_area2;
+        this->pixel_area1 = pixel_area1;
+        this->pixel_area2 = pixel_area2;
+    }
+
+    // ��ȡ���ر���ϵ��
+    double getPixelRatio() {
+        double ratio = (real_area1 / real_area2) * (pixel_area2 / pixel_area1);
+        return ratio; // �������ر���ϵ��
+    }
+
+    // �������ر���ϵ����������һ��������ͼ������ռ�������
+    int getNextPixelArea(int next_real_area) {
+        double ratio = this->getPixelRatio();
+        int next_pixel_area = static_cast<int>(next_real_area / ratio);
+        return next_pixel_area; // ������һ��������ͼ������ռ�������
+    }
+
+private:
+    double real_area1; // ��һ����ʵ�е��������
+    double real_area2; // �ڶ�����ʵ�е��������
+    int pixel_area1; // ��һ��������ͼ������ռ�������
+    int pixel_area2; // �ڶ���������ͼ������ռ�������
+};
diff --git a/src/林火预测/风速补正综合指标法/model.cpp b/src/林火预测/风速补正综合指标法/model.cpp
new file mode 100644
index 0000000..1d8191f
--- /dev/null
+++ b/src/林火预测/风速补正综合指标法/model.cpp
@@ -0,0 +1,149 @@
+#include <iostream>
+#include <cmath>
+
+using namespace std;
+
+class ForestFireModel {
+private:
+    int rows; // ɭ�ֵ�ͼ����
+    int cols; // ɭ�ֵ�ͼ����
+    double ignitionProbability; // ��ȼ����
+    double burningProbability; // �������Ӹ���
+    double** forestMap; // ɭ�ֵ�ͼ
+
+public:
+    ForestFireModel(int rows, int cols, double ignitionProbability, double burningProbability) {
+        this->rows = rows;
+        this->cols = cols;
+        this->ignitionProbability = ignitionProbability;
+        this->burningProbability = burningProbability;
+
+        // ��ʼ��ɭ�ֵ�ͼ
+        forestMap = new double* [rows];
+        for (int i = 0; i < rows; i++) {
+            forestMap[i] = new double[cols];
+            for (int j = 0; j < cols; j++) {
+                forestMap[i][j] = (double)rand() / (RAND_MAX);
+            }
+        }
+    }
+
+    // ģ�������ɢ����
+    void simulate(int steps) {
+        for (int t = 0; t < steps; t++) {
+            double** nextMap = new double* [rows];
+            for (int i = 0; i < rows; i++) {
+                nextMap[i] = new double[cols];
+                for (int j = 0; j < cols; j++) {
+                    bool isBurning = false;
+                    bool isIgnited = (double)rand() / (RAND_MAX) < ignitionProbability;
+                    if (isIgnited || forestMap[i][j] > 0) {
+                        // �����ȼ��ǰλ���Ѿ��Ż��ж���Χ�Ƿ��л�����ɢ
+                        for (int k = -1; k <= 1; k++) {
+                            for (int l = -1; l <= 1; l++) {
+                                if (k == 0 && l == 0) {
+                                    continue;
+                                }
+                                int ii = i + k;
+                                int jj = j + l;
+                                if (ii < 0 || ii >= rows || jj < 0 || jj >= cols) {
+                                    continue;
+                                }
+                                if (forestMap[ii][jj] > 0) {
+                                    // ��Χ�л𣬵�ǰλ��Ҳ�Ż�
+                                    isBurning = true;
+                                }
+                                else if ((double)rand() / (RAND_MAX) < burningProbability) {
+                                    // ͨ�����ʾ�����ǰλ���Ƿ��Ż�
+                                    isBurning = true;
+                                }
+                            }
+                        }
+                    }
+                    nextMap[i][j] = isBurning ? 1 : (isIgnited ? 0.5 : forestMap[i][j]);
+                }
+            }
+            // ����ɭ�ֵ�ͼ
+            for (int i = 0; i < rows; i++) {
+                for (int j = 0; j < cols; j++) {
+                    forestMap[i][j] = nextMap[i][j];
+                }
+                delete[] nextMap[i];
+            }
+            delete[] nextMap;
+        }
+    }
+
+    // ����ָ��λ�õĻ��������ٶ�
+    double spreadSpeed(int x, int y) {
+        double speed = 0;
+        if (forestMap[x][y] == 0) {
+            return speed;
+        }
+        for (int i = 0; i < rows; i++) {
+            for (int j = 0; j < cols; j++) {
+                double distance = sqrt(pow(x - i, 2) + pow(y - j, 2));
+                if (forestMap[i][j] > 0 && distance > 0) {
+                    speed += forestMap[i][j] / distance;
+                }
+            }
+        }
+        return speed;
+    }
+
+    // ���㵱ǰ��������Χ�İ뾶
+    double fireRadius() {
+        double radius = 0;
+        for (int i = 0; i < rows; i++) {
+            for (int j = 0; j < cols; j++) {
+                if (forestMap[i][j] >= 1) {
+                    double distance = sqrt(pow(i - rows / 2, 2) + pow(j - cols / 2, 2));
+                    radius = max(radius, distance);
+                }
+            }
+        }
+        return radius;
+    }
+
+    // ���ɭ�ֵ�ͼ
+    void printMap() {
+        for (int i = 0; i < rows; i++) {
+            for (int j = 0; j < cols; j++) {
+                if (forestMap[i][j] >= 1) {
+                    cout << "* ";
+                }
+                else if (forestMap[i][j] > 0) {
+                    cout << "o ";
+                }
+                else {
+                    cout << ". ";
+                }
+            }
+            cout << endl;
+        }
+    }
+
+    ~ForestFireModel() {
+        for (int i = 0; i < rows; i++) {
+            delete[] forestMap[i];
+        }
+        delete[] forestMap;
+    }
+};
+
+int main() {
+    srand(time(0));
+
+    // ģ��һ��5x5��ɭ�֣���ȼ����Ϊ0.2���������Ӹ���Ϊ0.8��ģ��100��
+    ForestFireModel model(5, 5, 0.2, 0.8);
+    model.simulate(100);
+    model.printMap();
+
+    // ����ָ��λ�õĻ��������ٶ�
+    cout << "Spread speed at position (2, 3): " << model.spreadSpeed(2, 3) << endl;
+
+    // ���㵱ǰ��������Χ�İ뾶
+    cout << "Fire radius: " << model.fireRadius() << endl;
+
+    return 0;
+}