p5akopqw4
/
senjing
1
0
Fork 0
Code Issues Pull Requests 2 Projects Releases Wiki Activity

recoverty

Browse Source
songhaibo_branch
博 1 year ago
parent 9aeddde25c
commit 5c56d971cf
17 changed files with 0 additions and 997 deletions
Show Stats Download Patch File Download Diff File

152
src/林火预测/FP.cpp
Unescape View File

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

30
src/林火预测/Ks_correction.h
Unescape View File

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

49
src/林火预测/levelToSlope.h
Unescape View File

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

62
src/林火预测/levelToSpeed.h
Unescape View File

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

19
src/林火预测/pixel.cpp
Unescape View File

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

29
src/林火预测/pixel.h
Unescape View File

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

38
src/林火预测/wind_direction.h
Unescape View File

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

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

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

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

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

149
src/林火预测/风速补正综合指标法/model.cpp
Unescape View File

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

111
src/登录页面—vue/Login.vue
Unescape View File

@ -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>

23
src/细节功能/Alarm.cpp
Unescape View File

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

46
src/细节功能/Alarm.h
Unescape View File

@ -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;
// 这里可以实现具体的警报动作，例如触发声音、发送通知等
}
};

19
src/细节功能/Distance.cpp
Unescape View File

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

19
src/细节功能/Distance.h
Unescape View File

@ -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; // 相机焦距
};

19
src/细节功能/pixel.cpp
Unescape View File

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

29
src/细节功能/pixel.h
Unescape View File

@ -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; // 第二个物体在图像中所占像素面积
};
Write Preview
Loading…
Cancel
Save