zhangben1207/CommonLibraries
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix: follow official calib roi capture sequence

Browse Source
This commit is contained in:
Ben 2026-08-26 12:11:19 +08:00
parent 756bd1d64a
commit 8935bd24cd
1 changed files with 65 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

99
src/VizumCamera.cpp
View File

@ -121,9 +121,7 @@ class FullFrameRoiRestoreGuard
public: public:
FullFrameRoiRestoreGuard(VZNLHANDLE deviceHandle, FullFrameRoiRestoreGuard(VZNLHANDLE deviceHandle,
const SVzNLROIRect& initialLeftROI, const SVzNLROIRect& initialLeftROI,
const SVzNLROIRect& initialRightROI, const SVzNLROIRect& initialRightROI)
unsigned int frameWidth,
unsigned int frameHeight)
: m_guardDeviceHandle(deviceHandle), : m_guardDeviceHandle(deviceHandle),
m_initialLeftROI(initialLeftROI), m_initialLeftROI(initialLeftROI),
m_initialRightROI(initialRightROI) m_initialRightROI(initialRightROI)
@ -149,19 +147,33 @@ public:
} }
m_restoreRequired = true; m_restoreRequired = true;
SVzVideoResolution resolution{};
ret = VzNL_GetResolution(m_guardDeviceHandle, &resolution);
if (ret != 0 || resolution.nFrameWidth == 0 || resolution.nFrameHeight == 0) {
char errorMsg[256] = {0};
VzNL_GetErrorInfo(ret, errorMsg);
LOG_ERROR("[VizumCamera] Cannot read full-frame resolution after enabling CalibROI: {} "
"(error code: {}), size={}x{}",
errorMsg, ret, resolution.nFrameWidth, resolution.nFrameHeight);
RestoreNow();
return;
}
m_frameWidth = resolution.nFrameWidth;
m_frameHeight = resolution.nFrameHeight;
SVzNLROIRect fullLeftROI{}; SVzNLROIRect fullLeftROI{};
fullLeftROI.right = frameWidth; fullLeftROI.right = m_frameWidth;
fullLeftROI.bottom = frameHeight; fullLeftROI.bottom = m_frameHeight;
SVzNLROIRect fullRightROI{}; SVzNLROIRect fullRightROI{};
fullRightROI.right = frameWidth; fullRightROI.right = m_frameWidth;
fullRightROI.bottom = frameHeight; fullRightROI.bottom = m_frameHeight;
ret = VzNL_ConfigDetectROI(m_guardDeviceHandle, &fullLeftROI, &fullRightROI); ret = VzNL_ConfigDetectROI(m_guardDeviceHandle, &fullLeftROI, &fullRightROI);
if (ret != 0) { if (ret != 0) {
char errorMsg[256] = {0}; char errorMsg[256] = {0};
VzNL_GetErrorInfo(ret, errorMsg); VzNL_GetErrorInfo(ret, errorMsg);
LOG_ERROR("[VizumCamera] Cannot configure full-frame detection ROI: {} " LOG_ERROR("[VizumCamera] Cannot configure full-frame detection ROI: {} "
"(error code: {}), requested=[0, {}, 0, {}]", "(error code: {}), requested=[0, {}, 0, {}]",
errorMsg, ret, frameWidth, frameHeight); errorMsg, ret, m_frameWidth, m_frameHeight);
RestoreNow(); RestoreNow();
return; return;
} }
@ -170,7 +182,7 @@ public:
LOG_INFO("[VizumCamera] Temporary full-frame ROI configured through SDK: " LOG_INFO("[VizumCamera] Temporary full-frame ROI configured through SDK: "
"left/right=[0, {}, 0, {}]; initial left=[{}, {}, {}, {}], " "left/right=[0, {}, 0, {}]; initial left=[{}, {}, {}, {}], "
"right=[{}, {}, {}, {}]", "right=[{}, {}, {}, {}]",
frameWidth, frameHeight, m_frameWidth, m_frameHeight,
m_initialLeftROI.left, m_initialLeftROI.right, m_initialLeftROI.left, m_initialLeftROI.right,
m_initialLeftROI.top, m_initialLeftROI.bottom, m_initialLeftROI.top, m_initialLeftROI.bottom,
m_initialRightROI.left, m_initialRightROI.right, m_initialRightROI.left, m_initialRightROI.right,
@ -182,6 +194,16 @@ public:
return m_ready; return m_ready;
} }
unsigned int FrameWidth() const
{
return m_frameWidth;
}
unsigned int FrameHeight() const
{
return m_frameHeight;
}
bool RestoreNow() bool RestoreNow()
{ {
if (m_restoreAttempted && m_restoreSucceeded) if (m_restoreAttempted && m_restoreSucceeded)
@ -252,6 +274,8 @@ private:
SVzNLROIRect m_initialLeftROI{}; SVzNLROIRect m_initialLeftROI{};
SVzNLROIRect m_initialRightROI{}; SVzNLROIRect m_initialRightROI{};
VzBool m_previousCalibRoi = VzFalse; VzBool m_previousCalibRoi = VzFalse;
unsigned int m_frameWidth = 0;
unsigned int m_frameHeight = 0;
bool m_restoreRequired = false; bool m_restoreRequired = false;
bool m_ready = false; bool m_ready = false;
bool m_restoreAttempted = false; bool m_restoreAttempted = false;
@ -1100,13 +1124,25 @@ bool VizumCamera::CaptureFullFrameLeftImage(SLImage& image,
return false; return false;
} }
// Official SDK sample sequence starts by disabling CalibROI before
// reading the ROI that will be restored after the full-frame capture.
int ret = VzNL_EnableCalibROI(m_deviceHandle, VzFalse);
if (ret != 0) {
char errorMsg[256] = {0};
VzNL_GetErrorInfo(ret, errorMsg);
LOG_ERROR("[VizumCamera] Official full-frame transaction cannot disable CalibROI "
"before reading initial ROI: {} (error code: {})", errorMsg, ret);
return false;
}
LOG_INFO("[VizumCamera] Official full-frame transaction baseline applied: CalibROI=false");
const SVzNLROIRect expectedLeftROI{initialLeftROI.left, initialLeftROI.right, const SVzNLROIRect expectedLeftROI{initialLeftROI.left, initialLeftROI.right,
initialLeftROI.top, initialLeftROI.bottom}; initialLeftROI.top, initialLeftROI.bottom};
const SVzNLROIRect expectedRightROI{initialRightROI.left, initialRightROI.right, const SVzNLROIRect expectedRightROI{initialRightROI.left, initialRightROI.right,
initialRightROI.top, initialRightROI.bottom}; initialRightROI.top, initialRightROI.bottom};
SVzNLROIRect currentLeftROI{}; SVzNLROIRect currentLeftROI{};
SVzNLROIRect currentRightROI{}; SVzNLROIRect currentRightROI{};
int ret = VzNL_GetConfigDetectROI(m_deviceHandle, &currentLeftROI, &currentRightROI); ret = VzNL_GetConfigDetectROI(m_deviceHandle, &currentLeftROI, &currentRightROI);
if (ret != 0) { if (ret != 0) {
char errorMsg[256] = {0}; char errorMsg[256] = {0};
VzNL_GetErrorInfo(ret, errorMsg); VzNL_GetErrorInfo(ret, errorMsg);
@ -1115,17 +1151,6 @@ bool VizumCamera::CaptureFullFrameLeftImage(SLImage& image,
return false; return false;
} }
SVzVideoResolution resolution{};
ret = VzNL_GetResolution(m_deviceHandle, &resolution);
if (ret != 0 || resolution.nFrameWidth == 0 || resolution.nFrameHeight == 0) {
char errorMsg[256] = {0};
VzNL_GetErrorInfo(ret, errorMsg);
LOG_ERROR("[VizumCamera] Full-frame capture cannot read a valid resolution: {} "
"(error code: {}), size={}x{}",
errorMsg, ret, resolution.nFrameWidth, resolution.nFrameHeight);
return false;
}
if (!SameSdkRoi(currentLeftROI, expectedLeftROI) if (!SameSdkRoi(currentLeftROI, expectedLeftROI)
|| !SameSdkRoi(currentRightROI, expectedRightROI)) { || !SameSdkRoi(currentRightROI, expectedRightROI)) {
LOG_ERROR("[VizumCamera] Current ROI differs from the connection-time point-cloud ROI; " LOG_ERROR("[VizumCamera] Current ROI differs from the connection-time point-cloud ROI; "
@ -1139,9 +1164,14 @@ bool VizumCamera::CaptureFullFrameLeftImage(SLImage& image,
expectedLeftROI.top, expectedLeftROI.bottom, expectedLeftROI.top, expectedLeftROI.bottom,
expectedRightROI.left, expectedRightROI.right, expectedRightROI.left, expectedRightROI.right,
expectedRightROI.top, expectedRightROI.bottom); expectedRightROI.top, expectedRightROI.bottom);
FullFrameRoiRestoreGuard recoveryGuard(m_deviceHandle, expectedLeftROI, expectedRightROI, ret = VzNL_ConfigDetectROI(m_deviceHandle, &expectedLeftROI, &expectedRightROI);
resolution.nFrameWidth, resolution.nFrameHeight); const bool recoverySucceeded = ret == 0;
const bool recoverySucceeded = recoveryGuard.RestoreNow(); if (!recoverySucceeded) {
char errorMsg[256] = {0};
VzNL_GetErrorInfo(ret, errorMsg);
LOG_ERROR("[VizumCamera] Failed to restore expected ROI while CalibROI=false: {} "
"(error code: {})", errorMsg, ret);
}
ret = VzNL_GetConfigDetectROI(m_deviceHandle, &currentLeftROI, &currentRightROI); ret = VzNL_GetConfigDetectROI(m_deviceHandle, &currentLeftROI, &currentRightROI);
cameraStateRestored = recoverySucceeded && ret == 0 cameraStateRestored = recoverySucceeded && ret == 0
&& SameSdkRoi(currentLeftROI, expectedLeftROI) && SameSdkRoi(currentLeftROI, expectedLeftROI)
@ -1149,8 +1179,7 @@ bool VizumCamera::CaptureFullFrameLeftImage(SLImage& image,
return false; return false;
} }
FullFrameRoiRestoreGuard roiGuard(m_deviceHandle, expectedLeftROI, expectedRightROI, FullFrameRoiRestoreGuard roiGuard(m_deviceHandle, expectedLeftROI, expectedRightROI);
resolution.nFrameWidth, resolution.nFrameHeight);
if (!roiGuard.IsReady()) { if (!roiGuard.IsReady()) {
const bool restoreSucceeded = roiGuard.RestoreNow(); const bool restoreSucceeded = roiGuard.RestoreNow();
ret = VzNL_GetConfigDetectROI(m_deviceHandle, &currentLeftROI, &currentRightROI); ret = VzNL_GetConfigDetectROI(m_deviceHandle, &currentLeftROI, &currentRightROI);
@ -1159,14 +1188,16 @@ bool VizumCamera::CaptureFullFrameLeftImage(SLImage& image,
&& SameSdkRoi(currentRightROI, expectedRightROI); && SameSdkRoi(currentRightROI, expectedRightROI);
return false; return false;
} }
const unsigned int frameWidth = roiGuard.FrameWidth();
const unsigned int frameHeight = roiGuard.FrameHeight();
SVzNLROIRect configuredLeftROI{}; SVzNLROIRect configuredLeftROI{};
SVzNLROIRect configuredRightROI{}; SVzNLROIRect configuredRightROI{};
ret = VzNL_GetConfigDetectROI(m_deviceHandle, &configuredLeftROI, &configuredRightROI); ret = VzNL_GetConfigDetectROI(m_deviceHandle, &configuredLeftROI, &configuredRightROI);
const auto isFullFrameRoi = [&resolution](const SVzNLROIRect& roi) { const auto isFullFrameRoi = [frameWidth, frameHeight](const SVzNLROIRect& roi) {
return roi.left == 0 && roi.top == 0 return roi.left == 0 && roi.top == 0
&& roi.right == resolution.nFrameWidth && roi.right == static_cast<int>(frameWidth)
&& roi.bottom == resolution.nFrameHeight; && roi.bottom == static_cast<int>(frameHeight);
}; };
if (ret != 0 || !isFullFrameRoi(configuredLeftROI) || !isFullFrameRoi(configuredRightROI)) { if (ret != 0 || !isFullFrameRoi(configuredLeftROI) || !isFullFrameRoi(configuredRightROI)) {
char errorMsg[256] = {0}; char errorMsg[256] = {0};
@ -1179,7 +1210,7 @@ bool VizumCamera::CaptureFullFrameLeftImage(SLImage& image,
configuredLeftROI.top, configuredLeftROI.bottom, configuredLeftROI.top, configuredLeftROI.bottom,
configuredRightROI.left, configuredRightROI.right, configuredRightROI.left, configuredRightROI.right,
configuredRightROI.top, configuredRightROI.bottom, configuredRightROI.top, configuredRightROI.bottom,
resolution.nFrameWidth, resolution.nFrameHeight); frameWidth, frameHeight);
const bool restoreSucceeded = roiGuard.RestoreNow(); const bool restoreSucceeded = roiGuard.RestoreNow();
ret = VzNL_GetConfigDetectROI(m_deviceHandle, &currentLeftROI, &currentRightROI); ret = VzNL_GetConfigDetectROI(m_deviceHandle, &currentLeftROI, &currentRightROI);
cameraStateRestored = restoreSucceeded && ret == 0 cameraStateRestored = restoreSucceeded && ret == 0
@ -1189,7 +1220,7 @@ bool VizumCamera::CaptureFullFrameLeftImage(SLImage& image,
} }
LOG_INFO("[VizumCamera] SDK full-frame ROI readback verified before 2D capture: " LOG_INFO("[VizumCamera] SDK full-frame ROI readback verified before 2D capture: "
"left/right=[0, {}, 0, {}]", "left/right=[0, {}, 0, {}]",
resolution.nFrameWidth, resolution.nFrameHeight); frameWidth, frameHeight);
SVzNLImageData* leftImage = nullptr; SVzNLImageData* leftImage = nullptr;
SVzNLImageData* rightImage = nullptr; SVzNLImageData* rightImage = nullptr;
@ -1214,13 +1245,13 @@ bool VizumCamera::CaptureFullFrameLeftImage(SLImage& image,
const bool validFullFrame = converted && !image.empty() const bool validFullFrame = converted && !image.empty()
&& image.originX == 0 && image.originY == 0 && image.originX == 0 && image.originY == 0
&& image.width == resolution.nFrameWidth && image.width == frameWidth
&& image.height == resolution.nFrameHeight; && image.height == frameHeight;
if (converted && !validFullFrame) { if (converted && !validFullFrame) {
LOG_ERROR("[VizumCamera] Configured full-frame image contract failed: " LOG_ERROR("[VizumCamera] Configured full-frame image contract failed: "
"image={}x{} origin=({}, {}), expected={}x{} origin=(0, 0)", "image={}x{} origin=({}, {}), expected={}x{} origin=(0, 0)",
image.width, image.height, image.originX, image.originY, image.width, image.height, image.originX, image.originY,
resolution.nFrameWidth, resolution.nFrameHeight); frameWidth, frameHeight);
} }
const bool initialRoiRestored = roiGuard.RestoreNow(); const bool initialRoiRestored = roiGuard.RestoreNow();