Files
ssp/services/visionservice.cpp
T

607 lines
24 KiB
C++
Raw Normal View History

2026-10-27 22:16:55 +08:00
#include "visionservice.h"
2026-11-12 09:26:26 +08:00
#include "visiondllworker.h"
2026-10-27 22:16:55 +08:00
#include <QDateTime>
#include <QJsonArray>
2026-11-12 09:26:26 +08:00
#include <QMetaObject>
#include <QThread>
2026-10-27 22:16:55 +08:00
#include <QTimer>
#include <QUuid>
#include <cmath>
namespace {
2026-11-12 09:26:26 +08:00
QString newId()
{
return QUuid::createUuid().toString(QUuid::WithoutBraces);
}
2026-10-27 22:16:55 +08:00
bool validPose(const QJsonValue &value)
{
2026-11-12 09:26:26 +08:00
if (!value.isArray() || value.toArray().size() != 6) return false;
2026-10-27 22:16:55 +08:00
for (const QJsonValue &axis : value.toArray()) {
2026-11-12 09:26:26 +08:00
if (!axis.isDouble() || !std::isfinite(axis.toDouble())) return false;
2026-10-27 22:16:55 +08:00
}
return true;
}
bool nonnegativeInteger(const QJsonValue &value)
{
return value.isDouble() && std::isfinite(value.toDouble())
&& value.toDouble() >= 0 && std::floor(value.toDouble()) == value.toDouble();
}
2026-11-12 09:26:26 +08:00
QString epochToIso(const QJsonValue &value)
{
if (!value.isDouble() || !std::isfinite(value.toDouble())) return QString();
return QDateTime::fromMSecsSinceEpoch(qint64(value.toDouble()), Qt::UTC)
.toString(Qt::ISODateWithMs);
}
2026-10-27 22:16:55 +08:00
}
VisionService::VisionService(const VisionConfig &config, QObject *parent)
2026-11-12 09:26:26 +08:00
: QObject(parent), m_config(config), m_thread(new QThread(this))
, m_worker(new VisionDllWorker), m_requestTimer(new QTimer(this))
, m_avoidanceTimer(new QTimer(this)), m_avoidanceTimeout(new QTimer(this))
2026-10-27 22:16:55 +08:00
{
qRegisterMetaType<QJsonObject>("QJsonObject");
m_requestTimer->setSingleShot(true);
2026-11-12 09:26:26 +08:00
m_avoidanceTimer->setSingleShot(true);
m_avoidanceTimeout->setSingleShot(true);
connect(m_avoidanceTimer, &QTimer::timeout, this, &VisionService::pollAvoidance);
connect(m_avoidanceTimeout, &QTimer::timeout, this, [this]() {
if (m_avoidanceRequestId.isEmpty()) return;
m_avoidanceDiscarded = true;
m_worker->cancelOperation(m_avoidanceRequestId);
logAvoidance("ERROR", "避障检测超时,等待 DLL 结束本次操作后重试");
2026-10-27 22:16:55 +08:00
});
2026-11-12 09:26:26 +08:00
m_worker->moveToThread(m_thread);
connect(m_thread, &QThread::finished, m_worker, &QObject::deleteLater);
connect(m_worker, &VisionDllWorker::sdkLoaded,
this, &VisionService::onSdkLoaded, Qt::QueuedConnection);
connect(m_worker, &VisionDllWorker::devicesInitialized,
this, &VisionService::onDevicesInitialized, Qt::QueuedConnection);
connect(m_worker, &VisionDllWorker::operationCompleted,
this, &VisionService::onOperationCompleted, Qt::QueuedConnection);
connect(m_worker, &VisionDllWorker::released,
this, &VisionService::onReleased, Qt::QueuedConnection);
connect(m_worker, &VisionDllWorker::logMessage,
this, &VisionService::logMessage, Qt::QueuedConnection);
2026-10-27 22:16:55 +08:00
connect(m_requestTimer, &QTimer::timeout, this, [this]() {
const QString id = m_request.value("request_id").toString();
2026-11-12 09:26:26 +08:00
if (id.isEmpty()) return;
m_cancelledRequests.insert(id);
QString cancelError;
m_worker->cancelOperation(id, &cancelError);
if (!cancelError.isEmpty()) emit logMessage(cancelError);
failRequest("CLIENT_TIMEOUT", "视觉识别等待超时,本次结果已作废");
2026-10-27 22:16:55 +08:00
});
2026-11-12 09:26:26 +08:00
m_thread->start();
2026-10-27 22:16:55 +08:00
}
VisionService::~VisionService()
{
shutdown();
2026-11-12 09:26:26 +08:00
if (m_thread->isRunning()) m_thread->wait();
2026-10-27 22:16:55 +08:00
}
QJsonObject VisionService::standardParameters()
{
return {{"camera_mode", "left_only"}, {"refinement", "least_squares_high"},
2026-11-12 09:26:26 +08:00
{"deadline_ms", 30000}, {"min_score", 0.70}, {"greediness", 0.80},
2026-10-27 22:16:55 +08:00
{"yolo_selection", "center"}, {"pose_display", "model_origin"},
{"grasp_offset_mm", 4.40}};
}
QJsonObject VisionService::standardConvention()
{
2026-11-12 09:26:26 +08:00
return {{"frame", "world"}, {"tool", "TOOL1"},
{"rotation", "Rz(A)Ry(B)Rx(C)"}, {"linear_unit", "mm"},
{"angular_unit", "deg"}};
}
bool VisionService::isEnabled() const
{
return m_config.enabled;
}
bool VisionService::isReady() const
{
return isEnabled() && m_ready && !m_session.isEmpty();
}
bool VisionService::isBusy() const
{
return m_loading || m_initializing || m_releasing || m_workerBusy
|| !m_avoidanceRequestId.isEmpty();
2026-10-27 22:16:55 +08:00
}
bool VisionService::canInitialize() const
{
2026-11-12 09:26:26 +08:00
return isEnabled() && !m_session.isEmpty() && !isBusy()
&& (!m_productionActive || m_maintenanceAllowed);
}
2026-10-27 22:16:55 +08:00
2026-11-12 09:26:26 +08:00
QString VisionService::sessionId() const
2026-10-27 22:16:55 +08:00
{
2026-11-12 09:26:26 +08:00
return m_session;
2026-10-29 18:21:27 +08:00
}
2026-11-12 09:26:26 +08:00
void VisionService::startService()
2026-10-29 18:21:27 +08:00
{
2026-11-12 09:26:26 +08:00
if (m_shuttingDown) return;
if (!isEnabled()) {
emit operationFeedback("start", "info", "视觉功能未启用(vision/enabled=false)");
return;
}
m_avoidanceEnabled = true;
m_avoidanceTimer->start(0);
2026-10-29 18:21:27 +08:00
if (!m_session.isEmpty()) {
2026-11-12 09:26:26 +08:00
emit operationFeedback("start", "success", "视觉 DLL 已加载");
2026-10-29 18:21:27 +08:00
return;
}
2026-11-12 09:26:26 +08:00
if (isBusy()) {
emit operationFeedback("start", "info", "视觉 DLL 正在处理其他操作");
2026-10-27 22:16:55 +08:00
return;
2026-10-29 18:21:27 +08:00
}
2026-11-12 09:26:26 +08:00
m_loading = true;
publishAvailability();
QMetaObject::invokeMethod(m_worker, "loadSdk", Qt::QueuedConnection,
Q_ARG(QString, m_config.sdkRoot),
Q_ARG(int, m_config.initializeTimeoutMs));
2026-10-27 22:16:55 +08:00
}
2026-11-12 09:26:26 +08:00
void VisionService::onSdkLoaded(bool success, const QJsonObject &status,
const QString &message)
2026-10-27 22:16:55 +08:00
{
2026-11-12 09:26:26 +08:00
m_loading = false;
if (m_releasing || m_shuttingDown) return;
if (success) {
m_session = newId();
emit statusChanged(status);
2026-10-29 18:21:27 +08:00
emit logMessage(message);
2026-11-12 09:26:26 +08:00
emit operationFeedback("start", "success", message);
} else {
m_session.clear();
m_ready = false;
emit logMessage(message);
emit operationFeedback("start", "error", message);
2026-10-29 18:21:27 +08:00
}
2026-11-12 09:26:26 +08:00
publishAvailability();
if (m_avoidanceEnabled) {
if (!success) logAvoidance("ERROR", "避障检测未启动:" + message);
m_avoidanceTimer->start(success ? 0 : 5000);
2026-10-27 22:16:55 +08:00
}
}
2026-11-12 09:26:26 +08:00
void VisionService::initialize()
2026-10-27 22:16:55 +08:00
{
2026-11-12 09:26:26 +08:00
if (!canInitialize()) {
const QString message = !isEnabled() ? "视觉功能未启用(vision/enabled=false)"
: "初始化需要 DLL 已加载、资源空闲且生产已停止";
emit logMessage(message);
emit operationFeedback("initialize", "error", message);
return;
}
m_ready = false;
m_initializing = true;
publishAvailability();
QMetaObject::invokeMethod(m_worker, "initializeDevices", Qt::QueuedConnection,
Q_ARG(int, m_config.initializeTimeoutMs));
2026-10-29 18:21:27 +08:00
}
2026-11-12 09:26:26 +08:00
void VisionService::onDevicesInitialized(bool success, const QJsonObject &status,
const QString &message)
2026-10-29 18:21:27 +08:00
{
2026-11-12 09:26:26 +08:00
m_initializing = false;
if (m_releasing || m_shuttingDown) return;
m_ready = success;
if (!status.isEmpty()) emit statusChanged(status);
emit logMessage(message);
emit operationFeedback("initialize", success ? "success" : "error", message);
publishAvailability();
if (m_avoidanceEnabled) {
if (!success) logAvoidance("ERROR", "避障设备初始化失败:" + message);
m_avoidanceTimer->start(success ? 0 : 5000);
}
2026-10-29 11:57:47 +08:00
}
2026-11-12 09:26:26 +08:00
void VisionService::pollAvoidance()
2026-10-29 11:57:47 +08:00
{
2026-11-12 09:26:26 +08:00
if (!isEnabled() || !m_avoidanceEnabled || m_shuttingDown || m_releasing) return;
if (!std::isfinite(m_config.warningDistanceMm)
|| m_config.warningDistanceMm < 1 || m_config.warningDistanceMm > 5000) {
logAvoidance("ERROR", "避障配置无效:vision/warningDistanceMm 必须在 1~5000 mm 范围内");
2026-10-27 22:16:55 +08:00
return;
2026-11-12 09:26:26 +08:00
}
if (isBusy()) {
m_avoidanceTimer->start(500);
2026-10-27 22:16:55 +08:00
return;
}
2026-11-12 09:26:26 +08:00
if (m_session.isEmpty()) {
startService();
return;
2026-10-27 22:16:55 +08:00
}
2026-11-12 09:26:26 +08:00
if (!isReady()) {
// Automatic camera recovery does not send PLC or robot commands.
m_initializing = true;
publishAvailability();
QMetaObject::invokeMethod(m_worker, "initializeDevices", Qt::QueuedConnection,
Q_ARG(int, m_config.initializeTimeoutMs));
2026-10-27 22:16:55 +08:00
return;
}
2026-11-12 09:26:26 +08:00
m_avoidanceRequestId = newId();
m_avoidanceDiscarded = false;
const QJsonObject request{{"request_id", m_avoidanceRequestId}, {"input_source", "camera"},
{"threshold_mm", m_config.warningDistanceMm}, {"max_time_ms", m_config.requestTimeoutMs}};
publishAvailability();
QMetaObject::invokeMethod(m_worker, "planAvoidance", Qt::QueuedConnection,
Q_ARG(QJsonObject, request));
m_avoidanceTimeout->start(m_config.requestTimeoutMs);
2026-10-27 22:16:55 +08:00
}
2026-11-12 09:26:26 +08:00
void VisionService::finishAvoidance(int code, const QJsonObject &result)
2026-10-27 22:16:55 +08:00
{
2026-11-12 09:26:26 +08:00
m_avoidanceTimeout->stop();
const QString requestId = m_avoidanceRequestId;
m_avoidanceRequestId.clear();
if (!m_avoidanceDiscarded && m_avoidanceEnabled && !m_shuttingDown && !m_releasing) {
const double distance = result.value("distance_mm").toDouble();
const bool warning = distance < m_config.warningDistanceMm;
2026-11-12 14:39:30 +08:00
if (code == HVG_DISTANCE_UNKNOWN) {
m_avoidanceLogKey.clear();
} else if (code != HVG_OK) {
2026-11-12 09:26:26 +08:00
logAvoidance("ERROR", QString("避障检测失败(code=%1):%2")
.arg(code).arg(result.value("message").toString()));
if (code == HVG_NOT_READY || code == HVG_DEVICE_ERROR || code == HVG_CONFIG_ERROR)
m_ready = false;
} else if (result.value("schema_version").toDouble() != 1
|| !result.value("success").toBool()
|| !result.value("code").isDouble() || result.value("code").toDouble() != HVG_OK
|| result.value("request_id").toString() != requestId
|| !result.value("distance_valid").toBool()
|| !result.value("distance_mm").isDouble() || !std::isfinite(distance) || distance <= 0
|| result.value("threshold_mm").toDouble() != m_config.warningDistanceMm
|| !result.value("warning").isBool() || result.value("warning").toBool() != warning
|| result.value("state").toString() != (warning ? "WARNING" : "SAFE")) {
logAvoidance("ERROR", "避障检测结果无效,距离或状态不可用");
} else {
logAvoidance(warning ? "WARNING" : "SAFE", QString("%1:距离 %2 mm,预警阈值 %3 mm")
.arg(warning ? "避障距离预警" : "避障距离安全")
.arg(distance, 0, 'f', 2).arg(m_config.warningDistanceMm, 0, 'f', 2));
}
2026-10-27 22:16:55 +08:00
}
2026-11-12 09:26:26 +08:00
publishAvailability();
if (m_avoidanceEnabled && !m_shuttingDown && !m_releasing)
m_avoidanceTimer->start(isReady() ? 500 : 5000);
2026-10-27 22:16:55 +08:00
}
2026-11-12 09:26:26 +08:00
void VisionService::logAvoidance(const QString &state, const QString &message)
2026-10-27 22:16:55 +08:00
{
2026-11-12 09:26:26 +08:00
const QString key = state == "ERROR" ? state + message : state;
if (key == m_avoidanceLogKey) return;
m_avoidanceLogKey = key;
emit avoidanceLog(state == "WARNING" ? "预警" : state == "SAFE" ? "安全" : "失败", message);
2026-10-27 22:16:55 +08:00
}
2026-11-12 09:26:26 +08:00
void VisionService::measure(const QJsonObject &request)
2026-10-27 22:16:55 +08:00
{
2026-11-12 09:26:26 +08:00
requestOperation(request, false);
2026-10-27 22:16:55 +08:00
}
2026-11-12 09:26:26 +08:00
void VisionService::recognizeGrooves(const QJsonObject &request)
2026-10-27 22:16:55 +08:00
{
2026-11-12 09:26:26 +08:00
requestOperation(request, false, true);
2026-10-27 22:16:55 +08:00
}
2026-11-12 09:26:26 +08:00
void VisionService::diagnose(const QJsonObject &request)
2026-10-27 22:16:55 +08:00
{
2026-11-12 09:26:26 +08:00
requestOperation(request, true);
2026-10-27 22:16:55 +08:00
}
2026-11-12 09:26:26 +08:00
void VisionService::requestOperation(QJsonObject request, bool diagnostic, bool grooves)
2026-10-27 22:16:55 +08:00
{
2026-11-12 09:26:26 +08:00
const QString type = grooves ? "recognize_grooves" : "measure";
2026-10-27 22:16:55 +08:00
const QString id = request.value("request_id").toString();
2026-11-12 09:26:26 +08:00
if (!id.isEmpty() && (m_completedRequests.contains(id) || m_activeWorkerRequest == id)) {
2026-10-27 22:16:55 +08:00
emit logMessage("忽略重复的视觉请求编号:" + id);
return;
}
2026-11-12 09:26:26 +08:00
2026-10-27 22:16:55 +08:00
QString error;
const QJsonObject context = request.value("context").toObject();
const double tray = context.value("tray_no").toDouble();
2026-11-12 09:26:26 +08:00
if (!isEnabled()) error = "视觉功能未启用(vision/enabled=false)";
else if (id.isEmpty() || m_cancelledRequests.contains(id)) error = "请求编号为空或已取消";
else if (!isReady() || m_loading || m_initializing || m_releasing || m_workerBusy)
error = "视觉 DLL 未就绪或仍在处理上一任务";
else if (m_maintenanceAllowed) error = "视觉维护期间只允许初始化";
2026-10-27 22:16:55 +08:00
else if (diagnostic == m_productionActive) error = "诊断与自动生产不可同时执行";
2026-11-12 09:26:26 +08:00
else if (!diagnostic && request.value("server_session_id").toString() != m_session)
error = "生产请求会话已失效";
else if (!grooves && !validPose(request.value("robot_pose"))) error = "拍照位姿须为6个有限数值";
2026-10-27 22:16:55 +08:00
else if (context.value("workpiece_id").toString().isEmpty()
|| context.value("task_id").toString().isEmpty()
|| context.value("generation").toString().isEmpty()
2026-11-12 09:26:26 +08:00
|| tray < 1 || tray > 99 || std::floor(tray) != tray)
error = "工件/任务/料盘上下文无效";
else if (!grooves && (request.value("parameters").toObject() != standardParameters()
|| request.value("convention").toObject() != standardConvention()))
error = "测量参数或机器人坐标约定不匹配";
else if (!grooves && (!request.value("require_robot_pose").toBool()
2026-10-27 22:16:55 +08:00
|| request.value("pose_source").toString() != (diagnostic ? "diagnostic" : "plc_r40")
2026-11-12 09:26:26 +08:00
|| !QDateTime::fromString(request.value("pose_read_at").toString(), Qt::ISODate).isValid()))
error = "拍照位姿来源或采集时间无效";
2026-10-27 22:16:55 +08:00
if (!error.isEmpty()) {
if (!id.isEmpty()) m_completedRequests.insert(id);
QJsonObject result = request;
2026-11-12 09:26:26 +08:00
result.insert("type", type);
2026-10-27 22:16:55 +08:00
result.insert("status", "error");
result.insert("error_code", "REQUEST_REJECTED");
result.insert("message", error);
2026-11-12 09:26:26 +08:00
result.insert("camera_valid", false);
2026-10-27 22:16:55 +08:00
result.insert("robot_valid", false);
2026-11-12 09:26:26 +08:00
result.insert("occupancy_valid", false);
if (grooves) emit groovesRecognized(result);
else emit measurementFinished(result);
2026-10-27 22:16:55 +08:00
emit logMessage(error);
return;
}
2026-11-12 09:26:26 +08:00
2026-10-27 22:16:55 +08:00
request.insert("protocol_version", 1);
2026-11-12 09:26:26 +08:00
request.insert("type", type);
2026-10-27 22:16:55 +08:00
request.insert("server_session_id", m_session);
m_request = request;
m_diagnostic = diagnostic;
2026-11-12 09:26:26 +08:00
m_workerBusy = true;
m_activeWorkerRequest = id;
// Foreground recognition takes priority; the worker queues it after the current DLL call.
if (!m_avoidanceRequestId.isEmpty()) {
m_avoidanceDiscarded = true;
m_avoidanceTimeout->stop();
m_worker->cancelOperation(m_avoidanceRequestId);
}
if (!grooves) emit requestStarted(request);
2026-10-27 22:16:55 +08:00
publishAvailability();
2026-11-12 09:26:26 +08:00
QMetaObject::invokeMethod(m_worker, grooves ? "recognizeGrooves" : "measure", Qt::QueuedConnection,
Q_ARG(QJsonObject, dllRequest(request)));
m_requestTimer->start(m_config.requestTimeoutMs);
}
QJsonObject VisionService::dllRequest(const QJsonObject &request) const
{
if (request.value("type").toString() == "recognize_grooves") {
return {{"request_id", request.value("request_id")}, {"mode", "occupancy"},
{"input_source", "camera"}, {"camera", "left"},
{"confidence", 0.25}, {"nms", 0.45},
{"max_time_ms", m_config.requestTimeoutMs}};
}
const QJsonObject parameters = request.value("parameters").toObject();
const QJsonObject context = request.value("context").toObject();
return {
{"request_id", request.value("request_id")}, {"input_source", "camera"},
{"camera_mode", "left"}, {"max_time_ms", parameters.value("deadline_ms")},
{"refinement", "high"}, {"min_score", parameters.value("min_score")},
{"greediness", parameters.value("greediness")}, {"target_selection", 0},
{"grasp_offset_mm", parameters.value("grasp_offset_mm")},
{"tray_id", context.value("tray_no")}, {"z_strategy", "plane_xy"},
{"compute_grasp", true},
{"robot_pose_at_capture", QJsonObject{
{"XYZABC_mm_deg", request.value("robot_pose")}, {"frame_id", "world"},
{"tool_id", "TOOL1"}, {"capture_pose_confirmed", true},
{"source", request.value("pose_source")}
}}
};
}
QJsonObject VisionService::adaptResult(int code, const QJsonObject &dllResult) const
{
QJsonObject result = m_request;
result.insert("type", "measure");
result.insert("status", code == HVG_OK ? "ok" : code == HVG_TIMEOUT ? "timeout"
: code == HVG_CANCELLED ? "cancelled" : "error");
result.insert("error_code", code);
result.insert("message", dllResult.value("message"));
result.insert("camera_valid", dllResult.value("vision_valid"));
result.insert("robot_valid", dllResult.value("grasp_valid"));
result.insert("camera_pose", dllResult.value("object_pose_camera").toObject()
.value("XYZABC_mm_deg"));
result.insert("robot_pose", dllResult.value("robot_grasp_pose").toObject()
.value("XYZABC_mm_deg"));
result.insert("source", dllResult.value("actual_source"));
result.insert("score", dllResult.value("score"));
result.insert("config_revision", dllResult.value("config_revision"));
result.insert("run_id", dllResult.value("run_id"));
result.insert("elapsed_ms", dllResult.value("elapsed_ms"));
const QJsonObject capture = dllResult.value("capture").toObject();
result.insert("capture_begin", epochToIso(capture.value("begin_epoch_ms")));
result.insert("capture_end", epochToIso(capture.value("end_epoch_ms")));
return result;
}
void VisionService::onOperationCompleted(const QString &requestId, int code,
const QJsonObject &dllResult)
{
if (!m_avoidanceRequestId.isEmpty() && requestId == m_avoidanceRequestId) {
finishAvoidance(code, dllResult);
return;
}
if (requestId != m_activeWorkerRequest) return;
m_activeWorkerRequest.clear();
m_workerBusy = false;
if (code == HVG_NOT_READY || code == HVG_DEVICE_ERROR || code == HVG_CONFIG_ERROR)
m_ready = false;
if (m_request.isEmpty() || m_cancelledRequests.contains(requestId)) {
publishAvailability();
return;
}
if (m_request.value("type").toString() == "recognize_grooves") {
if (code != HVG_OK) {
failRequest(QString::number(code), "凹槽识别调用失败:" + dllResult.value("message").toString());
return;
}
if (dllResult.value("schema_version").toDouble() != 1
|| !dllResult.value("success").toBool()
|| !dllResult.value("code").isDouble() || dllResult.value("code").toDouble() != HVG_OK
|| dllResult.value("request_id").toString() != requestId
|| !dllResult.value("vision_valid").toBool()
|| !dllResult.value("occupancy_valid").toBool()
|| !dllResult.value("grooves").isArray()) {
failRequest("INVALID_RESULT", "凹槽识别结果无效,禁止放料");
return;
}
QJsonObject result = m_request;
result.insert("status", "ok");
result.insert("occupancy_valid", true);
result.insert("grooves", dllResult.value("grooves"));
finishRequest(result);
2026-10-27 22:16:55 +08:00
return;
}
2026-11-12 09:26:26 +08:00
const QJsonObject result = adaptResult(code, dllResult);
if (code == HVG_OK) {
QString error;
if (!validateResult(result, &error)) {
failRequest("INVALID_RESULT", error);
return;
}
}
finishRequest(result);
2026-10-27 22:16:55 +08:00
}
bool VisionService::validateResult(const QJsonObject &result, QString *error) const
{
const QDateTime begin = QDateTime::fromString(result.value("capture_begin").toString(), Qt::ISODate);
const QDateTime end = QDateTime::fromString(result.value("capture_end").toString(), Qt::ISODate);
const bool valid = result.value("context").toObject() == m_request.value("context").toObject()
2026-11-12 09:26:26 +08:00
&& result.value("camera_valid").toBool() && result.value("robot_valid").toBool()
2026-10-27 22:16:55 +08:00
&& validPose(result.value("camera_pose")) && validPose(result.value("robot_pose"))
&& result.value("source").toString() == "LEFT"
&& result.value("parameters").toObject() == m_request.value("parameters").toObject()
&& result.value("convention").toObject() == m_request.value("convention").toObject()
&& result.value("score").isDouble() && std::isfinite(result.value("score").toDouble())
&& result.value("score").toDouble() >= 0.70 && result.value("score").toDouble() <= 1.0
2026-11-12 09:26:26 +08:00
&& !result.value("config_revision").toString().isEmpty()
2026-10-27 22:16:55 +08:00
&& !result.value("run_id").toString().isEmpty()
&& begin.isValid() && end.isValid() && begin <= end
2026-11-12 09:26:26 +08:00
&& nonnegativeInteger(result.value("elapsed_ms"));
if (!valid && error)
*error = "视觉结果坐标、上下文、参数或有效性校验失败,禁止提交机器人";
2026-10-27 22:16:55 +08:00
return valid;
}
void VisionService::cancel(const QString &requestId)
{
if (requestId.isEmpty()) return;
m_cancelledRequests.insert(requestId);
2026-11-12 09:26:26 +08:00
if (m_activeWorkerRequest != requestId) return;
QString error;
m_worker->cancelOperation(requestId, &error);
if (!error.isEmpty()) emit logMessage(error);
failRequest("CANCELLED", "本次视觉结果已取消,等待 DLL 释放底层资源");
2026-10-27 22:16:55 +08:00
}
void VisionService::setProductionActive(bool active, bool maintenanceAllowed)
2026-10-27 22:16:55 +08:00
{
m_productionActive = active;
m_maintenanceAllowed = active && maintenanceAllowed;
2026-11-12 09:26:26 +08:00
if (!m_request.isEmpty()
&& (m_maintenanceAllowed || (active && m_diagnostic) || (!active && !m_diagnostic)))
2026-10-27 22:16:55 +08:00
cancel(m_request.value("request_id").toString());
publishAvailability();
}
2026-11-12 09:26:26 +08:00
void VisionService::disconnectService()
2026-10-27 22:16:55 +08:00
{
2026-11-12 09:26:26 +08:00
if (m_productionActive && !m_maintenanceAllowed) {
const QString message = "请先停止生产,再释放视觉资源";
emit logMessage(message);
emit operationFeedback("disconnect", "error", message);
2026-10-29 18:21:27 +08:00
return;
}
2026-11-12 09:26:26 +08:00
beginRelease("disconnect");
}
void VisionService::beginRelease(const QString &operation)
{
m_avoidanceEnabled = false;
m_avoidanceTimer->stop();
m_avoidanceTimeout->stop();
m_avoidanceLogKey.clear();
if (!m_avoidanceRequestId.isEmpty()) {
m_avoidanceDiscarded = true;
m_worker->cancelOperation(m_avoidanceRequestId);
2026-10-29 18:21:27 +08:00
}
2026-11-12 09:26:26 +08:00
if (m_releasing) {
if (!operation.isEmpty()) emit operationFeedback(operation, "info", "视觉资源正在释放");
if (m_shuttingDown)
QMetaObject::invokeMethod(m_worker, "release", Qt::QueuedConnection,
Q_ARG(bool, true));
2026-10-29 18:21:27 +08:00
return;
}
2026-11-12 09:26:26 +08:00
if (!m_activeWorkerRequest.isEmpty()) cancel(m_activeWorkerRequest);
else m_worker->cancelActiveOperation();
m_requestTimer->stop();
m_ready = false;
m_session.clear();
m_releasing = true;
m_releaseOperation = operation;
publishAvailability();
QMetaObject::invokeMethod(m_worker, "release", Qt::QueuedConnection,
Q_ARG(bool, m_shuttingDown));
2026-10-27 22:16:55 +08:00
}
2026-11-12 09:26:26 +08:00
void VisionService::onReleased(bool success, const QString &message)
2026-10-27 22:16:55 +08:00
{
2026-11-12 09:26:26 +08:00
m_releasing = false;
m_workerBusy = false;
m_initializing = false;
m_loading = false;
m_activeWorkerRequest.clear();
m_request = QJsonObject();
2026-10-27 22:16:55 +08:00
m_ready = false;
m_session.clear();
2026-11-12 09:26:26 +08:00
const QString operation = m_releaseOperation;
m_releaseOperation.clear();
emit logMessage(message);
if (!operation.isEmpty())
emit operationFeedback(operation, success ? "success" : "error", message);
2026-10-27 22:16:55 +08:00
publishAvailability();
}
2026-11-12 09:26:26 +08:00
void VisionService::shutdown()
{
if (m_shuttingDown) return;
m_shuttingDown = true;
if (!m_thread->isRunning()) return;
beginRelease(QString());
}
void VisionService::failRequest(const QString &code, const QString &message)
2026-10-27 22:16:55 +08:00
{
if (m_request.isEmpty()) return;
QJsonObject result = m_request;
result.insert("status", "error");
result.insert("error_code", code);
result.insert("message", message);
result.insert("camera_valid", false);
result.insert("robot_valid", false);
2026-11-12 09:26:26 +08:00
result.insert("occupancy_valid", false);
finishRequest(result);
2026-10-27 22:16:55 +08:00
}
2026-11-12 09:26:26 +08:00
void VisionService::finishRequest(const QJsonObject &result)
2026-10-27 22:16:55 +08:00
{
m_requestTimer->stop();
2026-11-12 09:26:26 +08:00
const QString requestId = result.value("request_id").toString();
if (!requestId.isEmpty()) m_completedRequests.insert(requestId);
2026-10-27 22:16:55 +08:00
m_request = QJsonObject();
2026-11-12 09:26:26 +08:00
if (result.value("type").toString() == "recognize_grooves") emit groovesRecognized(result);
else emit measurementFinished(result);
2026-10-27 22:16:55 +08:00
publishAvailability();
}
void VisionService::publishAvailability()
{
emit availabilityChanged(isReady(), isBusy(), m_session);
}