- 程序启动后自动连接左右相机、应用参数并完成一次白平衡 - 测量请求到达时若相机未初始化成功,再初始化一次 - 重试成功继续同一测量请求,失败返回 INITIALIZATION 和 robot_valid=false - 初始化期间允许一个待处理测量请求,并支持取消 - IPC 状态增加 initialization_in_progress - 手动白平衡先失效初始化缓存并同步更新就绪状态 - 将带宽设置收口到 CameraManager,更新接入文档 验证:MSVC x64编译通过;启动重试8、IPC9、白平衡6、抓取7项测试通过
357 lines
11 KiB
C++
357 lines
11 KiB
C++
// CameraManager.cpp
|
|
#include "CameraManager.h"
|
|
#include "GalaxyRuntime.h"
|
|
#include <QDebug>
|
|
#include <cmath>
|
|
|
|
const QString CameraManager::LEFT_SN = "GCQ25060290";
|
|
const QString CameraManager::RIGHT_SN = "GCQ25060284";
|
|
|
|
// Helper: gxstring <-> QString
|
|
static QString gxToQString(const GxIAPICPP::gxstring& gs)
|
|
{
|
|
return QString::fromLocal8Bit(gs.c_str());
|
|
}
|
|
static GxIAPICPP::gxstring qToGxString(const QString& qs)
|
|
{
|
|
return GxIAPICPP::gxstring(qs.toLocal8Bit().constData());
|
|
}
|
|
|
|
// Helper: grab one frame, convert to QImage
|
|
static QImage grabOneFrame(CGXDevicePointer device, CGXStreamPointer stream, int timeoutMs)
|
|
{
|
|
CImageDataPointer imgData = stream->GetImage(timeoutMs);
|
|
if (imgData.IsNull()) return QImage();
|
|
if (imgData->GetStatus() != GX_FRAME_STATUS_SUCCESS) return QImage();
|
|
|
|
int w = (int)imgData->GetWidth();
|
|
int h = (int)imgData->GetHeight();
|
|
if (w <= 0 || h <= 0) return QImage();
|
|
|
|
// Bayer -> RGB24 conversion (SDK manages the output buffer)
|
|
void* rgbBuf = imgData->ConvertToRGB24(GX_BIT_0_7, GX_RAW2RGB_NEIGHBOUR, false);
|
|
if (!rgbBuf) return QImage();
|
|
|
|
// Deep copy - SDK owns the buffer, must copy before imgData is released
|
|
QImage img((const uchar*)rgbBuf, w, h, w * 3, QImage::Format_RGB888);
|
|
return img.copy();
|
|
}
|
|
|
|
// =====================================================================
|
|
// CaptureWorker
|
|
// =====================================================================
|
|
CaptureWorker::CaptureWorker(CGXDevicePointer dev)
|
|
: m_device(dev), m_running(false)
|
|
{
|
|
}
|
|
|
|
void CaptureWorker::startCapture()
|
|
{
|
|
CGXStreamPointer stream;
|
|
try {
|
|
stream = m_device->OpenStream(0);
|
|
stream->StartGrab();
|
|
m_device->GetRemoteFeatureControl()
|
|
->GetCommandFeature("AcquisitionStart")->Execute();
|
|
m_running.store(true);
|
|
|
|
while (m_running.load()) {
|
|
try {
|
|
QImage img = grabOneFrame(m_device, stream, 200);
|
|
if (img.isNull()) continue;
|
|
|
|
// Scale down for preview (5120 -> 512)
|
|
QImage preview = img.scaled(640, 640,
|
|
Qt::KeepAspectRatio, Qt::FastTransformation);
|
|
emit frameReady(preview);
|
|
}
|
|
catch (...) {
|
|
// skip bad frame
|
|
}
|
|
}
|
|
|
|
m_device->GetRemoteFeatureControl()
|
|
->GetCommandFeature("AcquisitionStop")->Execute();
|
|
stream->StopGrab();
|
|
stream->Close();
|
|
}
|
|
catch (CGalaxyException& e) {
|
|
emit errorOccurred(QString("Capture error: %1").arg(e.what()));
|
|
try {
|
|
if (!stream.IsNull()) {
|
|
m_device->GetRemoteFeatureControl()
|
|
->GetCommandFeature("AcquisitionStop")->Execute();
|
|
stream->StopGrab();
|
|
stream->Close();
|
|
}
|
|
} catch (...) {}
|
|
}
|
|
}
|
|
|
|
void CaptureWorker::stopCapture()
|
|
{
|
|
m_running.store(false);
|
|
}
|
|
|
|
// =====================================================================
|
|
// CameraManager
|
|
// =====================================================================
|
|
CameraManager::CameraManager(QObject* parent) : QObject(parent)
|
|
{
|
|
m_serial[LEFT] = LEFT_SN;
|
|
m_serial[RIGHT] = RIGHT_SN;
|
|
for (int i = 0; i < 2; i++) {
|
|
m_connected[i] = false;
|
|
m_thread[i] = nullptr;
|
|
m_worker[i] = nullptr;
|
|
}
|
|
}
|
|
|
|
void CameraManager::setSerialNumber(CamIndex idx, const QString& serialNumber)
|
|
{
|
|
if (idx != LEFT && idx != RIGHT) return;
|
|
if (!serialNumber.trimmed().isEmpty())
|
|
m_serial[idx] = serialNumber.trimmed();
|
|
}
|
|
|
|
QString CameraManager::serialNumber(CamIndex idx) const
|
|
{
|
|
return (idx == LEFT || idx == RIGHT) ? m_serial[idx] : QString();
|
|
}
|
|
|
|
CameraManager::~CameraManager()
|
|
{
|
|
stopPreview(LEFT); stopPreview(RIGHT);
|
|
disconnectCamera(LEFT); disconnectCamera(RIGHT);
|
|
uninitSDK();
|
|
}
|
|
|
|
bool CameraManager::initSDK()
|
|
{
|
|
try {
|
|
const auto sdk = bundledGalaxySdk();
|
|
if (!sdk.isEmpty()) configureGalaxyRuntime(sdk);
|
|
IGXFactory::GetInstance().Init(); return true;
|
|
}
|
|
catch (CGalaxyException& e) {
|
|
qWarning() << "SDK init failed:" << e.what(); return false;
|
|
} catch (const std::exception& e) {
|
|
qWarning() << "Camera runtime setup failed:" << e.what(); return false;
|
|
}
|
|
}
|
|
|
|
void CameraManager::uninitSDK()
|
|
{
|
|
try { IGXFactory::GetInstance().Uninit(); } catch (...) {}
|
|
}
|
|
|
|
QStringList CameraManager::enumerateDevices()
|
|
{
|
|
QStringList list;
|
|
try {
|
|
GxIAPICPP::gxdeviceinfo_vector devList;
|
|
IGXFactory::GetInstance().UpdateAllDeviceList(1000, devList);
|
|
for (uint32_t i = 0; i < devList.size(); i++)
|
|
list << gxToQString(devList[i].GetSN());
|
|
} catch (...) {}
|
|
return list;
|
|
}
|
|
|
|
QString CameraManager::snForIndex(CamIndex idx) const
|
|
{
|
|
return serialNumber(idx);
|
|
}
|
|
|
|
bool CameraManager::connectCamera(CamIndex idx)
|
|
{
|
|
if (m_connected[idx]) return true;
|
|
try {
|
|
GxIAPICPP::gxdeviceinfo_vector devList;
|
|
IGXFactory::GetInstance().UpdateAllDeviceList(1000, devList);
|
|
|
|
QString sn = snForIndex(idx);
|
|
bool found = false;
|
|
for (uint32_t i = 0; i < devList.size(); i++) {
|
|
if (gxToQString(devList[i].GetSN()) == sn) {
|
|
found = true; break;
|
|
}
|
|
}
|
|
if (!found) {
|
|
emit errorOccurred(idx, QString("Camera %1 not found").arg(sn));
|
|
return false;
|
|
}
|
|
|
|
m_device[idx] = IGXFactory::GetInstance().OpenDeviceBySN(
|
|
qToGxString(sn), GX_ACCESS_EXCLUSIVE);
|
|
if (m_device[idx].IsNull()) {
|
|
emit errorOccurred(idx, "OpenDeviceBySN returned null");
|
|
return false;
|
|
}
|
|
m_connected[idx] = true;
|
|
emit cameraConnected(idx);
|
|
return true;
|
|
}
|
|
catch (CGalaxyException& e) {
|
|
emit errorOccurred(idx, QString("Connect failed: %1").arg(e.what()));
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void CameraManager::disconnectCamera(CamIndex idx)
|
|
{
|
|
stopPreview(idx);
|
|
if (!m_device[idx].IsNull()) {
|
|
try { m_device[idx]->Close(); } catch (...) {}
|
|
m_device[idx] = CGXDevicePointer(); // release smart ptr
|
|
}
|
|
m_connected[idx] = false;
|
|
emit cameraDisconnected(idx);
|
|
}
|
|
|
|
bool CameraManager::isConnected(CamIndex idx) const { return m_connected[idx]; }
|
|
|
|
bool CameraManager::startPreview(CamIndex idx)
|
|
{
|
|
if (!m_connected[idx] || m_device[idx].IsNull() || m_thread[idx])
|
|
return false;
|
|
|
|
m_worker[idx] = new CaptureWorker(m_device[idx]);
|
|
m_thread[idx] = new QThread();
|
|
m_worker[idx]->moveToThread(m_thread[idx]);
|
|
|
|
connect(m_thread[idx], &QThread::started, m_worker[idx], &CaptureWorker::startCapture);
|
|
if (idx == LEFT)
|
|
connect(m_worker[idx], &CaptureWorker::frameReady, this, &CameraManager::leftFrameReady);
|
|
else
|
|
connect(m_worker[idx], &CaptureWorker::frameReady, this, &CameraManager::rightFrameReady);
|
|
connect(m_worker[idx], &CaptureWorker::errorOccurred,
|
|
this, [this, idx](const QString& msg){ emit errorOccurred(idx, msg); });
|
|
connect(m_thread[idx], &QThread::finished, m_worker[idx], &QObject::deleteLater);
|
|
connect(m_thread[idx], &QThread::finished, m_thread[idx], &QObject::deleteLater);
|
|
|
|
m_thread[idx]->start();
|
|
return true;
|
|
}
|
|
|
|
void CameraManager::stopPreview(CamIndex idx)
|
|
{
|
|
if (m_worker[idx]) m_worker[idx]->stopCapture();
|
|
if (m_thread[idx]) {
|
|
m_thread[idx]->quit();
|
|
m_thread[idx]->wait(3000);
|
|
m_thread[idx] = nullptr;
|
|
m_worker[idx] = nullptr;
|
|
}
|
|
}
|
|
|
|
QImage CameraManager::captureSingleFrame(CamIndex idx)
|
|
{
|
|
if (!m_connected[idx] || m_device[idx].IsNull()) return QImage();
|
|
bool wasPreviewing = (m_thread[idx] != nullptr);
|
|
if (wasPreviewing) stopPreview(idx);
|
|
|
|
QImage result;
|
|
try {
|
|
CGXStreamPointer stream = m_device[idx]->OpenStream(0);
|
|
stream->StartGrab();
|
|
m_device[idx]->GetRemoteFeatureControl()
|
|
->GetCommandFeature("AcquisitionStart")->Execute();
|
|
|
|
result = grabOneFrame(m_device[idx], stream, 3000);
|
|
|
|
m_device[idx]->GetRemoteFeatureControl()
|
|
->GetCommandFeature("AcquisitionStop")->Execute();
|
|
stream->StopGrab();
|
|
stream->Close();
|
|
}
|
|
catch (CGalaxyException& e) {
|
|
emit errorOccurred(idx, QString("Capture failed: %1").arg(e.what()));
|
|
}
|
|
|
|
if (wasPreviewing) startPreview(idx);
|
|
return result;
|
|
}
|
|
|
|
bool CameraManager::setExposureTime(CamIndex idx, double us)
|
|
{
|
|
if (!m_connected[idx] || m_device[idx].IsNull()) return false;
|
|
try {
|
|
m_device[idx]->GetRemoteFeatureControl()
|
|
->GetEnumFeature("ExposureAuto")->SetValue("Off");
|
|
m_device[idx]->GetRemoteFeatureControl()
|
|
->GetFloatFeature("ExposureTime")->SetValue(us);
|
|
return true;
|
|
} catch (CGalaxyException& e) {
|
|
emit errorOccurred(idx, QString("Set exposure failed: %1").arg(e.what()));
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool CameraManager::getExposureTime(CamIndex idx, double& us)
|
|
{
|
|
us = 0.0;
|
|
if (!m_connected[idx] || m_device[idx].IsNull()) return false;
|
|
try {
|
|
us = m_device[idx]->GetRemoteFeatureControl()
|
|
->GetFloatFeature("ExposureTime")->GetValue();
|
|
return std::isfinite(us);
|
|
} catch (CGalaxyException& e) {
|
|
emit errorOccurred(idx, QString("Get exposure failed: %1").arg(e.what()));
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool CameraManager::setGain(CamIndex idx, double dB)
|
|
{
|
|
if (!m_connected[idx] || m_device[idx].IsNull()) return false;
|
|
try {
|
|
m_device[idx]->GetRemoteFeatureControl()
|
|
->GetEnumFeature("GainAuto")->SetValue("Off");
|
|
m_device[idx]->GetRemoteFeatureControl()
|
|
->GetFloatFeature("Gain")->SetValue(dB);
|
|
return true;
|
|
} catch (CGalaxyException& e) {
|
|
emit errorOccurred(idx, QString("Set gain failed: %1").arg(e.what()));
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool CameraManager::setBandwidthLimit(CamIndex idx, bool enabled)
|
|
{
|
|
if (!m_connected[idx] || m_device[idx].IsNull()) return false;
|
|
try {
|
|
auto features = m_device[idx]->GetRemoteFeatureControl();
|
|
features->GetIntFeature("DeviceLinkSelector")->SetValue(0);
|
|
features->GetEnumFeature("DeviceLinkThroughputLimitMode")->SetValue(enabled ? "On" : "Off");
|
|
return true;
|
|
} catch (...) {
|
|
emit errorOccurred(idx, QStringLiteral("Set bandwidth limit failed"));
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool CameraManager::applyWhiteBalanceOnce(CamIndex idx)
|
|
{
|
|
if (!m_connected[idx] || m_device[idx].IsNull()) return false;
|
|
try {
|
|
m_device[idx]->GetRemoteFeatureControl()
|
|
->GetEnumFeature("BalanceWhiteAuto")
|
|
->SetValue("Once");
|
|
return true;
|
|
} catch (CGalaxyException& e) {
|
|
emit errorOccurred(idx, QString("Apply white balance once failed: %1").arg(e.what()));
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool CameraManager::whiteBalanceFinished(CamIndex idx, bool& finished)
|
|
{
|
|
finished=false;
|
|
if(!m_connected[idx]||m_device[idx].IsNull())return false;
|
|
try {
|
|
const auto value=m_device[idx]->GetRemoteFeatureControl()->GetEnumFeature("BalanceWhiteAuto")->GetValue();
|
|
finished=gxToQString(value)==QStringLiteral("Off");
|
|
return true;
|
|
}catch(CGalaxyException& e){emit errorOccurred(idx,QString("Read white balance state failed: %1").arg(e.what()));return false;}
|
|
}
|