recoverty

src/林火预测/FP.cpp

@@ -1,152 +0,0 @@
-#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

@@ -1,30 +0,0 @@
-#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

@@ -1,49 +0,0 @@
-#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

@@ -1,62 +0,0 @@
-#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

@@ -1,19 +0,0 @@
-#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

@@ -1,29 +0,0 @@
-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

@@ -1,38 +0,0 @@
-#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

@@ -1,141 +0,0 @@
-#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

@@ -1,62 +0,0 @@
-#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

@@ -1,149 +0,0 @@
-#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

@@ -1,111 +0,0 @@
-<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

@@ -1,23 +0,0 @@
-#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

@@ -1,46 +0,0 @@
-#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

@@ -1,19 +0,0 @@
-#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

@@ -1,19 +0,0 @@
-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

@@ -1,19 +0,0 @@
-#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

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