Merge branch 'songhaibo_branch'

src/林火预测/FP.cpp

@@ -0,0 +1,152 @@
+#include <math.h>
+#include <iostream>
+#include "levelToSpeed.h"
+
+using namespace std;
+#define M_PI acos(-1)
+
+
+class ForestFirePrediction {
+public:
+    // 构造函数
+    ForestFirePrediction(int wind_direction, double wind_level, double slope, double altitude, int cover_type, double fire_size, double temperature, double waterlevel) {
+        this->wind_direction = wind_direction;
+        this->wind_level = wind_level;
+        this->slope = slope;
+        this->altitude = altitude;
+        this->cover_type = cover_type;
+        this->fire_size = fire_size;
+        this->temperature = temperature;
+        this->waterlevel = waterlevel;
+    }
+
+    // 计算受阻距离（单位：km）
+    double get_distance() {
+        double rad_slope = slope * M_PI / 180.0; // 将坡度转化为弧度
+        double distance = sin(rad_slope) * altitude / 1000.0; // 计算受阻距离
+        return distance;
+    }
+
+    // 预测火灾蔓延范围
+    void predict_range() {
+        double impact_factor;   // 植被类型影响系数
+        double correction_coef; // 风速补正系数
+        double distance;        // 受阻距离
+        double composite_index; // 综合指数
+
+        // 根据植被类型获取影响系数
+        switch (cover_type) {
+        case 1: // 针叶林
+            impact_factor = 0.7;
+            break;
+        case 2: // 落叶林
+            impact_factor = 0.5;
+            break;
+        case 3: // 灌木林
+            impact_factor = 0.4;
+            break;
+        default:
+            cout << "植被类型输入错误！" << endl;
+            return;
+        }
+
+        // 计算风速补正系数
+        int angle = abs(wind_direction - 180); // 计算风向与火灾扩散方向之间的夹角
+        if (angle <= 45 || angle >= 315) {     // 如果夹角较小，则不需要进行风速补正
+            correction_coef = 1;
+        }
+        else {
+            correction_coef = 0.65 + 0.35 * cos((angle - 45) * M_PI / 270.0); // 使用公式计算风速补正系数
+        }
+
+        // 计算受阻距离
+        distance = get_distance();
+
+        // 计算综合指数
+        composite_index = correction_coef * (1 + distance) * impact_factor;
+
+        // 计算火灾蔓延半径
+        double radius = sqrt(fire_size * 1000000 * composite_index) / M_PI;
+        double range = radius * pow(10, 1.5 * levelToSpeed(wind_level) / 30.0);
+
+        // 输出预测结果
+        cout << "火灾蔓延范围预测结果：" << endl;
+        cout << "火源最可能在" << radius << "米范围内发生。" << endl;
+        cout << "在风速为 " << wind_level << "级风的情况下，火源最可能的蔓延范围为 " << range << " 米。" << endl;
+    }
+
+    // 预测火灾蔓延速度
+    void predict_speed(int level) {
+        double slope_factor; // 坡度影响因子
+        double speed_factor; // 风速影响因子
+        double size_factor;  // 火源面积影响因子
+
+        // 计算坡度影响因子
+        if (slope > 0) {
+            slope_factor = pow(3.33, sqrt(slope));
+        }
+        else {
+            slope_factor = 1;
+        }
+
+        // 计算风速影响因子
+        double wind_speed = levelToSpeed(wind_level);
+        speed_factor = 5.15 * pow(wind_speed, 0.39) + 0.299 * temperature + 0.009 * (100 - waterlevel) - 0.304;
+
+        // 计算火源面积影响因子
+        size_factor = pow(fire_size, 0.77);
+
+        // 计算火灾蔓延速度
+        double speed = 0.348 * sqrt(size_factor * slope_factor * speed_factor);
+
+
+        // 输出预测结果
+        cout << "火灾蔓延速度预测结果：" << endl;
+        cout << "火灾蔓延速度可能为" << speed << "km/h。" << endl;
+    }
+
+private:
+    int wind_direction; // 风向（单位：度）
+    double wind_level;  // 风力等级
+    double slope;       // 坡度（单位：度）
+    double altitude;    // 海拔高度（单位：m）
+    int cover_type;     // 植被类型（1：针叶林；2：落叶林；3：灌木林）
+    double fire_size;   // 火源面积（单位：平方米）
+    double temperature; // 温度（单位：摄氏度）
+    double waterlevel;  // 湿度（单位：%）
+};
+
+int main() {
+    // 读取参数
+    int wind_direction;
+    int wind_level;
+    double slope;
+    double altitude;
+    int cover_type;
+    double fire_size;
+    double temperature;
+    double waterlevel;
+    cout << "请输入风向（0-360度）：" << endl;
+    cin >> wind_direction;
+    cout << "请输入风力等级（级）：" << endl;
+    cin >> wind_level;
+    cout << "请输入坡度（度）：" << endl;
+    cin >> slope;
+    cout << "请输入海拔高度（m）：" << endl;
+    cin >> altitude;
+    cout << "请输入植被类型（1：针叶林；2：落叶林；3：灌木林）：" << endl;
+    cin >> cover_type;
+    cout << "请输入火源面积（m^2）：" << endl;
+    cin >> fire_size;
+    cout << "请输入当天气温（°C）：" << endl;
+    cin >> temperature;
+    cout << "请输入当天湿度（%）：" << endl;
+    cin >> waterlevel;
+
+    // 预测火灾蔓延范围和速度
+    ForestFirePrediction ffp(wind_direction, wind_level, slope, altitude, cover_type, fire_size, temperature, waterlevel);
+    ffp.predict_range();
+    ffp.predict_speed(wind_level);
+
+    return 0;
+}

src/林火预测/Ks_correction.h

@@ -0,0 +1,30 @@
+#include <iostream>
+using namespace std;
+
+double Ks_cor(int cover_type)
+{
+    double impact_factor = 0;
+    // 根据植被类型获取影响系数
+    switch (cover_type) {
+    case 1: // 针叶林
+        impact_factor = 0.7;
+        break;
+    case 2: // 落叶林
+        impact_factor = 0.5;
+        break;
+    case 3: // 灌木林
+        impact_factor = 0.4;
+        break;
+    case 4: //枯枝落叶
+        impact_factor = 1.2;
+        break;
+    case 5: //草原
+        impact_factor = 2;
+        break;
+
+    default:
+        cout << "植被类型输入错误！" << endl;
+        return -1;
+    }
+    return impact_factor;
+}

src/林火预测/levelToSlope.h

@@ -0,0 +1,49 @@
+#include <iostream>
+#include <math.h>
+using namespace std;
+
+//0°～5°为平坡，
+//6°～15°为缓坡，
+//16°～25°为斜坡，
+//26°～35°为陡坡，
+//36°～40°为急陡坡，
+//41°～45°为急坡，
+//46°以上为险坡。
+double levelToSlope(int level) {
+    double slope = 0;
+    double theta = 0;
+    if (level >= 0 && level <= 7) {
+        
+        switch (level) {
+        case 1:
+            theta = 0;
+            break;
+        case 2:
+            theta = 11;
+            break;
+        case 3:
+            theta = 21;
+            break;
+        case 4:
+            theta = 30;
+            break;
+        case 5:
+            theta = 38;
+            break;
+        case 6:
+            theta = 45;
+            break;
+        case 7:
+            theta = 60;
+            break;
+        
+        }
+
+    }
+   
+    else {
+        cout << "无效的坡度等级！" << endl;
+    }
+    slope = tan(theta);
+    return slope;
+}

src/林火预测/levelToSpeed.h

@@ -0,0 +1,62 @@
+#include<iostream>
+using namespace std;
+
+double levelToSpeed(int level) {
+    double speed = 0;
+    if (level >= 0 && level <= 12) {
+        double speed = 0;
+        switch (level) {
+        case 1:
+            speed = 0.3;
+            break;
+        case 2:
+            speed = 1.6;
+            break;
+        case 3:
+            speed = 3.4;
+            break;
+        case 4:
+            speed = 5.5;
+            break;
+        case 5:
+            speed = 8.0;
+            break;
+        case 6:
+            speed = 10.8;
+            break;
+        case 7:
+            speed = 13.9;
+            break;
+        case 8:
+            speed = 17.2;
+            break;
+        case 9:
+            speed = 20.8;
+            break;
+        case 10:
+            speed = 24.5;
+            break;
+        case 11:
+            speed = 28.5;
+            break;
+        case 12:
+            speed = 32.7;
+            break;
+
+        }
+
+    }
+    else if (level == 13) {
+        speed = 35.8;
+    }
+    else if (level == 14) {
+        speed = 41.5;
+    }
+    else if (level == 15) {
+        speed = 48.2;
+    }
+    else {
+        cout << "无效的风力等级！" << endl;
+    }
+    return speed;
+}

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;
+}

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; // 第二个物体在图像中所占像素面积
+};

src/林火预测/wind_direction.h

@@ -0,0 +1,38 @@
+#include <iostream>
+using namespace std;
+
+int windToDirection(int type)
+{
+	int direction = 0;
+
+    // 根据类型获取风向
+    switch (type) {
+    case 1: // 北风
+        direction = 0;
+        break;
+    case 2: // 东北风
+        direction = 45;
+        break;
+    case 3: // 东风
+        direction = 90;
+        break;
+    case 4: // 东南风
+        direction = 135;
+        break;
+    case 5: // 南风
+        direction = 180;
+        break;
+    case 6: //西南风
+        direction = 225;
+        break;
+    case 7: //西风
+        direction = 270;
+        break;
+    case 8: //西北风
+        direction = 315;
+    default:
+        cout << "植被类型输入错误！" << endl;
+        return -1;
+    }
+    return direction;
+}

src/林火预测/风速补正综合指标法/ForestPolice.cpp

@@ -0,0 +1,141 @@
+#include <math.h>
+#include <iostream>
+#include "levelToSpeed.h"
+
+using namespace std;
+#define M_PI acos(-1)
+
+
+class ForestFirePrediction {
+public:
+    // 构造函数
+    ForestFirePrediction(int wind_direction, double wind_level, double slope, double altitude, int cover_type, double fire_size) {
+        this->wind_direction = wind_direction;
+        this->wind_level = wind_level;
+        this->slope = slope;
+        this->altitude = altitude;
+        this->cover_type = cover_type;
+        this->fire_size = fire_size;
+    }
+
+    // 计算受阻距离（单位：km）
+    double get_distance() {
+        double rad_slope = slope * M_PI / 180.0; // 将坡度转化为弧度
+        double distance = sin(rad_slope) * altitude / 1000.0; // 计算受阻距离
+        return distance;
+    }
+
+    // 预测火灾蔓延范围
+    void predict_range() {
+        double impact_factor;   // 植被类型影响系数
+        double correction_coef; // 风速补正系数
+        double distance;        // 受阻距离
+        double composite_index; // 综合指数
+
+        // 根据植被类型获取影响系数
+        switch (cover_type) {
+        case 1: // 针叶林
+            impact_factor = 0.7;
+            break;
+        case 2: // 落叶林
+            impact_factor = 0.5;
+            break;
+        case 3: // 灌木林
+            impact_factor = 0.4;
+            break;
+        default:
+            cout << "植被类型输入错误！" << endl;
+            return;
+        }
+
+        // 计算风速补正系数
+        int angle = abs(wind_direction - 180); // 计算风向与火灾扩散方向之间的夹角
+        if (angle <= 45 || angle >= 315) {     // 如果夹角较小，则不需要进行风速补正
+            correction_coef = 1;
+        }
+        else {
+            correction_coef = 0.65 + 0.35 * cos((angle - 45) * M_PI / 270.0); // 使用公式计算风速补正系数
+        }
+
+        // 计算受阻距离
+        distance = get_distance();
+
+        // 计算综合指数
+        composite_index = correction_coef * (1 + distance) * impact_factor;
+
+        // 计算火灾蔓延半径
+        double radius = sqrt(fire_size * 1000000 * composite_index) / M_PI;
+        double range = radius * pow(10, 1.5 * levelToSpeed(wind_level) / 30.0);
+
+        // 输出预测结果
+        cout << "火灾蔓延范围预测结果：" << endl;
+        cout << "火源最可能在" << radius << "米范围内发生。" << endl;
+        cout << "在风速为 " << wind_level << "级风的情况下，火源最可能的蔓延范围为 " << range << " 米。" << endl;
+    }
+
+    // 预测火灾蔓延速度
+    void predict_speed(int level) {
+        double slope_factor; // 坡度影响因子
+        double speed_factor; // 风速影响因子
+        double size_factor;  // 火源面积影响因子
+
+        // 计算坡度影响因子
+        if (slope > 0) {
+            slope_factor = pow(3.33, sqrt(slope));
+        }
+        else {
+            slope_factor = 1;
+        }
+
+        // 计算风速影响因子
+        double wind_speed = levelToSpeed(wind_level);
+        speed_factor = 5.15 * pow(wind_speed, 0.39);
+
+        // 计算火源面积影响因子
+        size_factor = pow(fire_size, 0.77);
+
+        // 计算火灾蔓延速度
+        double speed = 0.348 * sqrt(size_factor * slope_factor * speed_factor);
+
+        // 输出预测结果
+        cout << "火灾蔓延速度预测结果：" << endl;
+        cout << "火灾蔓延速度可能为" << speed << "km/h。" << endl;
+    }
+
+private:
+    int wind_direction; // 风向（单位：度）
+    double wind_level;  // 风力等级
+    double slope;       // 坡度（单位：度）
+    double altitude;    // 海拔高度（单位：m）
+    int cover_type;     // 植被类型（1：针叶林；2：落叶林；3：灌木林）
+    double fire_size;   // 火源面积（单位：平方米）
+};
+
+int main() {
+    // 读取参数
+    int wind_direction;
+    int wind_level;
+    double slope;
+    double altitude;
+    int cover_type;
+    double fire_size;
+    cout << "请输入风向（0-360度）：" << endl;
+    cin >> wind_direction;
+    cout << "请输入风力等级（级）：" << endl;
+    cin >> wind_level;
+    cout << "请输入坡度（度）：" << endl;
+    cin >> slope;
+    cout << "请输入海拔高度（m）：" << endl;
+    cin >> altitude;
+    cout << "请输入植被类型（1：针叶林；2：落叶林；3：灌木林）：" << endl;
+    cin >> cover_type;
+    cout << "请输入火源面积（m^2）：" << endl;
+    cin >> fire_size;
+
+    // 预测火灾蔓延范围和速度
+    ForestFirePrediction ffp(wind_direction, wind_level, slope, altitude, cover_type, fire_size);
+    ffp.predict_range();
+    ffp.predict_speed(wind_level);
+
+    return 0;
+}

src/林火预测/风速补正综合指标法/levelToSpeed.h

@@ -0,0 +1,62 @@
+#include<iostream>
+using namespace std;
+
+double levelToSpeed(int level) {
+    double speed = 0;
+    if (level >= 0 && level <= 12) {
+        double speed = 0;
+        switch (level) {
+        case 1:
+            speed = 0.3;
+            break;
+        case 2:
+            speed = 1.6;
+            break;
+        case 3:
+            speed = 3.4;
+            break;
+        case 4:
+            speed = 5.5;
+            break;
+        case 5:
+            speed = 8.0;
+            break;
+        case 6:
+            speed = 10.8;
+            break;
+        case 7:
+            speed = 13.9;
+            break;
+        case 8:
+            speed = 17.2;
+            break;
+        case 9:
+            speed = 20.8;
+            break;
+        case 10:
+            speed = 24.5;
+            break;
+        case 11:
+            speed = 28.5;
+            break;
+        case 12:
+            speed = 32.7;
+            break;
+
+        }
+        
+    }
+    else if (level == 13) {
+        speed = 35.8;
+    }
+    else if (level == 14) {
+        speed = 41.5;
+    }
+    else if (level == 15) {
+        speed = 48.2;
+    }
+    else {
+        cout << "ÎÞЧµÄ·çÁ¦µÈ¼¶£¡" << endl;
+    }
+    return speed;
+}

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;
+}

src/登录页面—vue/Login.vue

@@ -0,0 +1,111 @@
+<template>
+    <div class="loginBody">
+        <div class="loginDiv">
+            <div class="login-content">
+                <h1 class="login-title">用户登录</h1>
+                <el-form :model="loginForm" label-width="100px"
+                         :rules="rules" ref="loginForm">
+                    <el-form-item label="账号" prop="no">
+                        <el-input style="width: 200px" type="text" v-model="loginForm.no"
+                                  autocomplete="off" size="small"></el-input>
+                    </el-form-item>
+                    <el-form-item label="密码" prop="password">
+                        <el-input style="width: 200px" type="password" v-model="loginForm.password"
+                                  show-password autocomplete="off" size="small" @keyup.enter.native="confirm"></el-input>
+                    </el-form-item>
+                    <el-form-item>
+                        <el-button type="primary" @click="confirm" :disabled="confirm_disabled">确 定</el-button>
+                    </el-form-item>
+                </el-form>
+            </div>
+        </div>
+    </div>
+</template>
+
+
+<script>
+    export default {
+        name: "Login",
+        data(){
+            return{
+                confirm_disabled:false,
+                loginForm:{
+                    no:'',
+                    password:''
+                },
+                rules:{
+                    no: [
+                        { required: true, message: '请输入账号', trigger: 'blur' }
+                    ],
+                    password: [
+                        { required: true, message: '请输密码', trigger: 'blur' }
+                    ],
+                }
+            }
+        },
+        methods:{
+
+            confirm(){
+                this.confirm_disabled=true;
+                this.$refs.loginForm.validate((valid) => {
+                    if (valid) { //valid成功为true，失败为false
+                        //去后台验证用户名密码。依赖于 Axios 库，需要在组件中引入并初始化 Axios 才能正常工作
+                        this.$axios.post(this.$httpUrl+'/user/login',this.loginForm).then(res=>res.data).then(res=>{
+                            console.log(res)
+                            if(res.code==200){
+                                //存储：使用 sessionStorage 存储当前用户信息
+                                sessionStorage.setItem("CurUser",JSON.stringify(res.data.user))
+
+                                console.log(res.data.menu)
+                                this.$store.commit("setMenu",res.data.menu)
+                                //跳转到主页
+                                this.$router.replace('/Index');
+                            }else{
+                                this.confirm_disabled=false;
+                                alert('校验失败，用户名或密码错误！');
+                                return false;
+                            }
+                        });
+                    } else {
+                        this.confirm_disabled=false;
+                        console.log('校验失败');
+                        return false;
+                    }
+                });
+
+            }
+        }
+    }
+</script>
+
+<style scoped>
+    .loginBody {
+        position: absolute;
+        width: 100%;
+        height: 100%;
+        background-color: #B3C0D1;
+    }
+    .loginDiv {
+        position: absolute;
+        top: 50%;
+        left: 50%;
+        margin-top: -200px;
+        margin-left: -250px;
+        width: 450px;
+        height: 330px;
+        background: #fff;
+        border-radius: 5%;
+
+    }
+    .login-title {
+        margin: 20px 0;
+        text-align: center;
+    }
+    .login-content {
+        width: 400px;
+        height: 250px;
+        position: absolute;
+        top: 25px;
+        left: 25px;
+    }
+</style>

src/细节功能/Alarm.cpp

@@ -0,0 +1,23 @@
+#include "Alarm.h"
+#include <iostream>
+#include <string>
+
+using namespace std;
+
+int main() {
+    AlarmSystem alarm; // 创建警报系统对象
+
+    alarm.arm(); // 启动警报系统
+
+    // 模拟接收到信息并触发警报
+    string message = "温度异常";
+    alarm.receiveMessage(message);
+
+    alarm.disarm(); // 关闭警报系统
+
+    // 再次模拟接收到信息，但由于警报系统已关闭，不会触发警报
+    string message2 = "火灾警报";
+    alarm.receiveMessage(message2);
+
+    return 0;
+}

src/细节功能/Alarm.h

@@ -0,0 +1,46 @@
+#include <iostream>
+#include <string>
+
+using namespace std;
+
+class AlarmSystem {
+public:
+    // 构造函数，初始化警报系统
+    AlarmSystem() {
+        isArmed = false;
+        alarmMessage = "警报！有异常情况发生！";
+    }
+
+    // 启动警报系统
+    void arm() {
+        isArmed = true;
+        cout << "警报系统已启动" << endl;
+    }
+
+    // 关闭警报系统
+    void disarm() {
+        isArmed = false;
+        cout << "警报系统已关闭" << endl;
+    }
+
+    // 接收信息并触发警报
+    void receiveMessage(const string& message) {
+        if (isArmed) {
+            cout << "接收到信息：" << message << endl;
+            triggerAlarm();
+        }
+        else {
+            cout << "未启动警报系统，忽略信息：" << message << endl;
+        }
+    }
+
+private:
+    bool isArmed; // 警报系统是否启动
+    string alarmMessage; // 警报信息
+
+    // 触发警报
+    void triggerAlarm() {
+        cout << "发出警报：" << alarmMessage << endl;
+        // 这里可以实现具体的警报动作，例如触发声音、发送通知等
+    }
+};

src/细节功能/Distance.cpp

@@ -0,0 +1,19 @@
+#include "Distance.h"
+#include <iostream>
+
+using namespace std;
+
+int main() {
+    // 传入相机的基线长度和树木在两个视角下的像素位移
+    TreeDistanceEstimator treeEstimator(0.1, 30);
+
+    // 设置相机的焦距
+    treeEstimator.setFocalLength(100);
+
+    // 估测树木的距离
+    double distance = treeEstimator.estimateDistance();
+
+    cout << "估测的树木距离：" << distance << " 米" << endl;
+
+    return 0;
+}

src/细节功能/Distance.h

@@ -0,0 +1,19 @@
+class TreeDistanceEstimator {
+public:
+    // 构造函数，传入相机的基线长度和树木在两个视角下的像素位移
+    TreeDistanceEstimator(double baseline, double pixel_displacement) {
+        this->baseline = baseline;
+        this->pixel_displacement = pixel_displacement;
+    }
+
+    // 估测树木的距离
+    double estimateDistance() {
+        double distance = (baseline * focal_length) / pixel_displacement;
+        return distance; // 返回估测的距离
+    }
+
+private:
+    double baseline; // 相机的基线长度
+    double pixel_displacement; // 树木在两个视角下的像素位移
+    double focal_length; // 相机焦距
+};

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;
+}

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; // 第二个物体在图像中所占像素面积
+};