VSAG/amadeus_26_fb
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

修订拼写错误，增加独立config。

Browse Source
This commit is contained in:
xinyang
2019-07-13 13:57:26 +08:00
parent 95eb65e6f0
commit a8d24f412e
11 changed files with 184 additions and 165 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@@ -5,4 +5,5 @@ Mark
armor_box_photo armor_box_photo
tools/TrainCNN/.idea tools/TrainCNN/.idea
tools/TrainCNN/__pycache__ tools/TrainCNN/__pycache__
others/include/config/config.h
.DS_Store .DS_Store

8
CMakeLists.txt
View File

@@ -8,6 +8,14 @@ SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DPATH=\"\\\"${PROJECT_SOURCE_DIR}\\\"\"
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D${CMAKE_SYSTEM_NAME}") SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D${CMAKE_SYSTEM_NAME}")
SET(BIN_NAME "run") SET(BIN_NAME "run")
FIND_FILE(CONFIG_FOUND "config.h" "others/include/config")
if (CONFIG_FOUND)
MESSAGE("Found config.h")
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DWITH_CONFIG")
endif()
FIND_PROGRAM(CCACHE_FOUND ccache) FIND_PROGRAM(CCACHE_FOUND ccache)
IF(CCACHE_FOUND) IF(CCACHE_FOUND)
SET_PROPERTY(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache) SET_PROPERTY(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache)

10
energy/include/energy/energy.h
View File

@@ -27,9 +27,9 @@ public:
Energy(Serial &u, uint8_t &color);//构造函数，参数为串口和敌方颜色 Energy(Serial &u, uint8_t &color);//构造函数，参数为串口和敌方颜色
~Energy();//默认析构函数 ~Energy();//默认析构函数
void run(cv::Mat &gimble_src, cv::Mat &chassis_src); void run(cv::Mat &gimbal_src, cv::Mat &chassis_src);
void run(cv::Mat &gimble_src); void run(cv::Mat &gimbal_src);
Serial &serial;//串口 Serial &serial;//串口
void setEnergyInit();//设置能量机关初始化 void setEnergyInit();//设置能量机关初始化
@@ -40,13 +40,13 @@ public:
private: private:
EnergyPartParam energy_part_param_;//能量机关的参数设置 EnergyPartParam energy_part_param_;//能量机关的参数设置
EnergyPartParam gimble_energy_part_param_;//云台摄像头能量机关的参数设置 EnergyPartParam gimbal_energy_part_param_;//云台摄像头能量机关的参数设置
EnergyPartParam chassis_energy_part_param_;//底盘摄像头能量机关的参数设置 EnergyPartParam chassis_energy_part_param_;//底盘摄像头能量机关的参数设置
bool isMark;//若操作手正在手动标定，则为true bool isMark;//若操作手正在手动标定，则为true
bool isBig;//大符模式为true bool isBig;//大符模式为true
bool isSmall;//小符模式为true bool isSmall;//小符模式为true
bool isGimble;//同时具有底盘和云台摄像头时，处于云台摄像头对心过程 bool isgimbal;//同时具有底盘和云台摄像头时，处于云台摄像头对心过程
bool isChassis;//同时具有底盘和云台摄像头时，处于底盘摄像头击打过程 bool isChassis;//同时具有底盘和云台摄像头时，处于底盘摄像头击打过程
bool isGuessing;//当前处于发弹到新目标出现的过程，则为true，此时猜测下一个目标 bool isGuessing;//当前处于发弹到新目标出现的过程，则为true，此时猜测下一个目标
bool isPredicting;//当前处于新目标出现到发弹的过程，则为true，此时正常击打 bool isPredicting;//当前处于新目标出现到发弹的过程，则为true，此时正常击打
@@ -154,7 +154,7 @@ private:
void getPredictPoint(cv::Point target_point);//获取预测点位 void getPredictPoint(cv::Point target_point);//获取预测点位
void getAimPoint(cv::Point target_point);//通过自瞄逻辑计算点位 void getAimPoint(cv::Point target_point);//通过自瞄逻辑计算点位
void changeMark();//操作手手动修改标定值 void changeMark();//操作手手动修改标定值
void gimbleRotation();//计算云台旋转角度 void gimbalRotation();//计算云台旋转角度
void getAllTargetArmorCenters();//记录所有目标装甲板中心坐标 void getAllTargetArmorCenters();//记录所有目标装甲板中心坐标
void getRecentTargetArmorCenters();//记录近30帧目标装甲板中心坐标 void getRecentTargetArmorCenters();//记录近30帧目标装甲板中心坐标

2
energy/src/energy/change/mode_change.cpp
View File

@@ -14,7 +14,7 @@ using namespace cv;
// --------------------------------------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------------------------------------
void Energy::startChassis(){ void Energy::startChassis(){
isChassis = true; isChassis = true;
isGimble = false; isgimbal = false;
} }

8
energy/src/energy/energy.cpp
View File

@@ -22,7 +22,7 @@ Energy::Energy(Serial &u, uint8_t &color) : serial(u), ally_color(color),
energy_rotation_init = false; energy_rotation_init = false;
isBig = false; isBig = false;
isSmall = false; isSmall = false;
isGimble = true; isgimbal = true;
isChassis = false; isChassis = false;
} }
@@ -44,7 +44,7 @@ void Energy::setEnergyInit() {
energy_rotation_init = true; energy_rotation_init = true;
isBig = false; isBig = false;
isSmall = false; isSmall = false;
isGimble = true; isgimbal = true;
isChassis = false; isChassis = false;
} }
@@ -60,7 +60,7 @@ void Energy::setBigEnergyInit() {
energy_rotation_init = true; energy_rotation_init = true;
isBig = true; isBig = true;
isSmall = false; isSmall = false;
isGimble = true; isgimbal = true;
isChassis = false; isChassis = false;
} }
@@ -73,6 +73,6 @@ void Energy::setSmallEnergyInit() {
isBig = false; isBig = false;
isSmall = true; isSmall = true;
isGimble = true; isgimbal = true;
isChassis = false; isChassis = false;
} }

2
energy/src/energy/get/gimble_rotation_get.cpp
View File

@@ -38,7 +38,7 @@ void Energy::changeMark() {
//---------------------------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
// 此函数用于计算云台应当转到的角度 // 此函数用于计算云台应当转到的角度
// --------------------------------------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------------------------------------
void Energy::gimbleRotation() { void Energy::gimbalRotation() {
cv::Point2f real_predict_point;//计算在真实世界中的预测点位，进而计算云台的旋转角度 cv::Point2f real_predict_point;//计算在真实世界中的预测点位，进而计算云台的旋转角度
stretch(predict_point, real_predict_point); stretch(predict_point, real_predict_point);
yaw_rotation = static_cast<float>(180 / PI * yaw_rotation = static_cast<float>(180 / PI *

112
energy/src/energy/init/energy_init.cpp
View File

@@ -60,68 +60,68 @@ void Energy::initEnergy() {
// 此函数对能量机关参数进行初始化 // 此函数对能量机关参数进行初始化
// --------------------------------------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------------------------------------
void Energy::initEnergyPartParam() { void Energy::initEnergyPartParam() {
gimble_energy_part_param_.GRAY_THRESH = 160; gimbal_energy_part_param_.GRAY_THRESH = 160;
gimble_energy_part_param_.SPLIT_GRAY_THRESH = 180; gimbal_energy_part_param_.SPLIT_GRAY_THRESH = 180;
gimble_energy_part_param_.FAN_GRAY_THRESH = 75; gimbal_energy_part_param_.FAN_GRAY_THRESH = 75;
gimble_energy_part_param_.ARMOR_GRAY_THRESH = 80; gimbal_energy_part_param_.ARMOR_GRAY_THRESH = 80;
gimble_energy_part_param_.FAN_CONTOUR_AREA_MAX = 6600; gimbal_energy_part_param_.FAN_CONTOUR_AREA_MAX = 6600;
gimble_energy_part_param_.FAN_CONTOUR_AREA_MIN = 0; gimbal_energy_part_param_.FAN_CONTOUR_AREA_MIN = 0;
gimble_energy_part_param_.FAN_CONTOUR_LENGTH_MIN = 56; gimbal_energy_part_param_.FAN_CONTOUR_LENGTH_MIN = 56;
gimble_energy_part_param_.FAN_CONTOUR_LENGTH_MAX = 88; gimbal_energy_part_param_.FAN_CONTOUR_LENGTH_MAX = 88;
gimble_energy_part_param_.FAN_CONTOUR_WIDTH_MIN = 21; gimbal_energy_part_param_.FAN_CONTOUR_WIDTH_MIN = 21;
gimble_energy_part_param_.FAN_CONTOUR_WIDTH_MAX = 40; gimbal_energy_part_param_.FAN_CONTOUR_WIDTH_MAX = 40;
gimble_energy_part_param_.FAN_CONTOUR_HW_RATIO_MAX = 4; gimbal_energy_part_param_.FAN_CONTOUR_HW_RATIO_MAX = 4;
gimble_energy_part_param_.FAN_CONTOUR_HW_RATIO_MIN = 1; gimbal_energy_part_param_.FAN_CONTOUR_HW_RATIO_MIN = 1;
gimble_energy_part_param_.FAN_NON_ZERO_RATE_MAX = 0.8; gimbal_energy_part_param_.FAN_NON_ZERO_RATE_MAX = 0.8;
gimble_energy_part_param_.FAN_NON_ZERO_RATE_MIN = 0.48; gimbal_energy_part_param_.FAN_NON_ZERO_RATE_MIN = 0.48;
gimble_energy_part_param_.ARMOR_CONTOUR_AREA_MAX = 100000; gimbal_energy_part_param_.ARMOR_CONTOUR_AREA_MAX = 100000;
gimble_energy_part_param_.ARMOR_CONTOUR_AREA_MIN = 0; gimbal_energy_part_param_.ARMOR_CONTOUR_AREA_MIN = 0;
gimble_energy_part_param_.ARMOR_CONTOUR_LENGTH_MIN = 18; gimbal_energy_part_param_.ARMOR_CONTOUR_LENGTH_MIN = 18;
gimble_energy_part_param_.ARMOR_CONTOUR_LENGTH_MAX = 32; gimbal_energy_part_param_.ARMOR_CONTOUR_LENGTH_MAX = 32;
gimble_energy_part_param_.ARMOR_CONTOUR_WIDTH_MIN = 10; gimbal_energy_part_param_.ARMOR_CONTOUR_WIDTH_MIN = 10;
gimble_energy_part_param_.ARMOR_CONTOUR_WIDTH_MAX = 30; gimbal_energy_part_param_.ARMOR_CONTOUR_WIDTH_MAX = 30;
gimble_energy_part_param_.ARMOR_CONTOUR_HW_RATIO_MAX = 3; gimbal_energy_part_param_.ARMOR_CONTOUR_HW_RATIO_MAX = 3;
gimble_energy_part_param_.ARMOR_CONTOUR_HW_RATIO_MIN = 1; gimbal_energy_part_param_.ARMOR_CONTOUR_HW_RATIO_MIN = 1;
gimble_energy_part_param_.CENTER_R_CONTOUR_AREA_MAX = 100000; gimbal_energy_part_param_.CENTER_R_CONTOUR_AREA_MAX = 100000;
gimble_energy_part_param_.CENTER_R_CONTOUR_AREA_MIN = 0; gimbal_energy_part_param_.CENTER_R_CONTOUR_AREA_MIN = 0;
gimble_energy_part_param_.CENTER_R_CONTOUR_LENGTH_MIN = 7; gimbal_energy_part_param_.CENTER_R_CONTOUR_LENGTH_MIN = 7;
gimble_energy_part_param_.CENTER_R_CONTOUR_LENGTH_MAX = 19; gimbal_energy_part_param_.CENTER_R_CONTOUR_LENGTH_MAX = 19;
gimble_energy_part_param_.CENTER_R_CONTOUR_WIDTH_MIN = 7; gimbal_energy_part_param_.CENTER_R_CONTOUR_WIDTH_MIN = 7;
gimble_energy_part_param_.CENTER_R_CONTOUR_WIDTH_MAX = 19; gimbal_energy_part_param_.CENTER_R_CONTOUR_WIDTH_MAX = 19;
gimble_energy_part_param_.CENTER_R_CONTOUR_HW_RATIO_MAX = 3; gimbal_energy_part_param_.CENTER_R_CONTOUR_HW_RATIO_MAX = 3;
gimble_energy_part_param_.CENTER_R_CONTOUR_HW_RATIO_MIN = 1; gimbal_energy_part_param_.CENTER_R_CONTOUR_HW_RATIO_MIN = 1;
gimble_energy_part_param_.CENTER_R_CONTOUR_AREA_RATIO_MIN = 0.7; gimbal_energy_part_param_.CENTER_R_CONTOUR_AREA_RATIO_MIN = 0.7;
gimble_energy_part_param_.CENTER_R_CONTOUR_INTERSETION_AREA_MIN = 10; gimbal_energy_part_param_.CENTER_R_CONTOUR_INTERSETION_AREA_MIN = 10;
gimble_energy_part_param_.FLOW_STRIP_FAN_CONTOUR_AREA_MAX = 17000; gimbal_energy_part_param_.FLOW_STRIP_FAN_CONTOUR_AREA_MAX = 17000;
gimble_energy_part_param_.FLOW_STRIP_FAN_CONTOUR_AREA_MIN = 0; gimbal_energy_part_param_.FLOW_STRIP_FAN_CONTOUR_AREA_MIN = 0;
gimble_energy_part_param_.FLOW_STRIP_FAN_CONTOUR_LENGTH_MIN = 56; gimbal_energy_part_param_.FLOW_STRIP_FAN_CONTOUR_LENGTH_MIN = 56;
gimble_energy_part_param_.FLOW_STRIP_FAN_CONTOUR_LENGTH_MAX = 88; gimbal_energy_part_param_.FLOW_STRIP_FAN_CONTOUR_LENGTH_MAX = 88;
gimble_energy_part_param_.FLOW_STRIP_FAN_CONTOUR_WIDTH_MIN = 21; gimbal_energy_part_param_.FLOW_STRIP_FAN_CONTOUR_WIDTH_MIN = 21;
gimble_energy_part_param_.FLOW_STRIP_FAN_CONTOUR_WIDTH_MAX = 40; gimbal_energy_part_param_.FLOW_STRIP_FAN_CONTOUR_WIDTH_MAX = 40;
gimble_energy_part_param_.FLOW_STRIP_FAN_CONTOUR_HW_RATIO_MAX = 3; gimbal_energy_part_param_.FLOW_STRIP_FAN_CONTOUR_HW_RATIO_MAX = 3;
gimble_energy_part_param_.FLOW_STRIP_FAN_CONTOUR_HW_RATIO_MIN = 1; gimbal_energy_part_param_.FLOW_STRIP_FAN_CONTOUR_HW_RATIO_MIN = 1;
gimble_energy_part_param_.FLOW_STRIP_FAN_CONTOUR_AREA_RATIO_MAX = 0.55; gimbal_energy_part_param_.FLOW_STRIP_FAN_CONTOUR_AREA_RATIO_MAX = 0.55;
gimble_energy_part_param_.FLOW_STRIP_FAN_CONTOUR_AREA_RATIO_MIN = 0.25; gimbal_energy_part_param_.FLOW_STRIP_FAN_CONTOUR_AREA_RATIO_MIN = 0.25;
gimble_energy_part_param_.FLOW_STRIP_FAN_NON_ZERO_RATE_MAX = 0.48; gimbal_energy_part_param_.FLOW_STRIP_FAN_NON_ZERO_RATE_MAX = 0.48;
gimble_energy_part_param_.FLOW_STRIP_FAN_NON_ZERO_RATE_MIN = 0.25; gimbal_energy_part_param_.FLOW_STRIP_FAN_NON_ZERO_RATE_MIN = 0.25;
gimble_energy_part_param_.FLOW_STRIP_CONTOUR_AREA_MAX = 100000; gimbal_energy_part_param_.FLOW_STRIP_CONTOUR_AREA_MAX = 100000;
gimble_energy_part_param_.FLOW_STRIP_CONTOUR_AREA_MIN = 0; gimbal_energy_part_param_.FLOW_STRIP_CONTOUR_AREA_MIN = 0;
gimble_energy_part_param_.FLOW_STRIP_CONTOUR_LENGTH_MIN = 31; gimbal_energy_part_param_.FLOW_STRIP_CONTOUR_LENGTH_MIN = 31;
gimble_energy_part_param_.FLOW_STRIP_CONTOUR_LENGTH_MAX = 57; gimbal_energy_part_param_.FLOW_STRIP_CONTOUR_LENGTH_MAX = 57;
gimble_energy_part_param_.FLOW_STRIP_CONTOUR_WIDTH_MIN = 2; gimbal_energy_part_param_.FLOW_STRIP_CONTOUR_WIDTH_MIN = 2;
gimble_energy_part_param_.FLOW_STRIP_CONTOUR_WIDTH_MAX = 13; gimbal_energy_part_param_.FLOW_STRIP_CONTOUR_WIDTH_MAX = 13;
gimble_energy_part_param_.FLOW_STRIP_CONTOUR_HW_RATIO_MAX = 12; gimbal_energy_part_param_.FLOW_STRIP_CONTOUR_HW_RATIO_MAX = 12;
gimble_energy_part_param_.FLOW_STRIP_CONTOUR_HW_RATIO_MIN = 4; gimbal_energy_part_param_.FLOW_STRIP_CONTOUR_HW_RATIO_MIN = 4;
gimble_energy_part_param_.FLOW_STRIP_CONTOUR_AREA_RATIO_MIN = 0.5; gimbal_energy_part_param_.FLOW_STRIP_CONTOUR_AREA_RATIO_MIN = 0.5;
gimble_energy_part_param_.FLOW_STRIP_CONTOUR_INTERSETION_AREA_MIN = 117; gimbal_energy_part_param_.FLOW_STRIP_CONTOUR_INTERSETION_AREA_MIN = 117;
gimble_energy_part_param_.TWIN_ANGEL_MAX = 10; gimbal_energy_part_param_.TWIN_ANGEL_MAX = 10;
gimble_energy_part_param_.TARGET_INTERSETION_CONTOUR_AREA_MIN = 24; gimbal_energy_part_param_.TARGET_INTERSETION_CONTOUR_AREA_MIN = 24;

54
energy/src/energy/run.cpp
View File

@@ -12,22 +12,22 @@ using namespace cv;
//---------------------------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
// 此函数为能量机关模式主控制流函数，且步兵需要同时拥有云台摄像头和底盘摄像头 // 此函数为能量机关模式主控制流函数，且步兵需要同时拥有云台摄像头和底盘摄像头
// --------------------------------------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------------------------------------
void Energy::run(cv::Mat &gimble_src, cv::Mat &chassis_src) { void Energy::run(cv::Mat &gimbal_src, cv::Mat &chassis_src) {
if (chassis_src.empty()) if (chassis_src.empty())
run(gimble_src);//仅拥有云台摄像头则调用单摄像头的run函数 run(gimbal_src);//仅拥有云台摄像头则调用单摄像头的run函数
else if (isGimble) { else if (isgimbal) {
energy_part_param_ = gimble_energy_part_param_; energy_part_param_ = gimbal_energy_part_param_;
clearAll(); clearAll();
initImage(gimble_src); initImage(gimbal_src);
if (findArmors(gimble_src) < 1)return; if (findArmors(gimbal_src) < 1)return;
if (!findFlowStripFan(gimble_src))return; if (!findFlowStripFan(gimbal_src))return;
if (!findTargetInFlowStripFan()) return; if (!findTargetInFlowStripFan()) return;
if (!findCenterROI(gimble_src))return; if (!findCenterROI(gimbal_src))return;
if (!findCenterR(gimble_src))return; if (!findCenterR(gimbal_src))return;
if (show_energy)showFlowStripFan("strip", gimble_src); if (show_energy)showFlowStripFan("strip", gimbal_src);
if (show_energy)showCenterR("R", gimble_src); if (show_energy)showCenterR("R", gimbal_src);
if (!getOrigin())return; if (!getOrigin())return;
startChassis(); startChassis();
@@ -59,7 +59,7 @@ void Energy::run(cv::Mat &gimble_src, cv::Mat &chassis_src) {
} }
if (isPredicting) { if (isPredicting) {
getPredictPoint(target_point); getPredictPoint(target_point);
gimbleRotation(); gimbalRotation();
judgeShoot(); judgeShoot();
sendTarget(serial, yaw_rotation, pitch_rotation, shoot); sendTarget(serial, yaw_rotation, pitch_rotation, shoot);
} else if (isGuessing && stayGuessing()) { } else if (isGuessing && stayGuessing()) {
@@ -68,7 +68,7 @@ void Energy::run(cv::Mat &gimble_src, cv::Mat &chassis_src) {
if (!guessTarget()) return; if (!guessTarget()) return;
if (show_energy)showGuessTarget("guess", chassis_src); if (show_energy)showGuessTarget("guess", chassis_src);
getPredictPoint(guess_point); getPredictPoint(guess_point);
gimbleRotation(); gimbalRotation();
sendTarget(serial, yaw_rotation, pitch_rotation, false); sendTarget(serial, yaw_rotation, pitch_rotation, false);
} }
} }
@@ -78,22 +78,22 @@ void Energy::run(cv::Mat &gimble_src, cv::Mat &chassis_src) {
//---------------------------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
// 此函数为能量机关模式主控制流函数，且步兵仅拥有云台摄像头 // 此函数为能量机关模式主控制流函数，且步兵仅拥有云台摄像头
// --------------------------------------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------------------------------------
void Energy::run(cv::Mat &gimble_src) { void Energy::run(cv::Mat &gimbal_src) {
energy_part_param_ = gimble_energy_part_param_; energy_part_param_ = gimbal_energy_part_param_;
clearAll(); clearAll();
initImage(gimble_src); initImage(gimbal_src);
changeMark(); changeMark();
if (isMark)return;//操作手强制手动标定origin_yaw和origin_pitch if (isMark)return;//操作手强制手动标定origin_yaw和origin_pitch
if (show_process)imshow("bin", gimble_src); if (show_process)imshow("bin", gimbal_src);
if (findArmors(gimble_src) < 1)return; if (findArmors(gimbal_src) < 1)return;
if (!findFlowStripFan(gimble_src))return; if (!findFlowStripFan(gimbal_src))return;
if (!findTargetInFlowStripFan()) return; if (!findTargetInFlowStripFan()) return;
if (!findCenterROI(gimble_src))return; if (!findCenterROI(gimbal_src))return;
if (show_energy)showFlowStripFan("strip", gimble_src); if (show_energy)showFlowStripFan("strip", gimbal_src);
if (!findCenterR(gimble_src))return; if (!findCenterR(gimbal_src))return;
if (show_energy)showCenterR("R", gimble_src); if (show_energy)showCenterR("R", gimbal_src);
getTargetPolarAngle(); getTargetPolarAngle();
JudgeMode(); JudgeMode();
if (energy_mode_init)return; if (energy_mode_init)return;
@@ -104,16 +104,16 @@ void Energy::run(cv::Mat &gimble_src) {
} }
if (isPredicting) { if (isPredicting) {
getPredictPoint(target_point); getPredictPoint(target_point);
gimbleRotation(); gimbalRotation();
judgeShoot(); judgeShoot();
sendTarget(serial, yaw_rotation, pitch_rotation, shoot); sendTarget(serial, yaw_rotation, pitch_rotation, shoot);
} else if (isGuessing && stayGuessing()) { } else if (isGuessing && stayGuessing()) {
findFans(gimble_src); findFans(gimbal_src);
if (save_mark)writeDownMark(); if (save_mark)writeDownMark();
guessTarget(); guessTarget();
if (show_energy)showGuessTarget("guess", gimble_src); if (show_energy)showGuessTarget("guess", gimbal_src);
getPredictPoint(guess_point); getPredictPoint(guess_point);
gimbleRotation(); gimbalRotation();
sendTarget(serial, yaw_rotation, pitch_rotation, false); sendTarget(serial, yaw_rotation, pitch_rotation, false);
} }
} }

58
main.cpp
View File

@@ -18,6 +18,7 @@
#include <armor_finder/armor_finder.h> #include <armor_finder/armor_finder.h>
#include <options/options.h> #include <options/options.h>
#include <additions/additions.h> #include <additions/additions.h>
#include <config/setconfig.h>
#define DO_NOT_CNT_TIME #define DO_NOT_CNT_TIME
@@ -35,7 +36,7 @@ mcu_data mcuData = { // 单片机端回传结构体
ENEMY_RED, // 敌方颜色 ENEMY_RED, // 敌方颜色
}; };
WrapperHead *video_gimble = nullptr; // 云台摄像头视频源 WrapperHead *video_gimbal = nullptr; // 云台摄像头视频源
WrapperHead *video_chassis = nullptr; // 底盘摄像头视频源 WrapperHead *video_chassis = nullptr; // 底盘摄像头视频源
Serial serial(115200); // 串口对象 Serial serial(115200); // 串口对象
@@ -60,16 +61,16 @@ int main(int argc, char *argv[]) {
while (true) { while (true) {
// 打开视频源 // 打开视频源
if (from_camera) { if (from_camera) {
video_gimble = new CameraWrapper(0/*, "armor"*/); video_gimbal = new CameraWrapper(0/*, "armor"*/);
video_chassis = new CameraWrapper(1/*, "energy"*/); video_chassis = new CameraWrapper(1/*, "energy"*/);
} else { } else {
video_gimble = new VideoWrapper("/home/sun/项目/energy_video/energy_test.avi"); video_gimbal = new VideoWrapper("/home/sun/项目/energy_video/energy_test.avi");
video_chassis = new VideoWrapper("/home/sun/项目/energy_video/energy_test.avi"); video_chassis = new VideoWrapper("/home/sun/项目/energy_video/energy_test.avi");
} }
if (video_gimble->init()) { if (video_gimbal->init()) {
LOGM("video_gimble source initialization successfully."); LOGM("video_gimbal source initialization successfully.");
} else { } else {
LOGW("video_gimble source unavailable!"); LOGW("video_gimbal source unavailable!");
} }
if (video_chassis->init()) { if (video_chassis->init()) {
LOGM("video_chassis source initialization successfully."); LOGM("video_chassis source initialization successfully.");
@@ -78,10 +79,10 @@ int main(int argc, char *argv[]) {
} }
// 跳过前10帧噪声图像。 // 跳过前10帧噪声图像。
Mat gimble_src, chassis_src; Mat gimbal_src, chassis_src;
for (int i = 0; i < 10; i++) { for (int i = 0; i < 10; i++) {
if (video_gimble) { if (video_gimbal) {
video_gimble->read(gimble_src); video_gimbal->read(gimbal_src);
} }
if (video_chassis) { if (video_chassis) {
video_chassis->read(chassis_src); video_chassis->read(chassis_src);
@@ -93,35 +94,44 @@ int main(int argc, char *argv[]) {
CNT_TIME("Total", { CNT_TIME("Total", {
if (mcuData.state != ARMOR_STATE) {//能量机关模式 if (mcuData.state != ARMOR_STATE) {//能量机关模式
if (last_state == ARMOR_STATE) {//若上一帧是自瞄模式，即刚往完成切换，则需要初始化 if (last_state == ARMOR_STATE) {//若上一帧是自瞄模式，即刚往完成切换，则需要初始化
((CameraWrapper *) video_gimble)->changeBrightness(20); ((CameraWrapper *) video_gimbal)->changeBrightness(ENERGY_CAMERA_GAIN);
energy.setEnergyInit(); energy.setEnergyInit();
checkReconnect(video_chassis->read(chassis_src)); checkReconnect(video_chassis->read(chassis_src));
#ifdef CHASSIS_FLIP_MODE
flip(chassis_src, chassis_src, CHASSIS_FLIP_MODE);
#endif
} }
ok = checkReconnect(video_gimble->read(gimble_src)); ok = checkReconnect(video_gimbal->read(gimbal_src));
if (!from_camera) extract(gimble_src, chassis_src); #ifdef GIMBAL_FLIP_MODE
if (save_video) saveVideos(gimble_src, chassis_src);//保存视频 flip(gimbal_src, gimbal_src, CHASSIS_FLIP_MODE);
if (show_origin) showOrigin(gimble_src, chassis_src);//显示原始图像 #endif
// energy.run(gimble_src, chassis_src); if (!from_camera) extract(gimbal_src, chassis_src);
energy.run(gimble_src); if (save_video) saveVideos(gimbal_src, chassis_src);//保存视频
if (show_origin) showOrigin(gimbal_src, chassis_src);//显示原始图像
// energy.run(gimbal_src, chassis_src);
energy.run(gimbal_src);
last_state = mcuData.state;//更新上一帧状态 last_state = mcuData.state;//更新上一帧状态
} else { // 自瞄模式 } else { // 自瞄模式
if (last_state != ARMOR_STATE) { if (last_state != ARMOR_STATE) {
((CameraWrapper *) video_gimble)->changeBrightness(30); ((CameraWrapper *) video_gimbal)->changeBrightness(ARMOR_CAMERA_GAIN);
} }
last_state = mcuData.state; last_state = mcuData.state;
ok = checkReconnect(video_gimble->read(gimble_src)); ok = checkReconnect(video_gimbal->read(gimbal_src));
if (!from_camera) extract(gimble_src); #ifdef GIMBAL_FLIP_MODE
if (save_video) saveVideos(gimble_src); flip(gimbal_src, gimbal_src, CHASSIS_FLIP_MODE);
if (show_origin) showOrigin(gimble_src); #endif
if (!from_camera) extract(gimbal_src);
if (save_video) saveVideos(gimbal_src);
if (show_origin) showOrigin(gimbal_src);
CNT_TIME("Armor Time", { CNT_TIME("Armor Time", {
armorFinder.run(gimble_src); armorFinder.run(gimbal_src);
}); });
} }
// cv::waitKey(0); // cv::waitKey(0);
}); });
} while (ok); } while (ok);
delete video_gimble; delete video_gimbal;
video_gimble = nullptr; video_gimbal = nullptr;
delete video_chassis; delete video_chassis;
video_chassis = nullptr; video_chassis = nullptr;
cout << "Program fails. Restarting" << endl; cout << "Program fails. Restarting" << endl;

12
others/include/additions/additions.h
View File

@@ -22,11 +22,11 @@ extern mcu_data mcuData;
void uartReceive(Serial *pSerial); void uartReceive(Serial *pSerial);
bool checkReconnect(bool is_camera_0_connect, bool is_camera_1_connect); bool checkReconnect(bool is_camera_0_connect, bool is_camera_1_connect);
bool checkReconnect(bool is_camera_connect); bool checkReconnect(bool is_camera_connect);
void saveVideos(const cv::Mat &gimble_src, const cv::Mat &chassis_src); void saveVideos(const cv::Mat &gimbal_src, const cv::Mat &chassis_src);
void saveVideos(const cv::Mat &gimble_src); void saveVideos(const cv::Mat &gimbal_src);
void showOrigin(const cv::Mat &gimble_src, const cv::Mat &chassis_src); void showOrigin(const cv::Mat &gimbal_src, const cv::Mat &chassis_src);
void showOrigin(const cv::Mat &gimble_src); void showOrigin(const cv::Mat &gimbal_src);
void extract(cv::Mat &gimble_src, cv::Mat &chassis_src); void extract(cv::Mat &gimbal_src, cv::Mat &chassis_src);
void extract(cv::Mat &gimble_src); void extract(cv::Mat &gimbal_src);
#endif /* _ADDITIONS_H_ */ #endif /* _ADDITIONS_H_ */

82
others/src/additions/additions.cpp
View File

@@ -20,7 +20,7 @@
using namespace std; using namespace std;
using namespace cv; using namespace cv;
extern WrapperHead *video_gimble; extern WrapperHead *video_gimbal;
extern WrapperHead *video_chassis; extern WrapperHead *video_chassis;
extern Serial serial; extern Serial serial;
@@ -75,9 +75,9 @@ cv::VideoWriter initVideoWriter(const std::string &filename_prefix) {
bool checkReconnect(bool is_camera_0_connect, bool is_camera_1_connect) { bool checkReconnect(bool is_camera_0_connect, bool is_camera_1_connect) {
if (!is_camera_0_connect) { if (!is_camera_0_connect) {
delete video_gimble; delete video_gimbal;
video_gimble = new CameraWrapper(0, "armor"); video_gimbal = new CameraWrapper(0, "armor");
is_camera_0_connect = video_gimble->init(); is_camera_0_connect = video_gimbal->init();
} }
if (!is_camera_1_connect) { if (!is_camera_1_connect) {
delete video_chassis; delete video_chassis;
@@ -89,79 +89,79 @@ bool checkReconnect(bool is_camera_0_connect, bool is_camera_1_connect) {
bool checkReconnect(bool is_camera_connect) { bool checkReconnect(bool is_camera_connect) {
if (!is_camera_connect) { if (!is_camera_connect) {
delete video_gimble; delete video_gimbal;
video_gimble = new CameraWrapper(0, "armor"); video_gimbal = new CameraWrapper(0, "armor");
is_camera_connect = video_gimble->init(); is_camera_connect = video_gimbal->init();
} }
return is_camera_connect; return is_camera_connect;
} }
auto gimble_video_writer = initVideoWriter(PROJECT_DIR"/gimble_video/"); auto gimbal_video_writer = initVideoWriter(PROJECT_DIR"/gimbal_video/");
auto chassis_video_writer = initVideoWriter(PROJECT_DIR"/chassis_video/"); auto chassis_video_writer = initVideoWriter(PROJECT_DIR"/chassis_video/");
void saveVideos(const cv::Mat &gimble_src, const cv::Mat &chassis_src) { void saveVideos(const cv::Mat &gimbal_src, const cv::Mat &chassis_src) {
if (!gimble_src.empty() && !chassis_src.empty()) { if (!gimbal_src.empty() && !chassis_src.empty()) {
gimble_video_writer.write(gimble_src); gimbal_video_writer.write(gimbal_src);
Mat chassis_save = chassis_src.clone(); Mat chassis_save = chassis_src.clone();
cvtColor(chassis_save, chassis_save, COLOR_GRAY2BGR); cvtColor(chassis_save, chassis_save, COLOR_GRAY2BGR);
chassis_video_writer.write(chassis_save); chassis_video_writer.write(chassis_save);
} else if (!gimble_src.empty() && chassis_src.empty()) { } else if (!gimbal_src.empty() && chassis_src.empty()) {
gimble_video_writer.write(gimble_src); gimbal_video_writer.write(gimbal_src);
} else if (gimble_src.empty() && !chassis_src.empty()) { } else if (gimbal_src.empty() && !chassis_src.empty()) {
if (show_origin)imshow("src", gimble_src); if (show_origin)imshow("src", gimbal_src);
Mat chassis_save = chassis_src.clone(); Mat chassis_save = chassis_src.clone();
cvtColor(chassis_save, chassis_save, COLOR_GRAY2BGR); cvtColor(chassis_save, chassis_save, COLOR_GRAY2BGR);
chassis_video_writer.write(chassis_save); chassis_video_writer.write(chassis_save);
} else return; } else return;
} }
void saveVideos(const cv::Mat &gimble_src) { void saveVideos(const cv::Mat &gimbal_src) {
if (!gimble_src.empty()) { if (!gimbal_src.empty()) {
gimble_video_writer.write(gimble_src); gimbal_video_writer.write(gimbal_src);
} else return; } else return;
} }
void showOrigin(const cv::Mat &gimble_src, const cv::Mat &chassis_src) { void showOrigin(const cv::Mat &gimbal_src, const cv::Mat &chassis_src) {
if (!gimble_src.empty() && !chassis_src.empty()) { if (!gimbal_src.empty() && !chassis_src.empty()) {
imshow("gimble", gimble_src); imshow("gimbal", gimbal_src);
imshow("chassis", chassis_src); imshow("chassis", chassis_src);
} else if (!gimble_src.empty() && chassis_src.empty()) { } else if (!gimbal_src.empty() && chassis_src.empty()) {
imshow("gimble", gimble_src); imshow("gimbal", gimbal_src);
} else if (gimble_src.empty() && !chassis_src.empty()) { } else if (gimbal_src.empty() && !chassis_src.empty()) {
imshow("chassis", chassis_src); imshow("chassis", chassis_src);
} else return; } else return;
cv::waitKey(1); cv::waitKey(1);
} }
void showOrigin(const cv::Mat &gimble_src) { void showOrigin(const cv::Mat &gimbal_src) {
if (!gimble_src.empty()) { if (!gimbal_src.empty()) {
imshow("gimble", gimble_src); imshow("gimbal", gimbal_src);
} else return; } else return;
cv::waitKey(1); cv::waitKey(1);
} }
void extract(cv::Mat &gimble_src, cv::Mat &chassis_src) { void extract(cv::Mat &gimbal_src, cv::Mat &chassis_src) {
if (!gimble_src.empty() && !chassis_src.empty()) { if (!gimbal_src.empty() && !chassis_src.empty()) {
extract(gimble_src); extract(gimbal_src);
extract(chassis_src); extract(chassis_src);
} else if (!gimble_src.empty() && chassis_src.empty()) { } else if (!gimbal_src.empty() && chassis_src.empty()) {
extract(gimble_src); extract(gimbal_src);
} else if (gimble_src.empty() && !chassis_src.empty()) { } else if (gimbal_src.empty() && !chassis_src.empty()) {
extract(chassis_src); extract(chassis_src);
} else return; } else return;
} }
void extract(cv::Mat &gimble_src) {//图像预处理，将视频切成640×480的大小 void extract(cv::Mat &gimbal_src) {//图像预处理，将视频切成640×480的大小
if (gimble_src.empty()) return; if (gimbal_src.empty()) return;
float length = static_cast<float>(gimble_src.cols); float length = static_cast<float>(gimbal_src.cols);
float width = static_cast<float>(gimble_src.rows); float width = static_cast<float>(gimbal_src.rows);
if (length / width > 640.0 / 480.0) { if (length / width > 640.0 / 480.0) {
length *= 480.0 / width; length *= 480.0 / width;
resize(gimble_src, gimble_src, cv::Size(length, 480)); resize(gimbal_src, gimbal_src, cv::Size(length, 480));
gimble_src = gimble_src(Rect((length - 640) / 2, 0, 640, 480)); gimbal_src = gimbal_src(Rect((length - 640) / 2, 0, 640, 480));
} else { } else {
width *= 640.0 / length; width *= 640.0 / length;
resize(gimble_src, gimble_src, cv::Size(640, width)); resize(gimbal_src, gimbal_src, cv::Size(640, width));
gimble_src = gimble_src(Rect(0, (width - 480) / 2, 640, 480)); gimbal_src = gimbal_src(Rect(0, (width - 480) / 2, 640, 480));
} }
} }