371 lines
14 KiB
C++
371 lines
14 KiB
C++
// YoloDetector.cpp
|
||
// Build notes (VS2017 / MSVC 19.1x):
|
||
// - Add onnxruntime include path and link against onnxruntime.lib
|
||
// - Copy the matching onnxruntime.dll next to your .exe so Windows does NOT
|
||
// pick up C:\Windows\System32\onnxruntime.dll (version mismatch causes the
|
||
// "Ort::GetApi() returned nullptr" crash).
|
||
// - Requires ONNX Runtime >= 1.13 for GetInputNameAllocated().
|
||
|
||
#include "YoloDetector.h"
|
||
|
||
// ORT headers are ONLY included in this translation unit (pimpl).
|
||
#include <onnxruntime_cxx_api.h>
|
||
|
||
#include <QPainter>
|
||
#include <QDebug>
|
||
#include <algorithm>
|
||
#include <string>
|
||
#include <vector>
|
||
#include <cmath>
|
||
|
||
// ── OrtImpl (pimpl body) ─────────────────────────────────────────────────────
|
||
struct YoloDetector::OrtImpl
|
||
{
|
||
// Env must outlive Session. Use unique_ptr so construction is deferred.
|
||
std::unique_ptr<Ort::Env> env;
|
||
Ort::SessionOptions opts;
|
||
std::unique_ptr<Ort::Session> session;
|
||
Ort::AllocatorWithDefaultOptions alloc;
|
||
|
||
// We store strings to keep them alive, then build pointer arrays for Run().
|
||
std::vector<std::string> inputNamesBuf;
|
||
std::vector<std::string> outputNamesBuf;
|
||
std::vector<const char*> inputNamePtrs;
|
||
std::vector<const char*> outputNamePtrs;
|
||
};
|
||
|
||
// ── ctor / dtor ──────────────────────────────────────────────────────────────
|
||
YoloDetector::YoloDetector(QObject* parent) : QObject(parent) {}
|
||
YoloDetector::~YoloDetector() = default;
|
||
|
||
// ── loadModel ────────────────────────────────────────────────────────────────
|
||
bool YoloDetector::loadModel(const QString& onnxPath)
|
||
{
|
||
|
||
|
||
|
||
m_loaded = false;
|
||
m_ort.reset();
|
||
|
||
try {
|
||
auto impl = std::make_unique<OrtImpl>();
|
||
|
||
// ── Create ORT environment ──────────────────────────────────────────
|
||
impl->env = std::make_unique<Ort::Env>(
|
||
ORT_LOGGING_LEVEL_WARNING, "YoloDetector");
|
||
|
||
// ── Session options ─────────────────────────────────────────────────
|
||
impl->opts.SetIntraOpNumThreads(4);
|
||
impl->opts.SetGraphOptimizationLevel(
|
||
GraphOptimizationLevel::ORT_ENABLE_ALL);
|
||
|
||
// ── Load model ──────────────────────────────────────────────────────
|
||
#ifdef _WIN32
|
||
std::wstring wPath = onnxPath.toStdWString();
|
||
impl->session = std::make_unique<Ort::Session>(
|
||
*impl->env, wPath.c_str(), impl->opts);
|
||
#else
|
||
impl->session = std::make_unique<Ort::Session>(
|
||
*impl->env, onnxPath.toUtf8().constData(), impl->opts);
|
||
#endif
|
||
|
||
// ── Input metadata ──────────────────────────────────────────────────
|
||
size_t numInputs = impl->session->GetInputCount();
|
||
for (size_t i = 0; i < numInputs; ++i) {
|
||
auto ptr = impl->session->GetInputNameAllocated(i, impl->alloc);
|
||
impl->inputNamesBuf.emplace_back(ptr.get());
|
||
}
|
||
for (auto& s : impl->inputNamesBuf)
|
||
impl->inputNamePtrs.push_back(s.c_str());
|
||
|
||
// Read input shape [1, 3, H, W] – dynamic dims may be -1
|
||
auto inInfo = impl->session->GetInputTypeInfo(0)
|
||
.GetTensorTypeAndShapeInfo();
|
||
auto inShape = inInfo.GetShape();
|
||
if (inShape.size() == 4) {
|
||
if (inShape[2] > 0) m_inputH = static_cast<int>(inShape[2]);
|
||
if (inShape[3] > 0) m_inputW = static_cast<int>(inShape[3]);
|
||
}
|
||
|
||
// ── Output metadata ─────────────────────────────────────────────────
|
||
size_t numOutputs = impl->session->GetOutputCount();
|
||
for (size_t i = 0; i < numOutputs; ++i) {
|
||
auto ptr = impl->session->GetOutputNameAllocated(i, impl->alloc);
|
||
impl->outputNamesBuf.emplace_back(ptr.get());
|
||
}
|
||
for (auto& s : impl->outputNamesBuf)
|
||
impl->outputNamePtrs.push_back(s.c_str());
|
||
|
||
// YOLOv8 default output: [1, 4+nc, num_anchors]
|
||
auto outInfo = impl->session->GetOutputTypeInfo(0)
|
||
.GetTensorTypeAndShapeInfo();
|
||
auto outShape = outInfo.GetShape();
|
||
if (outShape.size() >= 2 && outShape[1] > 4)
|
||
m_numClasses = static_cast<int>(outShape[1]) - 4;
|
||
|
||
m_ort = std::move(impl);
|
||
m_loaded = true;
|
||
m_modelPath = onnxPath;
|
||
|
||
// Fill default class names if the caller hasn't set them yet
|
||
if (m_classNames.isEmpty() || m_classNames.size() != m_numClasses) {
|
||
m_classNames.clear();
|
||
// 修正:匹配模型的3类命名
|
||
if (m_numClasses == 3) {
|
||
m_classNames << QStringLiteral("干扰物")
|
||
<< QStringLiteral("镀金零件")
|
||
<< QStringLiteral("非镀金零件");
|
||
}
|
||
else if (m_numClasses == 2) { // 兼容旧2类模型
|
||
m_classNames << QStringLiteral("镀金零件")
|
||
<< QStringLiteral("非镀金零件");
|
||
}
|
||
else {
|
||
for (int i = 0; i < m_numClasses; ++i)
|
||
m_classNames << QString("class%1").arg(i);
|
||
}
|
||
}
|
||
|
||
qDebug() << "[YoloDetector] model loaded:" << onnxPath
|
||
<< " input:" << m_inputW << "x" << m_inputH
|
||
<< " classes:" << m_numClasses;
|
||
|
||
emit modelLoaded(onnxPath);
|
||
return true;
|
||
}
|
||
catch (const Ort::Exception& e) {
|
||
QString msg = QString("[YoloDetector] ORT exception: %1").arg(e.what());
|
||
qWarning() << msg;
|
||
emit errorOccurred(msg);
|
||
}
|
||
catch (const std::exception& e) {
|
||
QString msg = QString("[YoloDetector] std::exception: %1").arg(e.what());
|
||
qWarning() << msg;
|
||
emit errorOccurred(msg);
|
||
}
|
||
return false;
|
||
}
|
||
|
||
// ── setClassNames ────────────────────────────────────────────────────────────
|
||
void YoloDetector::setClassNames(const QStringList& names)
|
||
{
|
||
m_classNames = names;
|
||
m_numClasses = names.size();
|
||
}
|
||
|
||
// ── preprocess ───────────────────────────────────────────────────────────────
|
||
std::vector<float> YoloDetector::preprocess(
|
||
const QImage& img, int targetW, int targetH)
|
||
{
|
||
// Smooth scaling may change RGB888 to RGB32. Convert AFTER scaling so
|
||
// the tensor loop always reads three-byte RGB pixels, including live frames.
|
||
QImage resized = img.scaled(targetW, targetH,
|
||
Qt::IgnoreAspectRatio,
|
||
Qt::SmoothTransformation).convertToFormat(QImage::Format_RGB888);
|
||
|
||
std::vector<float> data(static_cast<size_t>(3 * targetH * targetW));
|
||
const size_t planeSize = static_cast<size_t>(targetH * targetW);
|
||
|
||
for (int y = 0; y < targetH; ++y) {
|
||
const uchar* line = resized.constScanLine(y);
|
||
for (int x = 0; x < targetW; ++x) {
|
||
size_t idx = static_cast<size_t>(y * targetW + x);
|
||
data[0 * planeSize + idx] = line[x * 3 + 0] / 255.f; // R
|
||
data[1 * planeSize + idx] = line[x * 3 + 1] / 255.f; // G
|
||
data[2 * planeSize + idx] = line[x * 3 + 2] / 255.f; // B
|
||
}
|
||
}
|
||
return data;
|
||
}
|
||
|
||
// ── NMS (Non-Maximum Suppression) ────────────────────────────────────────────
|
||
QVector<YoloResult> YoloDetector::nms(QVector<YoloResult>& candidates, float iouThresh)
|
||
{
|
||
QVector<YoloResult> keep;
|
||
if (candidates.isEmpty()) return keep;
|
||
|
||
// Sort by confidence descending
|
||
std::sort(candidates.begin(), candidates.end(),
|
||
[](const YoloResult& a, const YoloResult& b) {
|
||
return a.conf > b.conf;
|
||
});
|
||
|
||
QVector<bool> suppressed(candidates.size(), false);
|
||
for (int i = 0; i < candidates.size(); ++i) {
|
||
if (suppressed[i]) continue;
|
||
keep.append(candidates[i]);
|
||
|
||
for (int j = i + 1; j < candidates.size(); ++j) {
|
||
if (suppressed[j] || candidates[i].classId != candidates[j].classId)
|
||
continue;
|
||
|
||
// Calculate IoU
|
||
const QRectF& a = candidates[i].box;
|
||
const QRectF& b = candidates[j].box;
|
||
float interX1 = std::max(a.left(), b.left());
|
||
float interY1 = std::max(a.top(), b.top());
|
||
float interX2 = std::min(a.right(), b.right());
|
||
float interY2 = std::min(a.bottom(), b.bottom());
|
||
|
||
float interArea = std::max(0.f, interX2 - interX1) * std::max(0.f, interY2 - interY1);
|
||
float aArea = a.width() * a.height();
|
||
float bArea = b.width() * b.height();
|
||
float iou = interArea / (aArea + bArea - interArea);
|
||
|
||
if (iou > iouThresh)
|
||
suppressed[j] = true;
|
||
}
|
||
}
|
||
return keep;
|
||
}
|
||
|
||
// ── postprocess ──────────────────────────────────────────────────────────────
|
||
QVector<YoloResult> YoloDetector::postprocess(
|
||
const float* data, int numAnchors, int numFields,
|
||
int origW, int origH, float confThresh, float nmsThresh, int filterClass)
|
||
{
|
||
int nc = numFields - 4;
|
||
if (nc <= 0) return {};
|
||
|
||
const float scaleW = static_cast<float>(origW) / m_inputW;
|
||
const float scaleH = static_cast<float>(origH) / m_inputH;
|
||
|
||
// ── Decode candidates ────────────────────────────────────────────────────
|
||
QVector<YoloResult> candidates;
|
||
candidates.reserve(256);
|
||
|
||
for (int a = 0; a < numAnchors; ++a) {
|
||
// Find the highest-scoring class
|
||
int bestClass = -1;
|
||
float bestScore = confThresh;
|
||
for (int c = 0; c < nc; ++c) {
|
||
float score = data[(4 + c) * numAnchors + a];
|
||
if (score > bestScore) { bestScore = score; bestClass = c; }
|
||
}
|
||
if (bestClass < 0) continue;
|
||
if (filterClass >= 0 && bestClass != filterClass) continue;
|
||
|
||
float cx = data[0 * numAnchors + a];
|
||
float cy = data[1 * numAnchors + a];
|
||
float bw = data[2 * numAnchors + a];
|
||
float bh = data[3 * numAnchors + a];
|
||
|
||
float x1 = qBound(0.f, (cx - bw * 0.5f) * scaleW, (float)origW);
|
||
float y1 = qBound(0.f, (cy - bh * 0.5f) * scaleH, (float)origH);
|
||
float x2 = qBound(0.f, (cx + bw * 0.5f) * scaleW, (float)origW);
|
||
float y2 = qBound(0.f, (cy + bh * 0.5f) * scaleH, (float)origH);
|
||
|
||
YoloResult res;
|
||
res.box = QRectF(x1, y1, x2 - x1, y2 - y1);
|
||
res.classId = bestClass;
|
||
res.conf = bestScore;
|
||
res.label = m_classNames.value(bestClass, QString("class%1").arg(bestClass));
|
||
candidates.append(res);
|
||
}
|
||
|
||
// ── Apply NMS ────────────────────────────────────────────────────────────
|
||
return nms(candidates, nmsThresh);
|
||
}
|
||
|
||
// ── detect ───────────────────────────────────────────────────────────────────
|
||
QVector<YoloResult> YoloDetector::detect(
|
||
const QImage& img,
|
||
float confThresh, float nmsThresh, int filterClass)
|
||
{
|
||
if (!m_loaded || !m_ort || !m_ort->session) {
|
||
emit errorOccurred("YOLO model not loaded");
|
||
return {};
|
||
}
|
||
if (img.isNull()) return {};
|
||
|
||
const int origW = img.width();
|
||
const int origH = img.height();
|
||
|
||
try {
|
||
// ── Pre-process ─────────────────────────────────────────────────────
|
||
auto inputData = preprocess(img, m_inputW, m_inputH);
|
||
|
||
std::vector<int64_t> inputShape = { 1, 3,
|
||
static_cast<int64_t>(m_inputH),
|
||
static_cast<int64_t>(m_inputW) };
|
||
|
||
Ort::MemoryInfo memInfo =
|
||
Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
|
||
|
||
Ort::Value inputTensor = Ort::Value::CreateTensor<float>(
|
||
memInfo,
|
||
inputData.data(), inputData.size(),
|
||
inputShape.data(), inputShape.size());
|
||
|
||
// ── Inference ───────────────────────────────────────────────────────
|
||
auto outputs = m_ort->session->Run(
|
||
Ort::RunOptions{ nullptr },
|
||
m_ort->inputNamePtrs.data(), &inputTensor, 1,
|
||
m_ort->outputNamePtrs.data(), m_ort->outputNamePtrs.size());
|
||
|
||
// ── Post-process ────────────────────────────────────────────────────
|
||
const float* outData = outputs[0].GetTensorData<float>();
|
||
auto outShape = outputs[0].GetTensorTypeAndShapeInfo().GetShape();
|
||
|
||
// Expected layout: [1, 4+nc, num_anchors]
|
||
if (outShape.size() < 3) {
|
||
emit errorOccurred("Unexpected output shape");
|
||
return {};
|
||
}
|
||
int numFields = static_cast<int>(outShape[1]); // 4 + nc
|
||
int numAnchors = static_cast<int>(outShape[2]);
|
||
|
||
return postprocess(outData, numAnchors, numFields,
|
||
origW, origH, confThresh, nmsThresh, filterClass);
|
||
}
|
||
catch (const Ort::Exception& e) {
|
||
emit errorOccurred(QString("ORT inference error: %1").arg(e.what()));
|
||
}
|
||
catch (const std::exception& e) {
|
||
emit errorOccurred(QString("Detect error: %1").arg(e.what()));
|
||
}
|
||
return {};
|
||
}
|
||
|
||
// ── detectAndDraw ────────────────────────────────────────────────────────────
|
||
QImage YoloDetector::detectAndDraw(const QImage& img,
|
||
float confThresh, float nmsThresh, int filterClass)
|
||
{
|
||
QImage result = img.copy();
|
||
auto detections = detect(img, confThresh, nmsThresh, filterClass);
|
||
|
||
QPainter painter(&result);
|
||
painter.setRenderHint(QPainter::Antialiasing);
|
||
|
||
// Define colors for different classes (extend as needed)
|
||
QVector<QColor> colors = {
|
||
QColor(255, 0, 0), // Class 0: Red (镀金零件)
|
||
QColor(0, 255, 0), // Class 1: Green (非镀金零件)
|
||
QColor(0, 0, 255), // Class 2: Blue
|
||
QColor(255, 255, 0), // Class 3: Yellow
|
||
QColor(255, 0, 255) // Class 4: Magenta
|
||
};
|
||
|
||
for (const auto& res : detections) {
|
||
QColor color = colors[res.classId % colors.size()];
|
||
painter.setPen(QPen(color, 2));
|
||
painter.drawRect(res.box);
|
||
|
||
// Draw label + confidence
|
||
QString label = QString("%1 (%.2f)").arg(res.label).arg(res.conf);
|
||
QFont font = painter.font();
|
||
font.setBold(true);
|
||
painter.setFont(font);
|
||
|
||
QRectF textRect = painter.boundingRect(
|
||
QRectF(res.box.topLeft(), QSizeF(200, 30)),
|
||
Qt::AlignLeft | Qt::AlignTop, label);
|
||
textRect.adjust(-2, -2, 2, 2);
|
||
painter.fillRect(textRect, color);
|
||
painter.setPen(Qt::white);
|
||
painter.drawText(res.box.topLeft() + QPointF(2, 12), label);
|
||
}
|
||
|
||
return result;
|
||
}
|