项目实战 on kites262

Project SonicCraft Qinling：将 Spleeter 转换为 TFLite

Mon, 30 Sep 2024 22:31:51 +0800

SonicCraft Qinling 需要在端侧完成人声与伴奏的分离。Spleeter 在听感上尚可，但原生 TensorFlow 模型体积偏大，难以直接部署到目标设备，因此将其导出并压缩为 TensorFlow Lite。

实际耗时主要不在最后的 convert 调用，而在 Spleeter 提供的权重往往并非一份可直接转换的 SavedModel。

环境

pip install tensorflow tensorflow-model-optimization

同时安装 Spleeter。转换脚本与 Spleeter 宜置于同一 Python 环境；分处不同环境时，容易在 import 与版本依赖上反复排查。

获取预训练权重

本地没有权重则无法导出。可先执行一次分离，由工具自动下载模型：

spleeter separate -i input_audio_file.wav -p spleeter:2stems -o output

权重通常位于 ~/.spleeter/pretrained_models，具体路径随安装方式略有差异。此处使用 2stems（人声与伴奏）；多轨模型更大，现阶段不必引入。

导出 SavedModel

Spleeter 内部多为 checkpoint 一类格式，而 TFLite Converter 对 SavedModel 支持更好，故先完成一次导出：

import tensorflow as tf
from spleeter.separator import Separator

separator = Separator("spleeter:2stems")
export_dir = "./spleeter_saved_model"

tf.saved_model.save(separator.model, export_dir)

该步骤在不同 Spleeter 版本上表现并不一致：有的版本可直接 save，有的则因签名不完整而失败。导出出错时，宜先核对版本组合，再调整转换参数。

转换为 tflite

import tensorflow as tf

saved_model_dir = "./spleeter_saved_model"
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)

converter.optimizations = [tf.lite.Optimize.DEFAULT]

tflite_model = converter.convert()

with open("spleeter_model.tflite", "wb") as f:
 f.write(tflite_model)

若 convert 失败，常见原因包括：计算图中存在 TFLite 尚不支持的算子、动态 shape，或上一阶段 SavedModel 本身不完整。宜先保证转换成功，再考虑进一步量化。

量化

若 .tflite 体积仍不理想，可启用量化。动态范围量化成本最低，上述 Optimize.DEFAULT 往往已包含类似优化：

converter.optimizations = [tf.lite.Optimize.DEFAULT]

整数量化需要提供校准数据，且输入 shape 须与模型一致：

def representative_dataset():
 for _ in range(num_calibration_steps):
 yield [input_data]

converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.representative_dataset = representative_dataset

分离质量最终仍取决于听感。体积下降而听感明显劣化，则压缩失去意义。

加载与验证

生成文件并不等于可在端侧运行。可先在本机用 Interpreter 做一次推理：

import tensorflow as tf

interpreter = tf.lite.Interpreter(model_path="spleeter_model.tflite")
interpreter.allocate_tensors()

input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()

interpreter.set_tensor(input_details[0]["index"], input_data)
interpreter.invoke()

output_data = interpreter.get_tensor(output_details[0]["index"])

input_data 应沿用训练阶段的预处理。shape 不匹配时，set_tensor 会立即报错，便于定位问题。

后续若接入 OpenHarmony 或约束更严的 runtime，瓶颈更可能出现在算子支持与输入管线，而非重复编写导出脚本。

自建 Hugo 博客与自动构建工具链

Sun, 29 Sep 2024 18:11:02 +0800

引言

之前，我一直在Github Pages上学习和搭建个人网站，它免费而且简单，但在国内访问速度非常慢。

最近偶然有台国内服务器，借此我决定自己搭建一个博客网站，换掉原来的Github Pages，在经历多方搜索和尝试后，我选择了静态网页生成器Hugo。

实现效果

基于Markdown进行写作，通过Git上传到远程仓库，服务器收到更新消息自动更新网站内容。
通过https://example.com访问网站。

先决条件

在开始前，准备好以下云资源:

云服务器，系统环境为Ubuntu，且有公网IP，如11.4.5.14，接下来称为<Your-Server-IP>
- 下文中提到的对外端口80 443 10086端口需要在服务器控制台设置允许外部访问
域名，并可以访问其 DNS 管理控制台，如example.com

要在国内服务器上部署站点，需要进行备案，否则无法通过域名访问；

如果服务器和DNS服务商都在海外，则可以不用备案。

部署流程

前言

在开始之前，先了解一下涉及到的几个工具：

Hugo：一个快速的静态网页生成器，用于将Markdown文件转换为静态网页。
Git：一个分布式版本控制系统，用于管理网站的源代码。
Nginx：一个高性能的HTTP和反向代理服务器，用于部署网站。
Webhook：一个用于监听HTTP请求的工具，用于接收Github的Webhook请求，触发网站更新。
Go：一个开源的编程语言，用于编写Webhook服务。
acme.sh：一个用于申请免费SSL证书的工具。

本文环境：

服务器：Ubuntu 22.04 LTS (阿里云)
本地环境：Windows 11 Pro 24H2
Hugo版本：v0.136.1 extended
Nginx版本：1.24.0
acme.sh版本：3.1.0
Go版本：1.22.2

登录服务器

使用SSH登录到服务器，可以直接使用PowerShell(Windows)，也可以使用PuTTY等工具。

配置SSH密钥

在服务器生成SSH密钥对：

（如果是第一次生成，一路回车默认即可）

# 生成SSH密钥对，-C参数为注释，可填写自己的邮箱
ssh-keygen -t rsa -b 4096 -C "<your_email@mail.com>"

再将服务器公钥(默认~/.ssh/id_rsa.pub)的内容添加到Github的SSH Keys中。

准备Github仓库

在Github上创建一个新的仓库，如my-hugo-site，并将其克隆到服务器。

# 克隆仓库，需要修改为实际仓库地址
git clone git@github.com:<your_username>/my-hugo-site.git

配置Hugo

Hugo提供了多种安装方式，具体可参考官方文档。

此处以v0.136.1为例，通过wget获取Hugo的二进制版本，并解压主程序到/usr/local/bin目录下。

# 下载hugo发布包
wget https://github.com/gohugoio/hugo/releases/download/v0.136.1/hugo_extended_0.136.1_linux-amd64.tar.gz
# 解压hugo发布包
tar -zxvf hugo_extended_0.136.1_linux-amd64.tar.gz
# 移动hugo主程序到/usr/local/bin目录
mv hugo /usr/local/bin
# 清理不需要的文件
rm hugo_extended_0.136.1_linux-amd64.tar.gz LICENSE README.md
# 验证安装
hugo version

进入刚才克隆的仓库目录，初始化Hugo站点，然后创建一个新的文章。

cd my-hugo-site
hugo new site .
hugo new posts/my-first-post.md

查看content/posts/my-first-post.md文件，该文件是一个Markdown文件，开头的+++之间是Front Matter，用于配置文章的元数据。

编辑Front Matter，将draft字段改为false，表示文章已经发布，并在后面编写文章内容，效果如下：

+++
date = '2024-10-18T09:29:58Z'
draft = false
title = 'My First Post'
+++

# Hello World!

This is my first post.

直接在本目录执行hugo命令，将Markdown文件转换为静态网页。

之后my-hugo-site/public目录下会生成一些文件，其中包括index.html文件，这是博客的网站首页。

部署Nginx

安装Nginx，并配置my-hugo-site/public目录为站点根目录。

# 安装Nginx
sudo apt update
sudo apt-get install nginx

编写一个Nginx配置文件/etc/nginx/sites-available/my-hugo-site，示例如下：

# 添加一个server块，用于访问博客网站
server {
 listen 80;
 listen 8080;
 server_name example.com <Your-Server-IP>; # 需要修改为实际域名和服务器IP

 location / {
 root /path/to/my-hugo-site/public; # 需要修改为实际网站根目录
 index index.html;
 }
}

启用站点配置文件，并重启Nginx服务。

sudo ln -s /etc/nginx/sites-available/my-hugo-site /etc/nginx/sites-enabled/
sudo systemctl restart nginx

现在访问http://<Your-Server-IP>，应该可以看到博客首页。

配置Webhook

在服务器上配置Webhook，监听Github目标仓库的push事件，触发git pull命令并进行自动构建，这样免去每次在更新仓库后手动在服务器执行构建的步骤。

先编写build.sh脚本，示例如下：

#!/bin/bash

# 日志文件路径，需要修改为实际路径
LOGFILE="/srv/ghpg/log.build.log"

echo "====== Build Started: $(date) ======" >> "$LOGFILE"

# 切换到博客目录，需要修改为实际路径
cd /path/to/my-hugo-site || {
 echo "!!!!! Error: Could not change directory !!!!!" >> "$LOGFILE"
 exit 1
}

echo "Pulling latest changes..." >> "$LOGFILE"
git pull origin main

if [ $? -ne 0 ]; then
 echo "!!!!! Error: Failed to pull latest changes !!!!!" >> "$LOGFILE"
 exit 1
fi

echo "Running Hugo to build site..." >> "$LOGFILE"
/usr/local/bin/hugo --minify

if [ $? -ne 0 ]; then
 echo "!!!!! Error: Hugo build failed !!!!!" >> "$LOGFILE"
 exit 1
fi

echo "✓✓✓✓✓ Build completed: $(date) ✓✓✓✓✓" >> "$LOGFILE"

此处使用go编写一个简单的Webhook服务，监听/webhook路径，接收POST请求。

# 安装go
sudo apt update
sudo apt-get install golang-go

编写webhook.go文件，示例如下：

package main

import (
 "encoding/json"
 "fmt"
 "log"
 "net/http"
 "os/exec"
)

type Payload struct {
 Ref string `json:"ref"`
}

func handleWebhook(w http.ResponseWriter, r *http.Request) {
 // 监听的分支，需要修改为实际分支，默认为main
 var branch string = "refs/heads/main"

 // 构建脚本路径，需要修改为实际路径
 var build_sh = "/path/to/my-hugo-site/build.sh"

 var payload Payload
 json.NewDecoder(r.Body).Decode(&payload)

 if payload.Ref == branch {
 fmt.Fprintln(w, "Webhook received, processing...")

 go func() {
 log.Println("Starting build process...")
 cmd := exec.Command("/bin/bash", build_sh)
 err := cmd.Run()

 if err != nil {
 log.Printf("Build failed: %s\n", err.Error())
 } else {
 log.Println("Build completed successfully")
 }
 }()
 } else {
 fmt.Fprintln(w, "Not "+branch+" branch push, ignoring.")
 }
}

func main() {
 http.HandleFunc("/webhook", handleWebhook)

 // 监听10085端口，需要修改为实际端口
 log.Println("Starting server on :10085")
 http.ListenAndServe(":10085", nil)
}

编译webhook.go文件，生成可执行文件。

go build webhook.go -o webhook.x

将生成的webhook.x文件注册为系统服务，使其在服务器启动时自动运行。

编写/etc/systemd/system/webhook-my-hugo-site.service文件，示例如下：

[Unit]
Description=Webhook Service
After=network.target

[Service]
ExecStart=/path/to/my-hugo-site/webhook.x # 需要修改为实际Webhook.x可执行文件路径
Restart=always
User=root
Environment=GOPATH=/usr/local/go
Environment=PATH=/usr/local/go/bin:/usr/bin:/bin

[Install]
WantedBy=multi-user.target

在启动前，需要修改刚才的Nginx配置文件/etc/nginx/sites-available/my-hugo-site，添加一个server块，用于接收Webhook请求。

server {
 listen 80;
 listen 8080;
 server_name example.com <Your-Server-IP>; # 需要修改为实际域名和服务器IP

 location / {
 root /path/to/my-hugo-site/public; # 需要修改为实际网站根目录
 index index.html;
 }
}

# 添加一个server块，用于接收Webhook请求
server {
 listen 10086; # 添加Webhook监听端口，按需修改
 server_name example.com <Your-Server-IP>; # 需要修改为实际域名和服务器IP
 location / {
 proxy_pass http://localhost:10085; # 需要修改为实际Webhook监听端口
 }
}

启用服务并启动：

# 重载Daemon
sudo systemctl daemon-reload
# 启动服务
sudo systemctl enable webhook-my-hugo-site
sudo systemctl start webhook-my-hugo-site
# 查看服务状态
sudo systemctl status webhook-my-hugo-site

然后，在Github的my-hugo-site仓库的Settings中，找到Webhooks，添加一个新的Webhook，填写服务器的Webhook地址，如http://<Your-Server-IP>:10086/webhook，并选择application/json格式。

现在，每次在Github上更新仓库后，服务器都会自动构建网站。

配置DNS和TLS

为了实现通过域名访问网站，需要在域名的DNS管理控制台中添加一条A记录，将域名解析到服务器的公网IP。

如果你的服务器基于阿里云，可以参考阿里云DNS解析

为了实现HTTPS访问，可以使用acme.sh工具申请ZeroSSL免费SSL证书。

# 安装acme.sh
curl https://get.acme.sh | sh
source ~/.bashrc
# 注册ZeroSSL申请邮箱
acme.sh --register-account -m <your_email@example.com>
# 申请并安装证书
sudo acme.sh --issue --standalone -d example.com -d www.example.com \
 --key-file /etc/nginx/ssl/example.com.key \
 --fullchain-file /etc/nginx/ssl/example.com.crt

编辑/etc/nginx/sites-available/my-hugo-site文件，添加ssl_certificate和ssl_certificate_key字段。

server {
 listen 80;
 listen 8080;
 server_name example.com <Your-Server-IP>; # 需要修改为实际域名和服务器IP

 location / {
 root /path/to/my-hugo-site/public; # 需要修改为实际网站根目录
 index index.html;
 }

 listen 443 ssl; # 添加SSL监听端口
 ssl_certificate /etc/nginx/ssl/example.com.crt; # 需要修改为实际证书路径
 ssl_certificate_key /etc/nginx/ssl/example.com.key; # 需要修改为实际私钥路径
}

server {
 listen 10086; # 添加Webhook监听端口，按需修改
 server_name example.com <Your-Server-IP>; # 需要修改为实际域名和服务器IP
 location / {
 proxy_pass http://localhost:10085; # 需要修改为实际Webhook监听端口
 }
}

重启Nginx服务sudo systemctl restart nginx。

现在，通过https://example.com访问网站，应该可以看到已经使用HTTPS加密。

若访问顺利，代表证书有效，可以继续配置Nginx，添加HTTP到HTTPS的重定向。

编辑/etc/nginx/sites-available/my-hugo-site文件，添加一个server块，用于重定向。

server {
 # 此处移除原先的80、8080端口监听

 server_name example.com <Your-Server-IP>; # 需要修改为实际域名和服务器IP

 location / {
 root /path/to/my-hugo-site/public; # 需要修改为实际网站根目录
 index index.html;
 }

 listen 443 ssl; # 添加SSL监听端口
 ssl_certificate /etc/nginx/ssl/example.com.crt; # 需要修改为实际证书路径
 ssl_certificate_key /etc/nginx/ssl/example.com.key; # 需要修改为实际私钥路径
}

# 添加一个server块，用于重定向
server {
 listen 80;
 server_name example.com <Your-Server-IP>; # 需要修改为实际域名和服务器IP
 return 301 https://$host$request_uri;
}

server {
 listen 10086; # 添加Webhook监听端口，按需修改
 server_name example.com <Your-Server-IP>; # 需要修改为实际域名和服务器IP
 location / {
 proxy_pass http://localhost:10085; # 需要修改为实际Webhook监听端口
 }
}

重启Nginx服务sudo systemctl restart nginx。

现在，通过http://example.com访问网站，也会自动重定向到https://example.com。

后续写作

在Windows上安装Hugo的方法如下，打开PowerShell，执行以下命令：

# 安装Scoop
iwr -useb get.scoop.sh | iex
# 安装Hugo
scoop install hugo-extended
# 验证安装
hugo version

在一切配置完成后，我们可以在自己的环境上也克隆my-hugo-site仓库，安装Hugo，用同样的方式新建文章然后通过Markdown写作，之后用Git提交到Github。

在编写中，可以通过hugo server命令在本地环境预览网站效果。

结语

至此，我们已经完成了基于Hugo的个人博客的搭建，实现了：

基于Markdown在本地写作，通过Git上传到远程仓库；远程仓库更新时触发Webhook自动更新网站内容，通过Nginx作为Web服务器，通过域名访问网站；通过acme.sh申请ZeroSSl免费SSL证书，实现HTTPS访问。

参考

基于 Prometheus 与 SpireCV 的无人机视觉跟踪

Thu, 26 Sep 2024 20:00:32 +0800

d.cpp

基于无人机 ROS（机器人操作系统）的视觉控制程序，利用了 SpireCV SDK 进行目标检测和跟踪。主要功能是从相机获取图像，进行目标检测，如果检测到特定目标，则可以通过鼠标点击开始对该目标进行自动跟踪。

1. 头文件和命名空间

#include <iostream>
#include <string>
// 包含 SpireCV SDK 头文件
#include <sv_world.h>
#include <ros/ros.h>
#include <spirecv_msgs/TargetsInFrame.h>
#include <spirecv_msgs/Target.h>
#include <spirecv_msgs/ROI.h>
#include <spirecv_msgs/Control.h>
#include <image_transport/image_transport.h>
#include <cv_bridge/cv_bridge.h>

using namespace std;

包含了标准的 C++ 库，ROS 库，以及 SpireCV SDK 的头文件。
使用 namespace std 方便后续代码的编写。

2. 全局变量和函数声明

// 定义窗口名称
static const std::string RGB_WINDOW = "Image window";
// 框选到的矩形
cv::Rect rect_sel;
// 框选起始点
cv::Point pt_origin;

// 是否得到一个新的框选区域
bool b_renew_ROI = false;
// 是否开始跟踪
bool b_begin_TRACK = false;

cv::Mat ros_img;
bool get_ros_img = false;

int img_width, img_height;

//【发布】检测结果图像
image_transport::Publisher aruco_pub;
ros::Publisher spirecv_msg_pub;

// 实现框选逻辑的回调函数
void onMouse(int event, int x, int y, int, void *);
void remoteMouse(spirecv_msgs::Control ctl_msg);

// 声明了用于计算点是否在矩形内的函数
double getCross(node p1, node p2, node p);

定义了一些全局变量，用于控制程序的状态和存储数据。
声明了鼠标回调函数 onMouse 和远程鼠标回调函数 remoteMouse，用于处理用户的输入。

3. 相机回调函数

void cameraCallback(const sensor_msgs::ImageConstPtr &msg)
{
 cv_bridge::CvImagePtr cam_image;
 try
 {
 cam_image = cv_bridge::toCvCopy(msg, sensor_msgs::image_encodings::BGR8);
 cam_image->image.copyTo(ros_img);

 get_ros_img = true;
 }
 catch (cv_bridge::Exception &e)
 {
 ROS_ERROR("cv_bridge exception: %s", e.what());
 }
}

订阅相机话题的回调函数，将 ROS 图像消息转换为 OpenCV 图像。
设置标志 get_ros_img = true，表示已经获取到新的图像。

4. 点和几何计算

struct node
{
 double x, y;
};

node p1, p2, p3, p4;
node p;

double getCross(node p1, node p2, node p)
{
 return (p2.x - p1.x) * (p.y - p1.y) - (p.x - p1.x) * (p2.y - p1.y);
}

定义了一个 node 结构体，表示二维点。
定义了 getCross 函数，用于计算叉积，判断点是否在矩形内。

5. 鼠标回调函数

void onMouse(int event, int x, int y, int, void *)
{
 if (b_clicked)
 {
 // 更新框选区域坐标
 pt_origin.x = -1;
 pt_origin.y = -1;
 }
 // 左键按下
 if (event == cv::EVENT_LBUTTONDOWN)
 {
 detect_tracking = true;
 pt_origin = cv::Point(x, y);
 }
 else if (event == cv::EVENT_RBUTTONDOWN)
 {
 detect_tracking = true;
 b_renew_ROI = false;
 b_begin_TRACK = false;
 b_clicked = true;
 }
}

处理鼠标事件：
- 左键点击时，记录点击位置，并设置 detect_tracking = true，表示重新进入检测模式。
- 右键点击时，退出跟踪模式，重新进入检测模式。

6. 远程鼠标回调函数

void remoteMouse(spirecv_msgs::Control ctl_msg)
{
 if (b_clicked)
 {
 // 更新框选区域坐标
 pt_origin.x = -1;
 pt_origin.y = -1;
 }
 // 左键按下
 if (ctl_msg.mouse == spirecv_msgs::Control::MOUSE_LEFT)
 {
 detect_tracking = true;
 pt_origin = cv::Point(ctl_msg.x * img_width, ctl_msg.y * img_height);
 }
 else if (ctl_msg.mouse == spirecv_msgs::Control::MOUSE_RIGHT)
 {
 detect_tracking = true;
 b_renew_ROI = false;
 b_begin_TRACK = false;
 b_clicked = true;
 }
}

与鼠标回调函数类似，但这是用于接收远程控制指令，通过 ROS 话题接收鼠标事件。

7. 主函数

int main(int argc, char *argv[])
{
 ros::init(argc, argv, "car_detection_with_tracking");
 ros::NodeHandle nh("~");
 // 更新频率为60HZ
 ros::Rate loop_rate(60);
 int uav_id = 1;
 std::string camera_params_yaml = "";
 std::string local_saving_path = "";
 std::string input_image_topic = "";
 std::string output_image_topic = "";

 // 初始化一些参数
 nh.getParam("uav_id", uav_id);
 nh.getParam("camera_parameters", camera_params_yaml);
 nh.getParam("local_saving_path", local_saving_path);
 nh.getParam("input_image_topic", input_image_topic);
 nh.getParam("output_image_topic", output_image_topic);

 // 打印参数信息
 printf("UAV_ID: %d\n", uav_id);
 printf("CAMERA_PARAMS: %s\n", camera_params_yaml.c_str());
 printf("LOCAL_SAVING_PATH: %s\n", local_saving_path.c_str());
 printf("INPUT_IMAGE_TOPIC: %s\n", input_image_topic.c_str());
 printf("OUTPUT_IMAGE_TOPIC: %s\n", output_image_topic.c_str());

 // 初始化图像传输和订阅者、发布者
 image_transport::ImageTransport it(nh);
 image_transport::Subscriber image_subscriber;
 image_subscriber = it.subscribe(input_image_topic, 10, cameraCallback);
 ros::Publisher spirecv_msg_pub = nh.advertise<spirecv_msgs::TargetsInFrame>("/uav" + std::to_string(uav_id) + "/spirecv/car_detection_with_tracking", 1);

 ros::Subscriber spirecv_ctl_sub = nh.subscribe("/uav" + std::to_string(uav_id) + "/spirecv/control", 10, remoteMouse);

 aruco_pub = it.advertise(output_image_topic.c_str(), 1);

 // 定义一个新的窗口，可在上面进行框选操作
 cv::namedWindow(RGB_WINDOW);
 // 设置窗口操作回调函数，该函数实现整个框选逻辑
 cv::setMouseCallback(RGB_WINDOW, onMouse, 0);

 // 实例化框选目标跟踪类和通用目标检测器
 sv::SingleObjectTracker sot;
 sv::CommonObjectDetector cod;

 // 加载相机参数
 sot.loadCameraParams(camera_params_yaml);
 cod.loadCameraParams(camera_params_yaml);

 // 初始化图像尺寸
 img_height = sot.image_height;
 img_width = sot.image_width;

 // 实例化视频流传输器
 sv::VideoStreamer streamer;
 streamer.setup(cv::Size(img_width, img_height), 8554, 2);

 // 主循环
 while (ros::ok())
 {
 if (get_ros_img == true)
 {
 get_ros_img = false;
 img = ros_img.clone();

 if (detect_tracking == true)
 {
 // 如果处于检测模式
 // 实例化目标帧
 sv::TargetsInFrame tgts(frame_id++);

 // 调整图像尺寸
 cv::resize(img, img, cv::Size(cod.image_width, cod.image_height));

 // 初始化跟踪器
 rect_sel = cv::Rect(0, 0, 4, 4);
 sot.init(img, rect_sel);

 // 执行通用目标检测
 cod.detect(img, tgts);

 // 可视化检测结果
 sv::drawTargetsInFrame(img, tgts);

 // 将检测结果转换为 ROS 消息并发布
 spirecv_msgs::TargetsInFrame ros_tgts;
 // ...（设置 ros_tgts 的各个字段）
 spirecv_msg_pub.publish(ros_tgts);

 // 打印检测结果到控制台
 // ...（打印 tgts 的信息）

 // 检查鼠标点击位置是否在检测到的目标内
 for (int i = 0; i < tgts.targets.size(); i++)
 {
 // 计算目标的四个顶点
 // ...（设置 p1, p2, p3, p4）

 // 判断点击点是否在目标矩形内
 if (getCross(p1, p2, p) * getCross(p3, p4, p) >= 0 && getCross(p2, p3, p) * getCross(p4, p1, p) >= 0)
 {
 b_begin_TRACK = false;
 detect_tracking = false;
 rect_sel = cv::Rect(p1.x, p1.y, tgts.targets[i].w * tgts.width, tgts.targets[i].h * tgts.height);
 b_renew_ROI = true;
 frame_id = 0;
 printf("spirecv mode is tracked!\n");
 }
 else
 {
 printf("spirecv mode is detection!\n");
 }
 }
 }
 else
 {
 // 如果处于跟踪模式
 sv::TargetsInFrame tgts(frame_id++);
 cv::resize(img, img, cv::Size(sot.image_width, sot.image_height));

 if (b_renew_ROI)
 {
 // 初始化跟踪器
 sot.init(img, rect_sel);
 b_renew_ROI = false;
 b_begin_TRACK = true;
 }
 else if (b_begin_TRACK)
 {
 // 继续跟踪
 sot.track(img, tgts);

 // 可视化跟踪结果
 sv::drawTargetsInFrame(img, tgts);

 // 将跟踪结果转换为 ROS 消息并发布
 spirecv_msgs::TargetsInFrame ros_tgts;
 // ...（设置 ros_tgts 的各个字段）
 spirecv_msg_pub.publish(ros_tgts);

 // 打印跟踪结果到控制台
 // ...（打印 tgts 的信息）
 }
 }

 // 流式传输图像
 streamer.stream(img);

 // 显示图像
 cv::imshow(RGB_WINDOW, img);
 cv::waitKey(10);

 // 发布图像消息
 sensor_msgs::ImagePtr det_output_msg = cv_bridge::CvImage(std_msgs::Header(), "bgr8", img).toImageMsg();
 aruco_pub.publish(det_output_msg);
 }

 ros::spinOnce();
 loop_rate.sleep();
 }

 return 0;
}

初始化 ROS 节点和参数：获取无人机 ID，相机参数文件路径，本地保存路径，输入和输出图像话题等参数。
订阅和发布：订阅相机图像话题和控制指令话题，发布检测和跟踪结果，以及输出的图像。
窗口和回调函数：创建 OpenCV 窗口，用于显示图像，并设置鼠标回调函数。
加载相机参数：为检测器和跟踪器加载相机参数。
主循环：
- 检查是否有新的图像。
- 如果处于检测模式：
  - 使用通用目标检测器进行目标检测。
  - 可视化检测结果。
  - 将检测结果发布为 ROS 消息。
  - 检查鼠标点击位置，如果点击在目标上，则切换到跟踪模式。
- 如果处于跟踪模式：
  - 使用单目标跟踪器进行跟踪。
  - 可视化跟踪结果。
  - 将跟踪结果发布为 ROS 消息。
  - 如果需要，可以通过右键点击退出跟踪模式。
- 显示图像并发布图像消息。

y.cpp

基于无人机 ROS（机器人操作系统）的目标跟踪程序，使用了 SpireCV 和 Prometheus 的消息类型，实现了对目标的检测和跟踪。通过订阅视觉检测结果，计算控制指令，将其发布给无人机控制模块，从而实现无人机对目标的自主跟踪。

1. 头文件和命名空间

#include <ros/ros.h>
#include <sstream>
#include <Eigen/Eigen>
#include <iostream>
#include <prometheus_msgs/UAVState.h>
#include <prometheus_msgs/UAVCommand.h>
#include <prometheus_msgs/UAVControlState.h>
#include <spirecv_msgs/TargetsInFrame.h>
#include <spirecv_msgs/Target.h>
#include <spirecv_msgs/ROI.h>
// #include <prometheus_msgs/Target.h>
// #include <prometheus_msgs/TargetsInFrame.h>
// #include <prometheus_msgs/ROI.h>
#include <mission_utils.h>
#include "printf_utils.h"

using namespace std;
using namespace Eigen;

#define NODE_NAME "yolov5_tracking"

包含的头文件：
- ROS 相关的头文件，如 ros/ros.h。
- Eigen 库用于线性代数计算。
- Prometheus 和 SpireCV 的自定义消息类型，用于无人机状态和目标信息的通信。
- 一些工具类头文件，如 mission_utils.h 和 printf_utils.h，用于辅助功能。
命名空间：
- 使用了标准命名空间 std 和 Eigen 命名空间 Eigen，方便后续代码编写。
宏定义：
- 定义了节点名称 NODE_NAME，用于 ROS 节点的初始化。

2. 全局变量声明

prometheus_msgs::UAVState g_UAVState;
Eigen::Vector3f g_drone_pos;
prometheus_msgs::UAVControlState g_uavcontrol_state;
spirecv_msgs::Target g_Detection_raw;
prometheus_msgs::UAVCommand g_command_now;
Eigen::Vector3f pos_body_frame;
Eigen::Vector3f pos_body_enu_frame;
float kpx_track, kpy_track, kpz_track;
bool is_detected = false;
int num_count_vision_lost = 0;
int num_count_vision_regain = 0;
int g_uav_id;
int Thres_vision = 0;
Eigen::Vector3f camera_offset;
float distance_to_setpoint;
Eigen::Vector3f tracking_delta;
Eigen::Vector3d car_pose_;
int car_id;
spirecv_msgs::TargetsInFrame det;
std::ostringstream info;

无人机状态相关变量：
- g_UAVState：无人机的当前状态，包括位置、姿态等。
- g_drone_pos：无人机的位置向量。
控制相关变量：
- g_uavcontrol_state：无人机的控制状态，表示当前无人机的控制模式。
- g_command_now：将要发送给无人机的控制命令。
目标检测相关变量：
- g_Detection_raw：最新的目标检测结果。
- is_detected：标志是否检测到目标。
控制参数：
- kpx_track, kpy_track, kpz_track：控制器的比例增益，用于计算控制指令。
- tracking_delta：无人机与目标之间的期望距离偏移。
其他变量：
- num_count_vision_lost、num_count_vision_regain：用于计数视觉丢失和重新检测到的次数。
- camera_offset：相机相对于无人机中心的偏移量。
- Thres_vision：视觉丢失计数器的阈值。
- det：存储目标检测的消息。
- info：用于格式化输出信息的字符串流。

3. 无人机状态回调函数

void droneStateCb(const prometheus_msgs::UAVState::ConstPtr &msg)
{
 g_UAVState = *msg;
 g_drone_pos[0] = g_UAVState.position[0];
 g_drone_pos[1] = g_UAVState.position[1];
 g_drone_pos[2] = g_UAVState.position[2];
}

功能：订阅无人机的状态信息，更新全局变量 g_UAVState 和无人机位置 g_drone_pos。
参数：msg，来自 /prometheus/state 话题的消息，包含无人机的状态信息。

4. 视觉检测回调函数

void VisionCb(const spirecv_msgs::TargetsInFrame::ConstPtr &msg)
{
 det = *msg;
 car_id = det.frame_id;
 g_Detection_raw.mode = false;
 for(auto &tar : msg->targets)
 {
 // if(!tar.mode)
 // continue;
 g_Detection_raw = tar;
 // car_pose_[0] = tar.px;
 // car_id = tar.tracked_id;

 // cout << "132456 is :" << car_pose_[0] << endl;
 // break;
 }
}

功能：订阅来自视觉检测节点的目标信息，更新全局变量 g_Detection_raw。
参数：msg，来自 /spirecv/car_detection_with_tracking 话题的消息，包含检测到的目标列表。
逻辑：
- 将接收到的消息赋值给全局变量 det。
- 提取 frame_id，存储到 car_id。
- 初始化 g_Detection_raw.mode 为 false，表示当前未检测到目标。
- 遍历 msg->targets，如果找到目标，则将其赋值给 g_Detection_raw。
- （注释掉的代码表明，可能曾经有过滤 tar.mode 的逻辑。）

5. 主函数

int main(int argc, char **argv)
{
 ros::init(argc, argv, "yolov5_tracking");
 ros::NodeHandle nh;

 ros::Rate rate(25);

 //视觉丢失次数阈值
 nh.param<int>("Thres_vision", Thres_vision, 10);

 //追踪的前后间隔
 nh.param<float>("tracking_delta_x", tracking_delta[0], 2);
 nh.param<float>("tracking_delta_y", tracking_delta[1], 0.0);
 nh.param<float>("tracking_delta_z", tracking_delta[2], 2);

 nh.param<float>("camera_offset_x", camera_offset[0], 0.0);
 nh.param<float>("camera_offset_y", camera_offset[1], 0.0);
 nh.param<float>("camera_offset_z", camera_offset[2], 0.0);

 //追踪控制参数
 nh.param<float>("kpx_track", kpx_track, 0.1);
 nh.param<float>("kpy_track", kpy_track, 0.1);
 nh.param<float>("kpz_track", kpz_track, 0.1);

 nh.param<int>("uav_id", g_uav_id, 1);

 // 订阅无人机状态、视觉检测结果、无人机控制状态
 ros::Subscriber curr_pos_sub = nh.subscribe<prometheus_msgs::UAVState>("/uav" + std::to_string(g_uav_id) + "/prometheus/state", 10, droneStateCb);
 ros::Subscriber vision_sub = nh.subscribe<spirecv_msgs::TargetsInFrame>("/uav" + std::to_string(g_uav_id) + "/spirecv/car_detection_with_tracking", 10, VisionCb);
 ros::Subscriber uav_control_state_sub = nh.subscribe<prometheus_msgs::UAVControlState>(
 "/uav" + std::to_string(g_uav_id) + "/prometheus/control_state", 10,
 [&](const prometheus_msgs::UAVControlState::ConstPtr &msg) -> void
 {
 g_uavcontrol_state = *msg;
 });

 // 发布控制指令
 ros::Publisher command_pub = nh.advertise<prometheus_msgs::UAVCommand>("/uav" + std::to_string(g_uav_id) + "/prometheus/command", 10);

 while (ros::ok())
 {
 ros::spinOnce();

 // 检查无人机是否处于 COMMAND_CONTROL 模式
 if (g_uavcontrol_state.control_state != prometheus_msgs::UAVControlState::COMMAND_CONTROL)
 {
 PCOUT(-1, WHITE, "Waiting for enter COMMAND_CONTROL state");
 }

 // 如果未检测到目标
 if (!g_Detection_raw.mode)
 {
 g_command_now.Agent_CMD = prometheus_msgs::UAVCommand::Current_Pos_Hover;
 PCOUT(-1, GREEN, "Waiting for click target!");
 }
 else
 {
 // 计算无人机与目标的距离
 distance_to_setpoint = pos_body_frame.norm();

 // 设置无人机的控制指令为移动模式
 g_command_now.Agent_CMD = prometheus_msgs::UAVCommand::Move;
 g_command_now.Move_mode = prometheus_msgs::UAVCommand::XYZ_VEL_BODY;

 // 根据目标的位置计算速度指令
 g_command_now.velocity_ref[0] = 0.5 * (g_Detection_raw.pz - 2.0);
 g_command_now.velocity_ref[1] = -0.8 * g_Detection_raw.px;

 // 根据目标的视线角调整垂直速度
 if (g_Detection_raw.los_ay <= -20)
 {
 g_command_now.velocity_ref[2] = 0.8 * g_Detection_raw.py;
 }
 else if (g_Detection_raw.los_ay >= -15)
 {
 g_command_now.velocity_ref[2] = -0.8 * g_Detection_raw.py;
 }
 else
 {
 g_command_now.velocity_ref[2] = 0;
 }

 g_command_now.yaw_ref = 0;
 PCOUT(-1, GREEN, "target tracking!");
 }

 // 更新控制指令的时间戳和命令 ID
 g_command_now.header.stamp = ros::Time::now();
 g_command_now.Command_ID = g_command_now.Command_ID + 1;

 // 在初始阶段，先悬停一段时间
 if (g_command_now.Command_ID < 10)
 g_command_now.Agent_CMD = prometheus_msgs::UAVCommand::Init_Pos_Hover;

 // 发布控制指令
 command_pub.publish(g_command_now);

 rate.sleep();
 }

 return 0;
}

节点初始化：使用 ros::init 初始化节点，节点名称为 "yolov5_tracking"。
参数获取：
- 使用 nh.param 获取参数服务器上的参数，如视觉丢失阈值、追踪控制参数、无人机 ID 等。
话题订阅和发布：
- 订阅无人机状态、视觉检测结果、无人机控制状态。
- 发布控制指令到 /prometheus/command。
主循环：
- 使用 ros::spinOnce() 处理回调函数。
- 检查无人机是否处于 COMMAND_CONTROL 模式，如果不是，等待进入该模式。
- 根据是否检测到目标，决定无人机的控制指令：
  - 未检测到目标：发送悬停指令 Current_Pos_Hover，等待目标出现。
  - 检测到目标：计算无人机需要的速度指令，跟踪目标。
    - 水平速度根据目标的位置 g_Detection_raw.px 和 g_Detection_raw.pz 计算。
    - 垂直速度根据目标的视线角 g_Detection_raw.los_ay 进行调整。
- 更新控制指令的时间戳和命令 ID。
- 在初始阶段（命令 ID 小于 10），发送初始化悬停指令 Init_Pos_Hover。
- 发布控制指令 g_command_now。

Hello Hugo：站点初建

Sat, 21 Sep 2024 21:50:54 +0800

Hello Hugo：站点初建

Hugo + Stack。第一篇。