873 lines
32 KiB
C++
873 lines
32 KiB
C++
// Copyright (c) 2024 by Rockchip Electronics Co., Ltd. All Rights Reserved.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
#include "yolov8-obb.h"
|
|
|
|
#include <math.h>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/time.h>
|
|
|
|
#include <iostream>
|
|
#include <cmath>
|
|
#include <algorithm>
|
|
|
|
#include <set>
|
|
#include <vector>
|
|
#define LABEL_NALE_TXT_PATH "./model/yolov8_obb_labels_list.txt"
|
|
|
|
static char *labels[OBJ_CLASS_NUM];
|
|
static thread_local int single_output_class_count = 0;
|
|
static char single_output_labels[OBJ_CLASS_NUM][32];
|
|
static bool custom_labels_enabled = false;
|
|
|
|
const int anchor[3][6] = {{10, 13, 16, 30, 33, 23},
|
|
{30, 61, 62, 45, 59, 119},
|
|
{116, 90, 156, 198, 373, 326}
|
|
};
|
|
|
|
inline static int clamp(float val, int min, int max) {
|
|
return val > min ? (val < max ? val : max) : min;
|
|
}
|
|
|
|
static char *readLine(FILE *fp, char *buffer, int *len) {
|
|
int ch;
|
|
int i = 0;
|
|
size_t buff_len = 0;
|
|
|
|
buffer = (char *)malloc(buff_len + 1);
|
|
if (!buffer)
|
|
return NULL; // Out of memory
|
|
|
|
while ((ch = fgetc(fp)) != '\n' && ch != EOF) {
|
|
buff_len++;
|
|
void *tmp = realloc(buffer, buff_len + 1);
|
|
if (tmp == NULL) {
|
|
free(buffer);
|
|
return NULL; // Out of memory
|
|
}
|
|
buffer = (char *)tmp;
|
|
|
|
buffer[i] = (char)ch;
|
|
i++;
|
|
}
|
|
buffer[i] = '\0';
|
|
|
|
*len = buff_len;
|
|
|
|
// Detect end
|
|
if (ch == EOF && (i == 0 || ferror(fp))) {
|
|
free(buffer);
|
|
return NULL;
|
|
}
|
|
return buffer;
|
|
}
|
|
|
|
static int readLines(const char *fileName, char *lines[], int max_line) {
|
|
FILE *file = fopen(fileName, "r");
|
|
char *s;
|
|
int i = 0;
|
|
int n = 0;
|
|
|
|
if (file == NULL) {
|
|
printf("Open %s fail!\n", fileName);
|
|
return -1;
|
|
}
|
|
|
|
while ((s = readLine(file, s, &n)) != NULL) {
|
|
lines[i++] = s;
|
|
if (i >= max_line)
|
|
break;
|
|
}
|
|
fclose(file);
|
|
return i;
|
|
}
|
|
|
|
static int loadLabelName(const char *locationFilename, char *label[]) {
|
|
printf("load lable %s\n", locationFilename);
|
|
readLines(locationFilename, label, OBJ_CLASS_NUM);
|
|
return 0;
|
|
}
|
|
|
|
static float CalculateOverlap(float xmin0, float ymin0, float xmax0, float ymax0, float xmin1, float ymin1, float xmax1,
|
|
float ymax1) {
|
|
float w = fmax(0.f, fmin(xmax0, xmax1) - fmax(xmin0, xmin1) + 1.0);
|
|
float h = fmax(0.f, fmin(ymax0, ymax1) - fmax(ymin0, ymin1) + 1.0);
|
|
float i = w * h;
|
|
float u = (xmax0 - xmin0 + 1.0) * (ymax0 - ymin0 + 1.0) + (xmax1 - xmin1 + 1.0) * (ymax1 - ymin1 + 1.0) - i;
|
|
return u <= 0.f ? 0.f : (i / u);
|
|
}
|
|
|
|
|
|
// box转化为角点
|
|
std::vector<float> rbbox_to_corners(const std::vector<float> &rbbox) {
|
|
// generate clockwise corners and rotate it clockwise
|
|
// 顺时针方向返回角点位置
|
|
float cx = rbbox[0] + rbbox[2] / 2;
|
|
float cy = rbbox[1] + rbbox[3] / 2;
|
|
float x_d = rbbox[2];
|
|
float y_d = rbbox[3];
|
|
float angle = rbbox[4];
|
|
float a_cos = std::cos(angle);
|
|
float a_sin = std::sin(angle);
|
|
std::vector<float> corners(8, 0.0);
|
|
float corners_x[4] = {-x_d / 2, -x_d / 2, x_d / 2, x_d / 2};
|
|
float corners_y[4] = {-y_d / 2, y_d / 2, y_d / 2, -y_d / 2};
|
|
for (int i = 0; i < 4; ++i) {
|
|
corners[2 * i] = a_cos * corners_x[i] - a_sin * corners_y[i] + cx;
|
|
corners[2 * i + 1] = a_sin * corners_x[i] + a_cos * corners_y[i] + cy;
|
|
}
|
|
return corners;
|
|
}
|
|
|
|
// 检测点是否在四边形内的函数
|
|
bool point_in_quadrilateral(float pt_x, float pt_y, const std::vector<float> &corners) {
|
|
float ab0 = corners[2] - corners[0];
|
|
float ab1 = corners[3] - corners[1];
|
|
|
|
float ad0 = corners[6] - corners[0];
|
|
float ad1 = corners[7] - corners[1];
|
|
|
|
float ap0 = pt_x - corners[0];
|
|
float ap1 = pt_y - corners[1];
|
|
|
|
float abab = ab0 * ab0 + ab1 * ab1;
|
|
float abap = ab0 * ap0 + ab1 * ap1;
|
|
float adad = ad0 * ad0 + ad1 * ad1;
|
|
float adap = ad0 * ap0 + ad1 * ap1;
|
|
|
|
return abab >= abap && abap >= 0 && adad >= adap && adap >= 0;
|
|
}
|
|
|
|
|
|
// 检测线段相交并计算交点的函数
|
|
int line_segment_intersection(const std::vector<float> &pts1, const std::vector<float> &pts2, int i, int j
|
|
, bool &ret1, float &point_x, float &point_y) {
|
|
// pts1, pts2 分别为 corners
|
|
// i j 分别表示第几个交点，取其和其后一个点构成的线段
|
|
// 返回 tuple(bool, pts) bool=true pts为交点
|
|
std::vector<float> A(2), B(2), C(2), D(2), ret(2);
|
|
A[0] = pts1[2 * i];
|
|
A[1] = pts1[2 * i + 1];
|
|
|
|
B[0] = pts1[2 * ((i + 1) % 4)];
|
|
B[1] = pts1[2 * ((i + 1) % 4) + 1];
|
|
|
|
C[0] = pts2[2 * j];
|
|
C[1] = pts2[2 * j + 1];
|
|
|
|
D[0] = pts2[2 * ((j + 1) % 4)];
|
|
D[1] = pts2[2 * ((j + 1) % 4) + 1];
|
|
|
|
float BA0 = B[0] - A[0];
|
|
float BA1 = B[1] - A[1];
|
|
float DA0 = D[0] - A[0];
|
|
float CA0 = C[0] - A[0];
|
|
float DA1 = D[1] - A[1];
|
|
float CA1 = C[1] - A[1];
|
|
|
|
// 叉乘判断方向
|
|
bool acd = DA1 * CA0 > CA1 * DA0;
|
|
bool bcd = (D[1] - B[1]) * (C[0] - B[0]) > (C[1] - B[1]) * (D[0] - B[0]);
|
|
|
|
if (acd != bcd) {
|
|
bool abc = CA1 * BA0 > BA1 * CA0;
|
|
bool abd = DA1 * BA0 > BA1 * DA0;
|
|
|
|
// 判断方向
|
|
if (abc != abd) {
|
|
float DC0 = D[0] - C[0];
|
|
float DC1 = D[1] - C[1];
|
|
float ABBA = A[0] * B[1] - B[0] * A[1];
|
|
float CDDC = C[0] * D[1] - D[0] * C[1];
|
|
float DH = BA1 * DC0 - BA0 * DC1;
|
|
float Dx = ABBA * DC0 - BA0 * CDDC;
|
|
float Dy = ABBA * DC1 - BA1 * CDDC;
|
|
ret[0] = Dx / DH;
|
|
ret[1] = Dy / DH;
|
|
ret1 = true;
|
|
point_x = ret[0] ;
|
|
point_y = ret[1] ;
|
|
return 0;
|
|
}
|
|
}
|
|
ret1 = false;
|
|
point_x = ret[0] ;
|
|
point_y = ret[1] ;
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
// 比较函数，用于排序
|
|
bool compare_points(const std::vector<float> &pt1, const std::vector<float> &pt2, const std::vector<float> ¢er) {
|
|
float vx1 = pt1[0] - center[0];
|
|
float vy1 = pt1[1] - center[1];
|
|
float vx2 = pt2[0] - center[0];
|
|
float vy2 = pt2[1] - center[1];
|
|
float d1 = std::sqrt(vx1 * vx1 + vy1 * vy1);
|
|
float d2 = std::sqrt(vx2 * vx2 + vy2 * vy2);
|
|
vx1 /= d1;
|
|
vy1 /= d1;
|
|
vx2 /= d2;
|
|
vy2 /= d2;
|
|
if (vy1 < 0) {
|
|
vx1 = -2 - vx1;
|
|
}
|
|
if (vy2 < 0) {
|
|
vx2 = -2 - vx2;
|
|
}
|
|
return vx1 < vx2;
|
|
}
|
|
|
|
// 对凸多边形的顶点进行排序
|
|
void sort_vertex_in_convex_polygon(std::vector<std::vector<float>> &int_pts, int num_of_inter) {
|
|
if (num_of_inter > 0) {
|
|
std::vector<float> center(2, 0);
|
|
for (int i = 0; i < num_of_inter; ++i) {
|
|
center[0] += int_pts[i][0];
|
|
center[1] += int_pts[i][1];
|
|
}
|
|
center[0] /= num_of_inter;
|
|
center[1] /= num_of_inter;
|
|
std::sort(int_pts.begin(), int_pts.end(), [¢er](const std::vector<float> &pt1, const std::vector<float> &pt2) {
|
|
return compare_points(pt1, pt2, center);
|
|
});
|
|
}
|
|
}
|
|
|
|
// 计算三角形的面积
|
|
float triangle_area(const std::vector<float> &a, const std::vector<float> &b, const std::vector<float> &c) {
|
|
return std::abs((a[0] - c[0]) * (b[1] - c[1]) - (a[1] - c[1]) * (b[0] - c[0])) / 2.0;
|
|
}
|
|
|
|
// 计算多边形转化为多个三角形面积之和
|
|
float polygon_area(const std::vector<std::vector<float>> &int_pts, int num_of_inter) {
|
|
float area_val = 0.0;
|
|
for (int i = 1; i < num_of_inter - 1; ++i) {
|
|
area_val += triangle_area(int_pts[0], int_pts[i], int_pts[i + 1]);
|
|
}
|
|
return area_val;
|
|
}
|
|
|
|
float Cal_IOU(float x1, float y1, float w1, float h1, float angle1, float x2, float y2, float w2, float h2, float angle2) {
|
|
// 定义两个box的数据
|
|
std::vector<float> rbbox1 = {x1, y1, w1, h1, angle1};
|
|
std::vector<float> rbbox2 = {x2, y2, w2, h2, angle2};
|
|
|
|
// 调用函数得到角点数据
|
|
std::vector<float> corners1 = rbbox_to_corners(rbbox1);
|
|
std::vector<float> corners2 = rbbox_to_corners(rbbox2);
|
|
|
|
std::vector<std::vector<float>> pts;
|
|
int num_pts = 0;
|
|
// 检测角点是否在对方的四边形内
|
|
for (int i = 0; i < 4; ++i) {
|
|
float point_x = corners1[2 * i];
|
|
float point_y = corners1[2 * i + 1];
|
|
if (point_in_quadrilateral(point_x, point_y, corners2)) {
|
|
num_pts++;
|
|
pts.push_back({point_x, point_y});
|
|
}
|
|
}
|
|
for (int i = 0; i < 4; ++i) {
|
|
float point_x = corners2[2 * i];
|
|
float point_y = corners2[2 * i + 1];
|
|
if (point_in_quadrilateral(point_x, point_y, corners1)) {
|
|
num_pts++;
|
|
pts.push_back({point_x, point_y});
|
|
}
|
|
}
|
|
|
|
|
|
for (int i = 0; i < 4; ++i) {
|
|
for (int j = 0; j < 4; ++j) {
|
|
float point_x, point_y;
|
|
bool ret;
|
|
line_segment_intersection(corners1, corners2, i, j, ret, point_x, point_y);
|
|
if (ret) {
|
|
num_pts++;
|
|
pts.push_back({point_x, point_y});
|
|
}
|
|
}
|
|
}
|
|
|
|
sort_vertex_in_convex_polygon(pts, num_pts);
|
|
|
|
float polygon_area_val = polygon_area(pts, num_pts);
|
|
|
|
// 计算 area_union
|
|
float area_union = rbbox1[2] * rbbox1[3] + rbbox2[2] * rbbox2[3] - polygon_area_val;
|
|
return polygon_area_val / area_union;
|
|
}
|
|
|
|
|
|
static int nms(int validCount, std::vector<float> &outputLocations, std::vector<int> classIds, std::vector<int> &order,
|
|
int filterId, float threshold) {
|
|
for (int i = 0; i < validCount; ++i) {
|
|
if (order[i] == -1 || classIds[i] != filterId) {
|
|
continue;
|
|
}
|
|
int n = order[i];
|
|
for (int j = i + 1; j < validCount; ++j) {
|
|
int m = order[j];
|
|
if (m == -1 || classIds[m] != filterId) {
|
|
continue;
|
|
}
|
|
float xmin0 = outputLocations[n * 5 + 0];
|
|
float ymin0 = outputLocations[n * 5 + 1];
|
|
float w0 = outputLocations[n * 5 + 2];
|
|
float h0 = outputLocations[n * 5 + 3];
|
|
float angle0 = outputLocations[n * 5 + 4];
|
|
|
|
float xmin1 = outputLocations[m * 5 + 0];
|
|
float ymin1 = outputLocations[m * 5 + 1];
|
|
float w1 = outputLocations[m * 5 + 2];
|
|
float h1 = outputLocations[m * 5 + 3];
|
|
float angle1 = outputLocations[m * 5 + 4];
|
|
|
|
float iou = Cal_IOU(xmin0, ymin0, w0, h0, angle0, xmin1, ymin1, w1, h1, angle1);
|
|
if (iou > threshold) {
|
|
order[j] = -1;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int quick_sort_indice_inverse(std::vector<float> &input, int left, int right, std::vector<int> &indices) {
|
|
float key;
|
|
int key_index;
|
|
int low = left;
|
|
int high = right;
|
|
if (left < right) {
|
|
key_index = indices[left];
|
|
key = input[left];
|
|
while (low < high) {
|
|
while (low < high && input[high] <= key) {
|
|
high--;
|
|
}
|
|
input[low] = input[high];
|
|
indices[low] = indices[high];
|
|
while (low < high && input[low] >= key) {
|
|
low++;
|
|
}
|
|
input[high] = input[low];
|
|
indices[high] = indices[low];
|
|
}
|
|
input[low] = key;
|
|
indices[low] = key_index;
|
|
quick_sort_indice_inverse(input, left, low - 1, indices);
|
|
quick_sort_indice_inverse(input, low + 1, right, indices);
|
|
}
|
|
return low;
|
|
}
|
|
|
|
static float sigmoid(float x) {
|
|
return 1.0 / (1.0 + expf(-x));
|
|
}
|
|
|
|
static float unsigmoid(float y) {
|
|
return -1.0 * logf((1.0 / y) - 1.0);
|
|
}
|
|
|
|
inline static int32_t __clip(float val, float min, float max) {
|
|
float f = val <= min ? min : (val >= max ? max : val);
|
|
return f;
|
|
}
|
|
|
|
static int8_t qnt_f32_to_affine(float f32, int32_t zp, float scale) {
|
|
float dst_val = (f32 / scale) + zp;
|
|
int8_t res = (int8_t)__clip(dst_val, -128, 127);
|
|
return res;
|
|
}
|
|
|
|
static uint8_t qnt_f32_to_affine_u8(float f32, int32_t zp, float scale) {
|
|
float dst_val = (f32 / scale) + zp;
|
|
uint8_t res = (uint8_t)__clip(dst_val, 0, 255);
|
|
return res;
|
|
}
|
|
|
|
static float deqnt_affine_to_f32(int8_t qnt, int32_t zp, float scale) {
|
|
return ((float)qnt - (float)zp) * scale;
|
|
}
|
|
static float deqnt_affine_u8_to_f32(uint8_t qnt, int32_t zp, float scale) {
|
|
return ((float)qnt - (float)zp) * scale;
|
|
}
|
|
|
|
|
|
|
|
void softmax(float *input, int size) {
|
|
float max_val = input[0];
|
|
for (int i = 1; i < size; ++i) {
|
|
if (input[i] > max_val) {
|
|
max_val = input[i];
|
|
}
|
|
}
|
|
|
|
float sum_exp = 0.0;
|
|
for (int i = 0; i < size; ++i) {
|
|
sum_exp += expf(input[i] - max_val);
|
|
}
|
|
|
|
for (int i = 0; i < size; ++i) {
|
|
input[i] = expf(input[i] - max_val) / sum_exp;
|
|
}
|
|
}
|
|
|
|
static int process_i8(int8_t *input, int8_t *angle_feature, int grid_h, int grid_w, int stride,
|
|
std::vector<float> &boxes, std::vector<float> &boxScores, std::vector<int> &classId, float threshold,
|
|
int32_t zp, float scale, int32_t angle_feature_zp, float angle_feature_scale, int index) {
|
|
int input_loc_len = 64;
|
|
int tensor_len = input_loc_len + OBJ_CLASS_NUM;
|
|
int validCount = 0;
|
|
|
|
int8_t thres_i8 = qnt_f32_to_affine(unsigmoid(threshold), zp, scale);
|
|
for (int h = 0; h < grid_h; h++) {
|
|
for (int w = 0; w < grid_w; w++) {
|
|
for (int a = 0; a < OBJ_CLASS_NUM; a++) {
|
|
if(input[(input_loc_len + a)*grid_w * grid_h + h * grid_w + w ] >= thres_i8) { //[1,tensor_len,grid_h,grid_w]
|
|
float box_conf_f32 = sigmoid(deqnt_affine_to_f32(input[(input_loc_len + a) * grid_w * grid_h + h * grid_w + w ],
|
|
zp, scale));
|
|
float loc[input_loc_len];
|
|
for (int i = 0; i < input_loc_len; ++i) {
|
|
loc[i] = deqnt_affine_to_f32(input[i * grid_w * grid_h + h * grid_w + w], zp, scale);
|
|
}
|
|
|
|
for (int i = 0; i < input_loc_len / 16; ++i) {
|
|
softmax(&loc[i * 16], 16);
|
|
}
|
|
float xywh_[4] = {0, 0, 0, 0};
|
|
float xywh[4] = {0, 0, 0, 0};
|
|
for (int dfl = 0; dfl < 16; ++dfl) {
|
|
xywh_[0] += loc[dfl] * dfl;
|
|
xywh_[1] += loc[1 * 16 + dfl] * dfl;
|
|
xywh_[2] += loc[2 * 16 + dfl] * dfl;
|
|
xywh_[3] += loc[3 * 16 + dfl] * dfl;
|
|
}
|
|
|
|
float xywh_add[2], xywh_sub[2];
|
|
xywh_add[0] = xywh_[0] + xywh_[2];
|
|
xywh_add[1] = xywh_[1] + xywh_[3];
|
|
xywh_sub[0] = (xywh_[2] - xywh_[0]) / 2;
|
|
xywh_sub[1] = (xywh_[3] - xywh_[1]) / 2;
|
|
float angle_feature_ = deqnt_affine_to_f32(angle_feature[index + (h * grid_w) + w], angle_feature_zp, angle_feature_scale);
|
|
angle_feature_ = (angle_feature_ - 0.25) * 3.1415927410125732;
|
|
float angle_feature_cos = cos(angle_feature_);
|
|
float angle_feature_sin = sin(angle_feature_);
|
|
float xy_mul1 = xywh_sub[0] * angle_feature_cos;
|
|
float xy_mul2 = xywh_sub[1] * angle_feature_sin;
|
|
float xy_mul3 = xywh_sub[0] * angle_feature_sin;
|
|
float xy_mul4 = xywh_sub[1] * angle_feature_cos;
|
|
xywh_[0] = ((xy_mul1 - xy_mul2) + w + 0.5) * stride;
|
|
xywh_[1] = ((xy_mul3 + xy_mul4) + h + 0.5) * stride;
|
|
xywh_[2] = xywh_add[0] * stride;
|
|
xywh_[3] = xywh_add[1] * stride;
|
|
xywh[0] = (xywh_[0] - xywh_[2] / 2);
|
|
xywh[1] = (xywh_[1] - xywh_[3] / 2);
|
|
xywh[2] = xywh_[2];
|
|
xywh[3] = xywh_[3];
|
|
boxes.push_back(xywh[0]);//x
|
|
boxes.push_back(xywh[1]);//y
|
|
boxes.push_back(xywh[2]);//w
|
|
boxes.push_back(xywh[3]);//h
|
|
boxes.push_back(angle_feature_);//angle
|
|
boxScores.push_back(box_conf_f32);
|
|
classId.push_back(a);
|
|
validCount++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return validCount;
|
|
}
|
|
|
|
|
|
static int process_u8(uint8_t *input, uint8_t *angle_feature, int grid_h, int grid_w, int stride,
|
|
std::vector<float> &boxes, std::vector<float> &boxScores, std::vector<int> &classId, float threshold,
|
|
int32_t zp, float scale, int32_t angle_feature_zp, float angle_feature_scale, int index) {
|
|
int input_loc_len = 64;
|
|
int tensor_len = input_loc_len + OBJ_CLASS_NUM;
|
|
int validCount = 0;
|
|
|
|
uint8_t thres_i8 = qnt_f32_to_affine_u8(unsigmoid(threshold), zp, scale);
|
|
for (int h = 0; h < grid_h; h++) {
|
|
for (int w = 0; w < grid_w; w++) {
|
|
for (int a = 0; a < OBJ_CLASS_NUM; a++) {
|
|
if(input[(input_loc_len + a)*grid_w * grid_h + h * grid_w + w ] >= thres_i8) { //[1,tensor_len,grid_h,grid_w]
|
|
float box_conf_f32 = sigmoid(deqnt_affine_u8_to_f32(input[(input_loc_len + a) * grid_w * grid_h + h * grid_w + w ],
|
|
zp, scale));
|
|
float loc[input_loc_len];
|
|
for (int i = 0; i < input_loc_len; ++i) {
|
|
loc[i] = deqnt_affine_u8_to_f32(input[i * grid_w * grid_h + h * grid_w + w], zp, scale);
|
|
}
|
|
|
|
for (int i = 0; i < input_loc_len / 16; ++i) {
|
|
softmax(&loc[i * 16], 16);
|
|
}
|
|
float xywh_[4] = {0, 0, 0, 0};
|
|
float xywh[4] = {0, 0, 0, 0};
|
|
for (int dfl = 0; dfl < 16; ++dfl) {
|
|
xywh_[0] += loc[dfl] * dfl;
|
|
xywh_[1] += loc[1 * 16 + dfl] * dfl;
|
|
xywh_[2] += loc[2 * 16 + dfl] * dfl;
|
|
xywh_[3] += loc[3 * 16 + dfl] * dfl;
|
|
}
|
|
|
|
float xywh_add[2], xywh_sub[2];
|
|
xywh_add[0] = xywh_[0] + xywh_[2];
|
|
xywh_add[1] = xywh_[1] + xywh_[3];
|
|
xywh_sub[0] = (xywh_[2] - xywh_[0]) / 2;
|
|
xywh_sub[1] = (xywh_[3] - xywh_[1]) / 2;
|
|
float angle_feature_ = deqnt_affine_u8_to_f32(angle_feature[index + (h * grid_w) + w], angle_feature_zp, angle_feature_scale);
|
|
angle_feature_ = (angle_feature_ - 0.25) * 3.1415927410125732;
|
|
float angle_feature_cos = cos(angle_feature_);
|
|
float angle_feature_sin = sin(angle_feature_);
|
|
float xy_mul1 = xywh_sub[0] * angle_feature_cos;
|
|
float xy_mul2 = xywh_sub[1] * angle_feature_sin;
|
|
float xy_mul3 = xywh_sub[0] * angle_feature_sin;
|
|
float xy_mul4 = xywh_sub[1] * angle_feature_cos;
|
|
xywh_[0] = ((xy_mul1 - xy_mul2) + w + 0.5) * stride;
|
|
xywh_[1] = ((xy_mul3 + xy_mul4) + h + 0.5) * stride;
|
|
xywh_[2] = xywh_add[0] * stride;
|
|
xywh_[3] = xywh_add[1] * stride;
|
|
xywh[0] = (xywh_[0] - xywh_[2] / 2);
|
|
xywh[1] = (xywh_[1] - xywh_[3] / 2);
|
|
xywh[2] = xywh_[2];
|
|
xywh[3] = xywh_[3];
|
|
boxes.push_back(xywh[0]);//x
|
|
boxes.push_back(xywh[1]);//y
|
|
boxes.push_back(xywh[2]);//w
|
|
boxes.push_back(xywh[3]);//h
|
|
boxes.push_back(angle_feature_);//angle
|
|
boxScores.push_back(box_conf_f32);
|
|
classId.push_back(a);
|
|
validCount++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return validCount;
|
|
}
|
|
|
|
static int process_fp32(float *input, float *angle_feature, int grid_h, int grid_w, int stride,
|
|
std::vector<float> &boxes, std::vector<float> &boxScores, std::vector<int> &classId, float threshold,
|
|
int32_t zp, float scale, int32_t angle_feature_zp, float angle_feature_scale, int index) {
|
|
int input_loc_len = 64;
|
|
int tensor_len = input_loc_len + OBJ_CLASS_NUM;
|
|
int validCount = 0;
|
|
|
|
float thres_fp32 = unsigmoid(threshold);
|
|
for (int h = 0; h < grid_h; h++) {
|
|
for (int w = 0; w < grid_w; w++) {
|
|
for (int a = 0; a < OBJ_CLASS_NUM; a++) {
|
|
if(input[(input_loc_len + a)*grid_w * grid_h + h * grid_w + w ] >= thres_fp32) { //[1,tensor_len,grid_h,grid_w]
|
|
float box_conf_f32 = sigmoid(input[(input_loc_len + a) * grid_w * grid_h + h * grid_w + w ]);
|
|
float loc[input_loc_len];
|
|
for (int i = 0; i < input_loc_len; ++i) {
|
|
loc[i] = input[i * grid_w * grid_h + h * grid_w + w];
|
|
}
|
|
|
|
for (int i = 0; i < input_loc_len / 16; ++i) {
|
|
softmax(&loc[i * 16], 16);
|
|
}
|
|
float xywh_[4] = {0, 0, 0, 0};
|
|
float xywh[4] = {0, 0, 0, 0};
|
|
for (int dfl = 0; dfl < 16; ++dfl) {
|
|
xywh_[0] += loc[dfl] * dfl;
|
|
xywh_[1] += loc[1 * 16 + dfl] * dfl;
|
|
xywh_[2] += loc[2 * 16 + dfl] * dfl;
|
|
xywh_[3] += loc[3 * 16 + dfl] * dfl;
|
|
}
|
|
|
|
float xywh_add[2], xywh_sub[2];
|
|
xywh_add[0] = xywh_[0] + xywh_[2];
|
|
xywh_add[1] = xywh_[1] + xywh_[3];
|
|
xywh_sub[0] = (xywh_[2] - xywh_[0]) / 2;
|
|
xywh_sub[1] = (xywh_[3] - xywh_[1]) / 2;
|
|
float angle_feature_ = angle_feature[index + (h * grid_w) + w];
|
|
angle_feature_ = (angle_feature_ - 0.25) * 3.1415927410125732;
|
|
float angle_feature_cos = cos(angle_feature_);
|
|
float angle_feature_sin = sin(angle_feature_);
|
|
float xy_mul1 = xywh_sub[0] * angle_feature_cos;
|
|
float xy_mul2 = xywh_sub[1] * angle_feature_sin;
|
|
float xy_mul3 = xywh_sub[0] * angle_feature_sin;
|
|
float xy_mul4 = xywh_sub[1] * angle_feature_cos;
|
|
xywh_[0] = ((xy_mul1 - xy_mul2) + w + 0.5) * stride;
|
|
xywh_[1] = ((xy_mul3 + xy_mul4) + h + 0.5) * stride;
|
|
xywh_[2] = xywh_add[0] * stride;
|
|
xywh_[3] = xywh_add[1] * stride;
|
|
xywh[0] = (xywh_[0] - xywh_[2] / 2);
|
|
xywh[1] = (xywh_[1] - xywh_[3] / 2);
|
|
xywh[2] = xywh_[2];
|
|
xywh[3] = xywh_[3];
|
|
boxes.push_back(xywh[0]);//x
|
|
boxes.push_back(xywh[1]);//y
|
|
boxes.push_back(xywh[2]);//w
|
|
boxes.push_back(xywh[3]);//h
|
|
boxes.push_back(angle_feature_);//angle
|
|
boxScores.push_back(box_conf_f32);
|
|
classId.push_back(a);
|
|
validCount++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return validCount;
|
|
}
|
|
|
|
// Adapts the standard Ultralytics YOLOv8-OBB export tensor:
|
|
// [1, 5 + classes, positions] (or its transposed equivalent). The first four
|
|
// channels contain center-x, center-y, width and height; class scores follow;
|
|
// the final channel is the already-decoded angle in radians.
|
|
static int process_single_output_obb_fp32(const rknn_tensor_attr *attr, const float *output,
|
|
std::vector<float> &boxes, std::vector<float> &scores,
|
|
std::vector<int> &class_ids, float threshold) {
|
|
if (attr->n_dims != 3 || output == nullptr) {
|
|
printf("single-output OBB adapter requires a 3D tensor\n");
|
|
return -1;
|
|
}
|
|
|
|
const int dim1 = attr->dims[1];
|
|
const int dim2 = attr->dims[2];
|
|
const bool channel_first = dim1 <= 256 && dim2 > dim1;
|
|
const int channels = channel_first ? dim1 : dim2;
|
|
const int positions = channel_first ? dim2 : dim1;
|
|
const int class_count = channels - 5;
|
|
if (class_count <= 0 || class_count > OBJ_CLASS_NUM) {
|
|
printf("invalid single-output OBB shape: channels=%d positions=%d\n", channels, positions);
|
|
return -1;
|
|
}
|
|
|
|
printf("single-output OBB adapter: channels=%d classes=%d positions=%d layout=%s\n",
|
|
channels, class_count, positions, channel_first ? "NCP" : "NPC");
|
|
single_output_class_count = class_count;
|
|
|
|
auto at = [=](int channel, int position) -> float {
|
|
return channel_first ? output[channel * positions + position]
|
|
: output[position * channels + channel];
|
|
};
|
|
|
|
bool raw_logits = false;
|
|
for (int position = 0; position < positions && !raw_logits; ++position) {
|
|
for (int class_id = 0; class_id < class_count; ++class_id) {
|
|
const float value = at(4 + class_id, position);
|
|
if (value < 0.0f || value > 1.0f) {
|
|
raw_logits = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
printf("single-output OBB score mode: %s\n", raw_logits ? "logits (sigmoid enabled)" : "probability");
|
|
|
|
auto score_at = [&](int class_id, int position) -> float {
|
|
const float value = at(4 + class_id, position);
|
|
return raw_logits ? sigmoid(value) : value;
|
|
};
|
|
|
|
int count = 0;
|
|
for (int position = 0; position < positions; ++position) {
|
|
int best_class = 0;
|
|
float best_score = score_at(0, position);
|
|
for (int class_id = 1; class_id < class_count; ++class_id) {
|
|
const float score = score_at(class_id, position);
|
|
if (score > best_score) {
|
|
best_score = score;
|
|
best_class = class_id;
|
|
}
|
|
}
|
|
if (best_score < threshold) {
|
|
continue;
|
|
}
|
|
|
|
const float center_x = at(0, position);
|
|
const float center_y = at(1, position);
|
|
const float width = at(2, position);
|
|
const float height = at(3, position);
|
|
boxes.push_back(center_x - width * 0.5f);
|
|
boxes.push_back(center_y - height * 0.5f);
|
|
boxes.push_back(width);
|
|
boxes.push_back(height);
|
|
boxes.push_back(at(channels - 1, position));
|
|
scores.push_back(best_score);
|
|
class_ids.push_back(best_class);
|
|
++count;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
int post_process(rknn_app_context_t *app_ctx, void *outputs, letterbox_t *letter_box, float conf_threshold, float nms_threshold, object_detect_result_list *od_results) {
|
|
#if defined(RV1106_1103)
|
|
rknn_tensor_mem **_outputs = (rknn_tensor_mem **)outputs;
|
|
#else
|
|
rknn_output *_outputs = (rknn_output *)outputs;
|
|
#endif
|
|
std::vector<float> filterBoxes;
|
|
std::vector<float> objProbs;
|
|
std::vector<int> classId;
|
|
int validCount = 0;
|
|
int stride = 0;
|
|
int grid_h = 0;
|
|
int grid_w = 0;
|
|
int model_in_w = app_ctx->model_width;
|
|
int model_in_h = app_ctx->model_height;
|
|
memset(od_results, 0, sizeof(object_detect_result_list));
|
|
int index = 0;
|
|
if (app_ctx->io_num.n_output == 1) {
|
|
#if defined(RV1106_1103)
|
|
printf("single-output OBB adapter is not enabled for RV1106/1103\n");
|
|
return -1;
|
|
#else
|
|
validCount = process_single_output_obb_fp32(
|
|
&app_ctx->output_attrs[0],
|
|
static_cast<const float *>(_outputs[0].buf),
|
|
filterBoxes,
|
|
objProbs,
|
|
classId,
|
|
conf_threshold);
|
|
if (validCount < 0) {
|
|
return -1;
|
|
}
|
|
#endif
|
|
} else {
|
|
#ifdef RKNPU1
|
|
for (int i = 0; i < 3; i++) {
|
|
grid_h = app_ctx->output_attrs[i].dims[1];
|
|
grid_w = app_ctx->output_attrs[i].dims[0];
|
|
stride = model_in_h / grid_h;
|
|
if (app_ctx->is_quant) {
|
|
validCount += process_u8((uint8_t *)_outputs[i].buf, (uint8_t *)_outputs[3].buf, grid_h, grid_w, stride, filterBoxes, objProbs,
|
|
classId, conf_threshold, app_ctx->output_attrs[i].zp, app_ctx->output_attrs[i].scale,
|
|
app_ctx->output_attrs[3].zp, app_ctx->output_attrs[3].scale, index);
|
|
} else {
|
|
validCount += process_fp32((float *)_outputs[i].buf, (float *)_outputs[3].buf, grid_h, grid_w, stride, filterBoxes, objProbs,
|
|
classId, conf_threshold, app_ctx->output_attrs[i].zp, app_ctx->output_attrs[i].scale,
|
|
app_ctx->output_attrs[3].zp, app_ctx->output_attrs[3].scale, index);
|
|
}
|
|
index += grid_h * grid_w;
|
|
}
|
|
#else
|
|
for (int i = 0; i < 3; i++) {
|
|
grid_h = app_ctx->output_attrs[i].dims[2];
|
|
grid_w = app_ctx->output_attrs[i].dims[3];
|
|
stride = model_in_h / grid_h;
|
|
if (app_ctx->is_quant) {
|
|
validCount += process_i8((int8_t *)_outputs[i].buf, (int8_t *)_outputs[3].buf, grid_h, grid_w, stride, filterBoxes, objProbs,
|
|
classId, conf_threshold, app_ctx->output_attrs[i].zp, app_ctx->output_attrs[i].scale,
|
|
app_ctx->output_attrs[3].zp, app_ctx->output_attrs[3].scale, index);
|
|
} else {
|
|
validCount += process_fp32((float *)_outputs[i].buf, (float *)_outputs[3].buf, grid_h, grid_w, stride, filterBoxes, objProbs,
|
|
classId, conf_threshold, app_ctx->output_attrs[i].zp, app_ctx->output_attrs[i].scale,
|
|
app_ctx->output_attrs[3].zp, app_ctx->output_attrs[3].scale, index);
|
|
}
|
|
index += grid_h * grid_w;
|
|
}
|
|
#endif
|
|
}
|
|
// no object detect
|
|
if (validCount <= 0) {
|
|
return 0;
|
|
}
|
|
std::vector<int> indexArray;
|
|
for (int i = 0; i < validCount; ++i) {
|
|
indexArray.push_back(i);
|
|
}
|
|
quick_sort_indice_inverse(objProbs, 0, validCount - 1, indexArray);
|
|
|
|
std::set<int> class_set(std::begin(classId), std::end(classId));
|
|
|
|
for (auto c : class_set) {
|
|
nms(validCount, filterBoxes, classId, indexArray, c, nms_threshold);
|
|
}
|
|
|
|
int last_count = 0;
|
|
od_results->count = 0;
|
|
|
|
/* box valid detect target */
|
|
for (int i = 0; i < validCount; ++i) {
|
|
if (indexArray[i] == -1 || last_count >= OBJ_NUMB_MAX_SIZE) {
|
|
continue;
|
|
}
|
|
int n = indexArray[i];
|
|
|
|
float x1 = filterBoxes[n * 5 + 0] - letter_box->x_pad;
|
|
float y1 = filterBoxes[n * 5 + 1] - letter_box->y_pad;
|
|
float w = filterBoxes[n * 5 + 2];
|
|
float h = filterBoxes[n * 5 + 3];
|
|
float angle = filterBoxes[n * 5 + 4];
|
|
|
|
// std::vector<float> rbbox_to_corners(const std::vector<float> &rbbox)
|
|
|
|
int id = classId[n];
|
|
float obj_conf = objProbs[i];
|
|
|
|
od_results->results[last_count].box.x = (int)(clamp(x1, 0, model_in_w) / letter_box->scale);
|
|
od_results->results[last_count].box.y = (int)(clamp(y1, 0, model_in_h) / letter_box->scale);
|
|
od_results->results[last_count].box.w = (int)(clamp(w, 0, model_in_w) / letter_box->scale);
|
|
od_results->results[last_count].box.h = (int)(clamp(h, 0, model_in_h) / letter_box->scale);
|
|
od_results->results[last_count].box.angle = angle;
|
|
od_results->results[last_count].prop = obj_conf;
|
|
od_results->results[last_count].cls_id = id;
|
|
last_count++;
|
|
}
|
|
od_results->count = last_count;
|
|
return 0;
|
|
}
|
|
|
|
int init_post_process() {
|
|
int ret = 0;
|
|
const char *custom_labels = getenv("YOLO_LABELS_PATH");
|
|
const char *labels_path = custom_labels && custom_labels[0] ? custom_labels : LABEL_NALE_TXT_PATH;
|
|
custom_labels_enabled = custom_labels && custom_labels[0];
|
|
ret = loadLabelName(labels_path, labels);
|
|
if (ret < 0) {
|
|
printf("Load %s failed!\n", labels_path);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
char *coco_cls_to_name(int cls_id) {
|
|
|
|
if (custom_labels_enabled && cls_id >= 0 && cls_id < OBJ_CLASS_NUM && labels[cls_id]) {
|
|
return labels[cls_id];
|
|
}
|
|
|
|
if (single_output_class_count > 0 && cls_id >= 0 && cls_id < single_output_class_count) {
|
|
snprintf(single_output_labels[cls_id], sizeof(single_output_labels[cls_id]), "class_%d", cls_id);
|
|
return single_output_labels[cls_id];
|
|
}
|
|
|
|
if (cls_id >= OBJ_CLASS_NUM) {
|
|
return "null";
|
|
}
|
|
|
|
if (labels[cls_id]) {
|
|
return labels[cls_id];
|
|
}
|
|
|
|
return "null";
|
|
}
|
|
|
|
void deinit_post_process() {
|
|
for (int i = 0; i < OBJ_CLASS_NUM; i++) {
|
|
if (labels[i] != nullptr) {
|
|
free(labels[i]);
|
|
labels[i] = nullptr;
|
|
}
|
|
}
|
|
}
|