From e8a209c782cbd9afef37c4c8e48df9de2fd41931 Mon Sep 17 00:00:00 2001 From: Lixfel Date: Thu, 1 Oct 2026 07:25:35 +0200 Subject: [PATCH 1/7] First preparations for runtime dynamic camera drivers --- src/driver/cameradriver.h | 18 ++++++++++++ src/driver/dummydriver.cpp | 57 ++++++++++++++++++++++++++++++++++++++ src/driver/dummydriver.h | 35 +++++++++++++++++++++++ 3 files changed, 110 insertions(+) create mode 100644 src/driver/dummydriver.cpp create mode 100644 src/driver/dummydriver.h diff --git a/src/driver/cameradriver.h b/src/driver/cameradriver.h index 90674de..199bf04 100644 --- a/src/driver/cameradriver.h +++ b/src/driver/cameradriver.h @@ -44,6 +44,24 @@ class CameraDriver { // Bound to the driver for reproducibility during testing with files. virtual double getTime(); + + virtual uint32_t getWidth() = 0; + virtual uint32_t getHeight() = 0; + virtual void setResolution(uint32_t width, uint32_t height) = 0; + + virtual float getExposure() = 0; + virtual void setExposure(float exposure) = 0; + + virtual float getGain() = 0; + virtual void setGain(float gain) = 0; + + virtual float getGamma() = 0; + virtual void setGamma(float gamma) = 0; + + virtual WhiteBalanceType getWhiteBalanceType() = 0; + virtual float getWhiteBalanceBlue() = 0; + virtual float getWhiteBalanceRed() = 0; + virtual void setWhiteBalance(WhiteBalanceType type, float blue, float red) = 0; }; diff --git a/src/driver/dummydriver.cpp b/src/driver/dummydriver.cpp new file mode 100644 index 0000000..8ee8581 --- /dev/null +++ b/src/driver/dummydriver.cpp @@ -0,0 +1,57 @@ +#include "dummydriver.h" +#include "driver/cameradriver.h" +#include "opencl.h" + +DummyDriver::DummyDriver(const CameraConfig& config): image(std::make_shared(&PixelFormat::BGR8, 640, 480, "dummy")) {} + +std::shared_ptr DummyDriver::readImage() { + return image; +} + +const PixelFormat DummyDriver::format() { + return PixelFormat::BGR8; +} + +double DummyDriver::expectedFrametime() { + return 1.0 / 30.0; +} + +uint32_t DummyDriver::getWidth() { + return 640; +} + +uint32_t DummyDriver::getHeight() { + return 480; +} + +void DummyDriver::setResolution(uint32_t width, uint32_t height) {} + +float DummyDriver::getExposure() { + return 1.0f; +} + +void DummyDriver::setExposure(float exposure) {} + +float DummyDriver::getGain() { + return 1.0f; +} + +void DummyDriver::setGain(float gain) {} + +float DummyDriver::getGamma() { + return 1.0f; +} + +void DummyDriver::setGamma(float gamma) {} + +WhiteBalanceType DummyDriver::getWhiteBalanceType() { + return WhiteBalanceType::WhiteBalanceType_Manual; +} + +float DummyDriver::getWhiteBalanceBlue() { + return 1.0f; +} + +float DummyDriver::getWhiteBalanceRed() { + return 1.0f; +} diff --git a/src/driver/dummydriver.h b/src/driver/dummydriver.h new file mode 100644 index 0000000..c46d07d --- /dev/null +++ b/src/driver/dummydriver.h @@ -0,0 +1,35 @@ +#pragma once +#include "cameradriver.h" + +class DummyDriver : public CameraDriver { +public: + explicit DummyDriver(const CameraConfig& config); + ~DummyDriver() override = default; + + std::shared_ptr readImage() override; + + const PixelFormat format() override; + + double expectedFrametime() override; + + uint32_t getWidth() override; + uint32_t getHeight() override; + void setResolution(uint32_t width, uint32_t height) override; + + float getExposure() override; + void setExposure(float exposure) override; + + float getGain() override; + void setGain(float gain) override; + + float getGamma() override; + void setGamma(float gamma) override; + + WhiteBalanceType getWhiteBalanceType() override; + float getWhiteBalanceBlue() override; + float getWhiteBalanceRed() override; + void setWhiteBalance(WhiteBalanceType type, float blue, float red) override; + +private: + std::shared_ptr image; +}; From 97994c0d0c3cb6d5e622f790fde3517bb40953de Mon Sep 17 00:00:00 2001 From: Lixfel Date: Thu, 1 Oct 2026 07:43:03 +0200 Subject: [PATCH 2/7] Implement OpenCV backend --- src/driver/dummydriver.cpp | 8 ++-- src/driver/opencvdriver.cpp | 75 +++++++++++++++++++++++++++++++++++++ src/driver/opencvdriver.h | 18 +++++++++ 3 files changed, 98 insertions(+), 3 deletions(-) diff --git a/src/driver/dummydriver.cpp b/src/driver/dummydriver.cpp index 8ee8581..c19bff5 100644 --- a/src/driver/dummydriver.cpp +++ b/src/driver/dummydriver.cpp @@ -27,13 +27,13 @@ uint32_t DummyDriver::getHeight() { void DummyDriver::setResolution(uint32_t width, uint32_t height) {} float DummyDriver::getExposure() { - return 1.0f; + return 0.0f; } void DummyDriver::setExposure(float exposure) {} float DummyDriver::getGain() { - return 1.0f; + return 0.0f; } void DummyDriver::setGain(float gain) {} @@ -45,7 +45,7 @@ float DummyDriver::getGamma() { void DummyDriver::setGamma(float gamma) {} WhiteBalanceType DummyDriver::getWhiteBalanceType() { - return WhiteBalanceType::WhiteBalanceType_Manual; + return WhiteBalanceType::WhiteBalanceType_AutoOutdoor; } float DummyDriver::getWhiteBalanceBlue() { @@ -55,3 +55,5 @@ float DummyDriver::getWhiteBalanceBlue() { float DummyDriver::getWhiteBalanceRed() { return 1.0f; } + +void DummyDriver::setWhiteBalance(WhiteBalanceType type, float blue, float red) {} diff --git a/src/driver/opencvdriver.cpp b/src/driver/opencvdriver.cpp index 77c87dd..bca2ecb 100644 --- a/src/driver/opencvdriver.cpp +++ b/src/driver/opencvdriver.cpp @@ -14,6 +14,8 @@ limitations under the License. */ #include "opencvdriver.h" +#include "driver/cameradriver.h" +#include OpenCVDriver::OpenCVDriver(const CameraConfig& config): capture(config.path, cv::CAP_ANY, {cv::CAP_PROP_HW_ACCELERATION, cv::VIDEO_ACCELERATION_ANY}), name(config.path) { std::replace(name.begin(), name.end(), '/', '_'); @@ -87,3 +89,76 @@ double OpenCVDriver::getTime() { return pos / capture.get(cv::CAP_PROP_FPS); } + +uint32_t OpenCVDriver::getWidth() { + return (uint32_t)capture.get(cv::CAP_PROP_FRAME_WIDTH); +} + +uint32_t OpenCVDriver::getHeight() { + return (uint32_t)capture.get(cv::CAP_PROP_FRAME_HEIGHT); +} + +void OpenCVDriver::setResolution(uint32_t width, uint32_t height) { + capture.set(cv::CAP_PROP_FRAME_WIDTH, width); + capture.set(cv::CAP_PROP_FRAME_HEIGHT, height); +} + +float OpenCVDriver::getExposure() { + if(capture.get(cv::CAP_PROP_AUTO_EXPOSURE) == 1.0) { + return 0.0f; + } else { + return (float)capture.get(cv::CAP_PROP_EXPOSURE) / 1000.0f; + } +} + +void OpenCVDriver::setExposure(float exposure) { + if(exposure == 0.0f) { + capture.set(cv::CAP_PROP_AUTO_EXPOSURE, 1.0); + return; + } else { + capture.set(cv::CAP_PROP_AUTO_EXPOSURE, 0.0); + capture.set(cv::CAP_PROP_EXPOSURE, exposure * 1000.0); + } +} + +float OpenCVDriver::getGain() { + return (float)capture.get(cv::CAP_PROP_GAIN); +} + +void OpenCVDriver::setGain(float gain) { + capture.set(cv::CAP_PROP_GAIN, gain); +} + +float OpenCVDriver::getGamma() { + return (float)capture.get(cv::CAP_PROP_GAMMA); +} + +void OpenCVDriver::setGamma(float gamma) { + capture.set(cv::CAP_PROP_GAMMA, gamma); +} + +WhiteBalanceType OpenCVDriver::getWhiteBalanceType() { + if(capture.get(cv::CAP_PROP_AUTO_WB) == 1.0) { + return WhiteBalanceType::WhiteBalanceType_AutoOutdoor; + } else { + return WhiteBalanceType::WhiteBalanceType_Manual; + } +} + +float OpenCVDriver::getWhiteBalanceBlue() { + return (float)capture.get(cv::CAP_PROP_WHITE_BALANCE_BLUE_U); +} + +float OpenCVDriver::getWhiteBalanceRed() { + return (float)capture.get(cv::CAP_PROP_WHITE_BALANCE_RED_V); +} + +void OpenCVDriver::setWhiteBalance(WhiteBalanceType type, float blue, float red) { + if(type != WhiteBalanceType::WhiteBalanceType_Manual) { + capture.set(cv::CAP_PROP_AUTO_WB, 1.0); + } else { + capture.set(cv::CAP_PROP_AUTO_WB, 0.0); + capture.set(cv::CAP_PROP_WHITE_BALANCE_BLUE_U, blue); + capture.set(cv::CAP_PROP_WHITE_BALANCE_RED_V, red); + } +} diff --git a/src/driver/opencvdriver.h b/src/driver/opencvdriver.h index 0c1d432..1dcde09 100644 --- a/src/driver/opencvdriver.h +++ b/src/driver/opencvdriver.h @@ -31,6 +31,24 @@ class OpenCVDriver : public CameraDriver { double getTime() override; + uint32_t getWidth() override; + uint32_t getHeight() override; + void setResolution(uint32_t width, uint32_t height) override; + + float getExposure() override; + void setExposure(float exposure) override; + + float getGain() override; + void setGain(float gain) override; + + float getGamma() override; + void setGamma(float gamma) override; + + WhiteBalanceType getWhiteBalanceType() override; + float getWhiteBalanceBlue() override; + float getWhiteBalanceRed() override; + void setWhiteBalance(WhiteBalanceType type, float blue, float red) override; + private: cv::VideoCapture capture; std::shared_ptr image = nullptr; From 6cbc2722ed8bcb747f300fb94140fd152f5a6eba Mon Sep 17 00:00:00 2001 From: Lixfel Date: Sun, 4 Oct 2026 07:53:17 +0200 Subject: [PATCH 3/7] Adapt spinnaker driver --- src/driver/spinnakerdriver.cpp | 90 ++++++++++++++++++++++++++++++++++ src/driver/spinnakerdriver.h | 39 +++++++++++---- 2 files changed, 119 insertions(+), 10 deletions(-) diff --git a/src/driver/spinnakerdriver.cpp b/src/driver/spinnakerdriver.cpp index 545ab52..62fe92a 100644 --- a/src/driver/spinnakerdriver.cpp +++ b/src/driver/spinnakerdriver.cpp @@ -180,4 +180,94 @@ void SpinnakerDriver::restore(const RawImage& image) { } } +uint32_t SpinnakerDriver::getWidth() { + return pCam->Width.GetValue(); +} + +uint32_t SpinnakerDriver::getHeight() { + return pCam->Height.GetValue(); +} + +void SpinnakerDriver::setResolution(uint32_t width, uint32_t height) { + CATCH_SPINNAKER(pCam->Width.SetValue(width)); + CATCH_SPINNAKER(pCam->Height.SetValue(height)); +} + +float SpinnakerDriver::getExposure() { + return pCam->ExposureTime.GetValue() / 1000.0f; +} + +void SpinnakerDriver::setExposure(float exposure) { + if(exposure == 0.0f) { + CATCH_SPINNAKER(pCam->ExposureAuto.SetValue(Spinnaker::ExposureAuto_Continuous)); + CATCH_SPINNAKER(pCam->AutoExposureMeteringMode.SetValue(Spinnaker::AutoExposureMeteringMode_Average)); + } else { + CATCH_SPINNAKER(pCam->ExposureAuto.SetValue(Spinnaker::ExposureAuto_Off)) + CATCH_SPINNAKER(pCam->ExposureTime.SetValue(exposure * 1000.0f)) + } +} + +float SpinnakerDriver::getGain() { + return pCam->Gain.GetValue(); +} + +void SpinnakerDriver::setGain(float gain) { + if(gain == 0.0f) { + CATCH_SPINNAKER(pCam->GainAuto.SetValue(Spinnaker::GainAuto_Continuous)); + } else { + CATCH_SPINNAKER(pCam->GainAuto.SetValue(Spinnaker::GainAuto_Off)); + CATCH_SPINNAKER(pCam->Gain.SetValue(gain)); + } +} + +float SpinnakerDriver::getGamma() { + return pCam->Gamma.GetValue(); +} + +void SpinnakerDriver::setGamma(float gamma) { + if(gamma == 1.0f) { + CATCH_SPINNAKER(pCam->GammaEnable.SetValue(false)); + } else { + CATCH_SPINNAKER(pCam->GammaEnable.SetValue(true)); + CATCH_SPINNAKER(pCam->Gamma.SetValue(gamma)); + } +} + +WhiteBalanceType SpinnakerDriver::getWhiteBalanceType() { + if(pCam->BalanceWhiteAuto.GetValue() == Spinnaker::BalanceWhiteAuto_Off) { + return WhiteBalanceType::WhiteBalanceType_Manual; + } else { + return (pCam->BalanceWhiteAutoProfile.GetValue() == Spinnaker::BalanceWhiteAutoProfile_Outdoor) + ? WhiteBalanceType::WhiteBalanceType_AutoOutdoor + : WhiteBalanceType::WhiteBalanceType_AutoIndoor; + } +} + +float SpinnakerDriver::getWhiteBalanceBlue() { + CATCH_SPINNAKER(pCam->BalanceRatioSelector.SetValue(Spinnaker::BalanceRatioSelector_Blue)) + return pCam->BalanceRatio.GetValue(); +} + +float SpinnakerDriver::getWhiteBalanceRed() { + CATCH_SPINNAKER(pCam->BalanceRatioSelector.SetValue(Spinnaker::BalanceRatioSelector_Red)) + return pCam->BalanceRatio.GetValue(); +} + +void SpinnakerDriver::setWhiteBalance(WhiteBalanceType type, float blue, float red) { + if(type != WhiteBalanceType_Manual) { + CATCH_SPINNAKER(pCam->BalanceWhiteAuto.SetValue(Spinnaker::BalanceWhiteAuto_Continuous)); + CATCH_SPINNAKER(pCam->BalanceWhiteAutoProfile.SetValue( + type == WhiteBalanceType_AutoOutdoor + ? Spinnaker::BalanceWhiteAutoProfile_Outdoor + : Spinnaker::BalanceWhiteAutoProfile_Indoor + )); + } else { + CATCH_SPINNAKER(pCam->BalanceWhiteAuto.SetValue(Spinnaker::BalanceWhiteAuto_Off)); + CATCH_SPINNAKER(pCam->BalanceRatioSelector.SetValue(Spinnaker::BalanceRatioSelector_Blue)); + CATCH_SPINNAKER(pCam->BalanceRatio.SetValue(blue)); + CATCH_SPINNAKER(pCam->BalanceRatioSelector.SetValue(Spinnaker::BalanceRatioSelector_Red)); + CATCH_SPINNAKER(pCam->BalanceRatio.SetValue(red)); + } +} + #endif diff --git a/src/driver/spinnakerdriver.h b/src/driver/spinnakerdriver.h index af0d52b..0342c9e 100644 --- a/src/driver/spinnakerdriver.h +++ b/src/driver/spinnakerdriver.h @@ -1,19 +1,20 @@ /* - Copyright 2024 Felix Weinmann + Copyright 2024 Felix Weinmann - 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 + 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 + 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. + 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. */ #pragma once +#define SPINNAKER #ifdef SPINNAKER #include "cameradriver.h" @@ -33,6 +34,24 @@ class SpinnakerDriver : public CameraDriver { std::shared_ptr borrow(const Spinnaker::ImagePtr& pImage); void restore(const RawImage& image); + uint32_t getWidth() override; + uint32_t getHeight() override; + void setResolution(uint32_t width, uint32_t height) override; + + float getExposure() override; + void setExposure(float exposure) override; + + float getGain() override; + void setGain(float gain) override; + + float getGamma() override; + void setGamma(float gamma) override; + + WhiteBalanceType getWhiteBalanceType() override; + float getWhiteBalanceBlue() override; + float getWhiteBalanceRed() override; + void setWhiteBalance(WhiteBalanceType type, float blue, float red) override; + private: Spinnaker::SystemPtr pSystem; Spinnaker::CameraPtr pCam; From 7b87168692757f8982e4deb60e7d3debb98cb115 Mon Sep 17 00:00:00 2001 From: Lixfel Date: Sun, 4 Oct 2026 07:53:40 +0200 Subject: [PATCH 4/7] Bugfix --- src/driver/spinnakerdriver.h | 1 - 1 file changed, 1 deletion(-) diff --git a/src/driver/spinnakerdriver.h b/src/driver/spinnakerdriver.h index 0342c9e..d336d9e 100644 --- a/src/driver/spinnakerdriver.h +++ b/src/driver/spinnakerdriver.h @@ -14,7 +14,6 @@ limitations under the License. */ #pragma once -#define SPINNAKER #ifdef SPINNAKER #include "cameradriver.h" From 652ed9845d194475b86cd328395b5c63fe4ec18a Mon Sep 17 00:00:00 2001 From: Lixfel Date: Sat, 10 Oct 2026 09:46:29 +0200 Subject: [PATCH 5/7] Implement MVImpactDriver --- src/driver/mvimpactdriver.cpp | 91 +++++++++++++++++++++++++++++++++-- src/driver/mvimpactdriver.h | 20 +++++++- src/driver/opencvdriver.cpp | 6 +-- 3 files changed, 106 insertions(+), 11 deletions(-) diff --git a/src/driver/mvimpactdriver.cpp b/src/driver/mvimpactdriver.cpp index c01f703..3c5ce84 100644 --- a/src/driver/mvimpactdriver.cpp +++ b/src/driver/mvimpactdriver.cpp @@ -28,13 +28,14 @@ class MVImpactImage : public RawImage { }; -MVImpactDriver::MVImpactDriver(const CameraConfig& config) { - while(devMgr.deviceCount() <= config.hardwareId) { - WARN("Waiting for cam: " << devMgr.deviceCount() << "/" << (config.hardwareId+1)); +static mvIMPACT::acquire::Device* getDevice(int hardwareId) { + mvIMPACT::acquire::DeviceManager devMgr; + while(devMgr.deviceCount() <= hardwareId) { + WARN("Waiting for cam: " << devMgr.deviceCount() << "/" << (hardwareId+1)); sleep(1); devMgr.updateDeviceList(); } - device = devMgr[config.hardwareId]; + auto* device = devMgr[hardwareId]; device->userControlledImageProcessingEnable.write(TBoolean::bFalse); try { @@ -43,7 +44,10 @@ MVImpactDriver::MVImpactDriver(const CameraConfig& config) { FATAL("Error while opening the camera: " << e.getErrorCodeAsString() << " " << e.getErrorString()); } - SettingsBlueFOX settings(device); + return device; +} + +MVImpactDriver::MVImpactDriver(const CameraConfig& config): device(getDevice(config.hardwareId)), settings(device) { settings.cameraSetting.restoreDefault(); settings.imageProcessing.restoreDefault(); settings.imageDestination.restoreDefault(); @@ -117,5 +121,82 @@ double MVImpactDriver::expectedFrametime() { return 1 / GenICam::AcquisitionControl(device).mvResultingFrameRate.read(); } + +uint32_t MVImpactDriver::getWidth() { + return settings.imageDestination.imageWidth.read(); +} + +uint32_t MVImpactDriver::getHeight() { + return settings.imageDestination.imageHeight.read(); +} + +void MVImpactDriver::setResolution(uint32_t width, uint32_t height) { + settings.imageDestination.imageWidth.write(width); + settings.imageDestination.imageHeight.write(height); +} + +float MVImpactDriver::getExposure() { + return (float)settings.cameraSetting.expose_us.read() / 1000.0f; +} + +void MVImpactDriver::setExposure(float exposure) { + if(exposure == 0.0f) { + settings.cameraSetting.autoExposeControl.write(TAutoExposureControl::aecOn); + } else { + settings.cameraSetting.autoExposeControl.write(TAutoExposureControl::aecOff); + settings.cameraSetting.expose_us.write((int)(exposure * 1000)); + } +} + +float MVImpactDriver::getGain() { + return settings.cameraSetting.gain_dB.read(); +} + +void MVImpactDriver::setGain(float gain) { + if(gain == 0.0f) { + settings.cameraSetting.autoGainControl.write(TAutoGainControl::agcOn); + } else { + settings.cameraSetting.autoGainControl.write(TAutoGainControl::agcOff); + settings.cameraSetting.gain_dB.write(gain); + } +} + +float MVImpactDriver::getGamma() { + return 1.0f; // Unsupported? TODO +} + +void MVImpactDriver::setGamma(float gamma) { + // Unsupported? TODO +} + +WhiteBalanceType MVImpactDriver::getWhiteBalanceType() { + if(settings.imageProcessing.whiteBalanceCalibration.read() != TWhiteBalanceCalibrationMode::wbcmOff) { + return WhiteBalanceType::WhiteBalanceType_AutoOutdoor; + } else { + return WhiteBalanceType::WhiteBalanceType_Manual; + } +} + +float MVImpactDriver::getWhiteBalanceBlue() { + return settings.imageProcessing.getWBUserSetting(0).blueGain.read(); +} + +float MVImpactDriver::getWhiteBalanceRed() { + return settings.imageProcessing.getWBUserSetting(0).redGain.read(); +} + +void MVImpactDriver::setWhiteBalance(WhiteBalanceType type, float blue, float red) { + if(type != WhiteBalanceType_Manual) { + settings.imageProcessing.whiteBalanceCalibration.write(TWhiteBalanceCalibrationMode::wbcmContinuous); + } else { + settings.imageProcessing.whiteBalanceCalibration.write(TWhiteBalanceCalibrationMode::wbcmOff); + WhiteBalanceSettings& wb = settings.imageProcessing.getWBUserSetting(0); + wb.restoreDefault(); + wb.blueGain.write(blue); + wb.redGain.write(red); + settings.imageProcessing.whiteBalance.write(TWhiteBalanceParameter::wbpUser1); + } +} + #endif diff --git a/src/driver/mvimpactdriver.h b/src/driver/mvimpactdriver.h index eb69883..704c572 100644 --- a/src/driver/mvimpactdriver.h +++ b/src/driver/mvimpactdriver.h @@ -32,9 +32,27 @@ class MVImpactDriver : public CameraDriver { double expectedFrametime() override; + uint32_t getWidth() override; + uint32_t getHeight() override; + void setResolution(uint32_t width, uint32_t height) override; + + float getExposure() override; + void setExposure(float exposure) override; + + float getGain() override; + void setGain(float gain) override; + + float getGamma() override; + void setGamma(float gamma) override; + + WhiteBalanceType getWhiteBalanceType() override; + float getWhiteBalanceBlue() override; + float getWhiteBalanceRed() override; + void setWhiteBalance(WhiteBalanceType type, float blue, float red) override; + private: - mvIMPACT::acquire::DeviceManager devMgr; mvIMPACT::acquire::Device* device; + SettingsBlueFOX settings; std::unique_ptr provider; }; diff --git a/src/driver/opencvdriver.cpp b/src/driver/opencvdriver.cpp index bca2ecb..336c3f7 100644 --- a/src/driver/opencvdriver.cpp +++ b/src/driver/opencvdriver.cpp @@ -104,11 +104,7 @@ void OpenCVDriver::setResolution(uint32_t width, uint32_t height) { } float OpenCVDriver::getExposure() { - if(capture.get(cv::CAP_PROP_AUTO_EXPOSURE) == 1.0) { - return 0.0f; - } else { - return (float)capture.get(cv::CAP_PROP_EXPOSURE) / 1000.0f; - } + return (float)capture.get(cv::CAP_PROP_EXPOSURE) / 1000.0f; } void OpenCVDriver::setExposure(float exposure) { From 4de15ad1d76a685bc402a564c9ea974c017f0532 Mon Sep 17 00:00:00 2001 From: Lixfel Date: Mon, 12 Oct 2026 07:14:59 +0200 Subject: [PATCH 6/7] Finish port to new API --- src/Resources.cpp | 9 ++++- src/driver/mvimpactdriver.cpp | 36 +++----------------- src/driver/opencvdriver.cpp | 40 +++++----------------- src/driver/spinnakerdriver.cpp | 62 +++++++--------------------------- 4 files changed, 35 insertions(+), 112 deletions(-) diff --git a/src/Resources.cpp b/src/Resources.cpp index e5d713d..f486a99 100644 --- a/src/Resources.cpp +++ b/src/Resources.cpp @@ -74,7 +74,14 @@ Resources::Resources(const std::string& configPath) : fieldReference(), configPa configMtime = (int64_t)st.st_mtim.tv_sec * 1000000000 + st.st_mtim.tv_nsec; openCl = std::make_shared(); - camera = openCamera(CameraConfig(getOptional(config["camera"]))); + + CameraConfig camConfig(getOptional(config["camera"])); + camera = openCamera(camConfig); + camera->setResolution(camConfig.width, camConfig.height); + camera->setExposure(camConfig.exposure); + camera->setGain(camConfig.gain); + camera->setGamma(camConfig.gamma); + camera->setWhiteBalance(camConfig.whiteBalanceType, camConfig.whiteBalanceBlue, camConfig.whiteBalanceRed); camId = config["cam_id"].as(0); if (camId < 0 || camId > 7) { diff --git a/src/driver/mvimpactdriver.cpp b/src/driver/mvimpactdriver.cpp index 3c5ce84..77d6941 100644 --- a/src/driver/mvimpactdriver.cpp +++ b/src/driver/mvimpactdriver.cpp @@ -54,37 +54,6 @@ MVImpactDriver::MVImpactDriver(const CameraConfig& config): device(getDevice(con settings.cameraSetting.pixelFormat.write(TImageBufferPixelFormat::ibpfMono8); settings.imageDestination.pixelFormat.write(TImageDestinationPixelFormat::idpfRaw); - if(!config.autoResolution()) { - settings.imageDestination.imageWidth.write(config.width); - settings.imageDestination.imageHeight.write(config.height); - } - - if(config.autoExposure()) { - settings.cameraSetting.autoExposeControl.write(TAutoExposureControl::aecOn); - } else { - settings.cameraSetting.autoExposeControl.write(TAutoExposureControl::aecOff); - settings.cameraSetting.expose_us.write((int)(config.exposure * 1000)); - } - - if(config.autoGain()) { - settings.cameraSetting.autoGainControl.write(TAutoGainControl::agcOn); - } else { - settings.cameraSetting.autoGainControl.write(TAutoGainControl::agcOff); - settings.cameraSetting.gain_dB.write(config.gain); - } - - if(config.whiteBalanceType != WhiteBalanceType_Manual) { - settings.imageProcessing.whiteBalanceCalibration.write(TWhiteBalanceCalibrationMode::wbcmNextFrame); - } else { - settings.imageProcessing.whiteBalanceCalibration.write(TWhiteBalanceCalibrationMode::wbcmOff); - WhiteBalanceSettings& wb = settings.imageProcessing.getWBUserSetting(0); - wb.restoreDefault(); - wb.blueGain.write(config.whiteBalanceBlue); - wb.redGain.write(config.whiteBalanceRed); - settings.imageProcessing.whiteBalance.write(TWhiteBalanceParameter::wbpUser1); - } - - //TODO user supplied memory functionality to prevent copies https://wassets.balluff.com/documents/DRF_957352_AA_000/CaptureToUserMemory_8cpp-example.html provider = std::make_unique(device); @@ -131,6 +100,11 @@ uint32_t MVImpactDriver::getHeight() { } void MVImpactDriver::setResolution(uint32_t width, uint32_t height) { + if(width == 0 || height == 0) { + width = settings.imageDestination.imageWidth.getMaxValue(); + height = settings.imageDestination.imageHeight.getMaxValue(); + } + settings.imageDestination.imageWidth.write(width); settings.imageDestination.imageHeight.write(height); } diff --git a/src/driver/opencvdriver.cpp b/src/driver/opencvdriver.cpp index 336c3f7..1692403 100644 --- a/src/driver/opencvdriver.cpp +++ b/src/driver/opencvdriver.cpp @@ -22,37 +22,6 @@ OpenCVDriver::OpenCVDriver(const CameraConfig& config): capture(config.path, cv: // Use compressed data stream to unlock the highest resolution - framerate combination on USB2 cameras capture.set(cv::CAP_PROP_FOURCC, cv::VideoWriter::fourcc('M', 'J', 'P', 'G')); - - if(config.autoResolution()) { - capture.set(cv::CAP_PROP_FRAME_WIDTH, INT_MAX); - capture.set(cv::CAP_PROP_FRAME_HEIGHT, INT_MAX); - } else { - capture.set(cv::CAP_PROP_FRAME_WIDTH, config.width); - capture.set(cv::CAP_PROP_FRAME_HEIGHT, config.height); - } - - if(config.autoExposure()) { - capture.set(cv::CAP_PROP_AUTO_EXPOSURE, 1.0); - } else { - capture.set(cv::CAP_PROP_AUTO_EXPOSURE, 0.0); - capture.set(cv::CAP_PROP_EXPOSURE, config.exposure * 1000.0); - } - - if(!config.autoGain()) { - capture.set(cv::CAP_PROP_GAIN, config.gain); - } - - if(config.autoGamma()) { - capture.set(cv::CAP_PROP_GAMMA, config.gamma); - } - - if(config.whiteBalanceType != WhiteBalanceType_Manual) { - capture.set(cv::CAP_PROP_AUTO_WB, 1.0); - } else { - capture.set(cv::CAP_PROP_AUTO_WB, 0.0); - capture.set(cv::CAP_PROP_WHITE_BALANCE_BLUE_U, config.whiteBalanceBlue); - capture.set(cv::CAP_PROP_WHITE_BALANCE_RED_V, config.whiteBalanceRed); - } } std::shared_ptr OpenCVDriver::readImage() { @@ -99,6 +68,11 @@ uint32_t OpenCVDriver::getHeight() { } void OpenCVDriver::setResolution(uint32_t width, uint32_t height) { + if(width == 0 || height == 0) { + width = INT_MAX; + height = INT_MAX; + } + capture.set(cv::CAP_PROP_FRAME_WIDTH, width); capture.set(cv::CAP_PROP_FRAME_HEIGHT, height); } @@ -122,6 +96,10 @@ float OpenCVDriver::getGain() { } void OpenCVDriver::setGain(float gain) { + if(gain == 0.0f) { + gain = -1.0f; + } + capture.set(cv::CAP_PROP_GAIN, gain); } diff --git a/src/driver/spinnakerdriver.cpp b/src/driver/spinnakerdriver.cpp index 62fe92a..778ed75 100644 --- a/src/driver/spinnakerdriver.cpp +++ b/src/driver/spinnakerdriver.cpp @@ -64,55 +64,6 @@ SpinnakerDriver::SpinnakerDriver(const CameraConfig& config) { CATCH_SPINNAKER(pCam->PixelFormat.SetValue(Spinnaker::PixelFormat_BayerRG8)) CATCH_SPINNAKER(pCam->AcquisitionFrameRateEnable.SetValue(false)) - if(config.autoResolution()) { - CATCH_SPINNAKER(pCam->Width.SetValue(pCam->WidthMax.GetValue())); - CATCH_SPINNAKER(pCam->Height.SetValue(pCam->HeightMax.GetValue())); - } else { - CATCH_SPINNAKER(pCam->Width.SetValue(config.width)); - CATCH_SPINNAKER(pCam->Height.SetValue(config.height)); - } - - if(config.autoExposure()) { - CATCH_SPINNAKER(pCam->AutoExposureMeteringMode.SetValue(Spinnaker::AutoExposureMeteringMode_Average)) - CATCH_SPINNAKER(pCam->ExposureAuto.SetValue(Spinnaker::ExposureAuto_Continuous)) - } else { - CATCH_SPINNAKER(pCam->ExposureAuto.SetValue(Spinnaker::ExposureAuto_Off)) - CATCH_SPINNAKER(pCam->ExposureTime.SetValue(config.exposure * 1000.0)) - } - - if(config.autoGain()) { - CATCH_SPINNAKER(pCam->GainAuto.SetValue(Spinnaker::GainAuto_Continuous)) - } else { - CATCH_SPINNAKER(pCam->GainAuto.SetValue(Spinnaker::GainAuto_Off)) - CATCH_SPINNAKER(pCam->Gain.SetValue(config.gain)) - } - - if(config.autoExposure() && config.autoGain()) { - CATCH_SPINNAKER(pCam->AutoExposureControlPriority.SetValue(Spinnaker::AutoExposureControlPriority_Gain)) - } - - if(config.autoGamma()) { - CATCH_SPINNAKER(pCam->GammaEnable.SetValue(false)) - } else { - CATCH_SPINNAKER(pCam->GammaEnable.SetValue(true)) - CATCH_SPINNAKER(pCam->Gamma.SetValue((float)config.gamma)) - } - - if(config.whiteBalanceType != WhiteBalanceType_Manual) { - CATCH_SPINNAKER(pCam->BalanceWhiteAuto.SetValue(Spinnaker::BalanceWhiteAuto_Continuous)) - CATCH_SPINNAKER(pCam->BalanceWhiteAutoProfile.SetValue( - config.whiteBalanceType == WhiteBalanceType_AutoOutdoor - ? Spinnaker::BalanceWhiteAutoProfile_Outdoor - : Spinnaker::BalanceWhiteAutoProfile_Indoor - )) - } else { - CATCH_SPINNAKER(pCam->BalanceWhiteAuto.SetValue(Spinnaker::BalanceWhiteAuto_Off)) - CATCH_SPINNAKER(pCam->BalanceRatioSelector.SetValue(Spinnaker::BalanceRatioSelector_Blue)) - CATCH_SPINNAKER(pCam->BalanceRatio.SetValue(config.whiteBalanceBlue)) - CATCH_SPINNAKER(pCam->BalanceRatioSelector.SetValue(Spinnaker::BalanceRatioSelector_Red)) - CATCH_SPINNAKER(pCam->BalanceRatio.SetValue(config.whiteBalanceRed)) - } - pCam->TLStream.StreamBufferHandlingMode.SetValue(Spinnaker::StreamBufferHandlingMode_NewestOnly); pCam->TLStream.StreamBufferCountManual.SetValue(pCam->TLStream.StreamBufferCountManual.GetMin()); @@ -189,6 +140,11 @@ uint32_t SpinnakerDriver::getHeight() { } void SpinnakerDriver::setResolution(uint32_t width, uint32_t height) { + if(width == 0 || height == 0) { + width = pCam->WidthMax.GetValue(); + height = pCam->HeightMax.GetValue(); + } + CATCH_SPINNAKER(pCam->Width.SetValue(width)); CATCH_SPINNAKER(pCam->Height.SetValue(height)); } @@ -201,6 +157,10 @@ void SpinnakerDriver::setExposure(float exposure) { if(exposure == 0.0f) { CATCH_SPINNAKER(pCam->ExposureAuto.SetValue(Spinnaker::ExposureAuto_Continuous)); CATCH_SPINNAKER(pCam->AutoExposureMeteringMode.SetValue(Spinnaker::AutoExposureMeteringMode_Average)); + + if(pCam->GainAuto.GetValue() == Spinnaker::GainAuto_Continuous) { + CATCH_SPINNAKER(pCam->AutoExposureControlPriority.SetValue(Spinnaker::AutoExposureControlPriority_Gain)); + } } else { CATCH_SPINNAKER(pCam->ExposureAuto.SetValue(Spinnaker::ExposureAuto_Off)) CATCH_SPINNAKER(pCam->ExposureTime.SetValue(exposure * 1000.0f)) @@ -214,6 +174,10 @@ float SpinnakerDriver::getGain() { void SpinnakerDriver::setGain(float gain) { if(gain == 0.0f) { CATCH_SPINNAKER(pCam->GainAuto.SetValue(Spinnaker::GainAuto_Continuous)); + + if(pCam->ExposureAuto.GetValue() == Spinnaker::ExposureAuto_Continuous) { + CATCH_SPINNAKER(pCam->AutoExposureControlPriority.SetValue(Spinnaker::AutoExposureControlPriority_Gain)); + } } else { CATCH_SPINNAKER(pCam->GainAuto.SetValue(Spinnaker::GainAuto_Off)); CATCH_SPINNAKER(pCam->Gain.SetValue(gain)); From 21b413991ff3679a789be65da4482b64f7c4a394 Mon Sep 17 00:00:00 2001 From: Lixfel Date: Sun, 18 Oct 2026 15:57:31 +0200 Subject: [PATCH 7/7] Fix builds with newest libprotobuf/libabsl and protocol --- cmake/FindSpinnaker.cmake | 2 +- cmake/FindmvIMPACT.cmake | 2 +- src/Perspective.cpp | 4 ++-- src/Resources.cpp | 2 +- src/calib/Distortion.cpp | 2 +- src/calib/GeomModel.cpp | 8 ++++---- src/driver/cameradriver.cpp | 8 ++++---- src/driver/mvimpactdriver.cpp | 2 +- src/driver/mvimpactdriver.h | 2 +- src/driver/spinnakerdriver.cpp | 4 ++-- src/driver/spinnakerdriver.h | 2 +- src/log.h | 2 +- src/main.cpp | 8 ++++---- src/opencl.cpp | 2 +- src/rtpstreamer.cpp | 2 +- src/udpsocket.cpp | 6 +++--- 16 files changed, 29 insertions(+), 29 deletions(-) diff --git a/cmake/FindSpinnaker.cmake b/cmake/FindSpinnaker.cmake index 33dcaeb..b446ebf 100644 --- a/cmake/FindSpinnaker.cmake +++ b/cmake/FindSpinnaker.cmake @@ -34,7 +34,7 @@ if (WITH_SPINNAKER) SPINNAKER_LIBS STREQUAL "SPINNAKER_LIBS-NOTFOUND" OR SPINNAKER_INCLUDE_DIRS STREQUAL "SPINNAKER_INCLUDE_DIRS-NOTFOUND" )) - add_definitions( -DSPINNAKER ) + add_definitions( -DSPINNAKER_AVAILABLE ) message(STATUS "Spinnaker found, activating Spinnaker support.") else() set(SPINNAKER_INCLUDE_DIRS "") diff --git a/cmake/FindmvIMPACT.cmake b/cmake/FindmvIMPACT.cmake index 0796a96..968ac31 100644 --- a/cmake/FindmvIMPACT.cmake +++ b/cmake/FindmvIMPACT.cmake @@ -30,7 +30,7 @@ if (WITH_MVIMPACT) mvIMPACT_LIBS STREQUAL "mvIMPACT_LIBS-NOTFOUND" OR mvIMPACT_INCLUDE_DIRS STREQUAL "mvIMPACT_INCLUDE_DIRS-NOTFOUND" )) - add_definitions( -DMVIMPACT ) + add_definitions( -DMVIMPACT_AVAILABLE ) message(STATUS "mvIMPACT found, activating mvIMPACT support.") else() set(mvIMPACT_INCLUDE_DIRS "") diff --git a/src/Perspective.cpp b/src/Perspective.cpp index 88fc33f..1172393 100644 --- a/src/Perspective.cpp +++ b/src/Perspective.cpp @@ -89,7 +89,7 @@ void Perspective::geometryCheck(const int width, const int height, const double } } fieldScale = fieldScaleSum / (float)n * resamplingFactor; - LOG("Field scale: " << minFieldScale << "mm/px < " << fieldScale << "mm/px < " << maxFieldScale << "mm/px"); + VP_LOG("Field scale: " << minFieldScale << "mm/px < " << fieldScale << "mm/px < " << maxFieldScale << "mm/px"); //update visibleFieldExtent Eigen::Vector2f center = model.image2field({0.0f, 0.0f}, (float)maxBotHeight).head<2>(); @@ -121,7 +121,7 @@ void Perspective::geometryCheck(const int width, const int height, const double if(reprojectedFieldSize[1] % 2) reprojectedFieldSize[1]++; - LOG("Visible field extent: " << visibleFieldExtent.transpose() << "mm (xmin,xmax,ymin,ymax) Field scale: " << fieldScale << "mm/px"); + VP_LOG("Visible field extent: " << visibleFieldExtent.transpose() << "mm (xmin,xmax,ymin,ymax) Field scale: " << fieldScale << "mm/px"); } Eigen::Vector2f Perspective::flat2field(const Eigen::Vector2f& pos) const { diff --git a/src/Resources.cpp b/src/Resources.cpp index e5d713d..eacab4e 100644 --- a/src/Resources.cpp +++ b/src/Resources.cpp @@ -230,7 +230,7 @@ void Resources::reloadConfigIfChanged() { try { YAML::Node config = YAML::LoadFile(configPath); applyTunables(config); - LOG("Reloaded tunables from " << configPath); + VP_LOG("Reloaded tunables from " << configPath); } catch(const YAML::Exception& e) { WARN("Config reload failed, keeping previous values: " << e.what()); } diff --git a/src/calib/Distortion.cpp b/src/calib/Distortion.cpp index e337f21..b69dfff 100644 --- a/src/calib/Distortion.cpp +++ b/src/calib/Distortion.cpp @@ -114,7 +114,7 @@ bool calibrateDistortion(const std::vector>& linePo lm.minimize(k); if((k(1) < 0.0f || k(2) < 0.0f || k(1) >= model.size.x() || k(2) >= model.size.y())) { - LOG("Principal point outside of image, aborting calibration for this frame"); + VP_LOG("Principal point outside of image, aborting calibration for this frame"); return false; } diff --git a/src/calib/GeomModel.cpp b/src/calib/GeomModel.cpp index f6410b2..aa40e4c 100644 --- a/src/calib/GeomModel.cpp +++ b/src/calib/GeomModel.cpp @@ -497,7 +497,7 @@ void geometryCalibration(const Resources& r, const CLImage& rgba) { const int halfLineWidth = halfLineWidthEstimation(r, gray); diag.half_line_width = halfLineWidth; - LOG("Half line width: " << halfLineWidth); + VP_LOG("Half line width: " << halfLineWidth); cv::Mat thresholded(gray.rows, gray.cols, CV_8UC1, 0.0); thresholdImage(r, gray, halfLineWidth, thresholded); @@ -520,12 +520,12 @@ void geometryCalibration(const Resources& r, const CLImage& rgba) { lines.emplace_back(a, b); } diag.raw_line_segments = (int)lines.size(); - LOG("Line segments: " << lines.size()); + VP_LOG("Line segments: " << lines.size()); const std::vector compoundLines = groupLineSegments(r, lines); const CVLines mergedLines = mergeLineSegments(compoundLines); diag.merged_line_count = (int)mergedLines.size(); - LOG("Lines: " << mergedLines.size()); + VP_LOG("Lines: " << mergedLines.size()); std::vector> mergedPixels(mergedLines.size()); { @@ -568,7 +568,7 @@ void geometryCalibration(const Resources& r, const CLImage& rgba) { model.updateDerived(); int error = modelError(r, model, linePixels); - LOG("Best model: " << model << " error " << (error/(float)linePixels.size())); + VP_LOG("Best model: " << model << " error " << (error/(float)linePixels.size())); diag.focal_length = model.focalLength; diag.position = model.pos; diff --git a/src/driver/cameradriver.cpp b/src/driver/cameradriver.cpp index e37ad87..8fea83b 100644 --- a/src/driver/cameradriver.cpp +++ b/src/driver/cameradriver.cpp @@ -16,10 +16,10 @@ #include "cameradriver.h" #include "driver/opencvdriver.h" -#ifdef SPINNAKER +#ifdef SPINNAKER_AVAILABLE #include "driver/spinnakerdriver.h" #endif -#ifdef MVIMPACT +#ifdef MVIMPACT_AVAILABLE #include "driver/mvimpactdriver.h" #endif @@ -76,12 +76,12 @@ bool CameraConfig::autoGamma() const { std::unique_ptr openCamera(const CameraConfig& config) { -#ifdef SPINNAKER +#ifdef SPINNAKER_AVAILABLE if(config.driverType == "SPINNAKER") return std::make_unique(config); #endif -#ifdef MVIMPACT +#ifdef MVIMPACT_AVAILABLE if(config.driverType == "MVIMPACT") return std::make_unique(config); #endif diff --git a/src/driver/mvimpactdriver.cpp b/src/driver/mvimpactdriver.cpp index c01f703..9de3f89 100644 --- a/src/driver/mvimpactdriver.cpp +++ b/src/driver/mvimpactdriver.cpp @@ -13,7 +13,7 @@ See the License for the specific language governing permissions and limitations under the License. */ -#ifdef MVIMPACT +#ifdef MVIMPACT_AVAILABLE #include "mvimpactdriver.h" #include diff --git a/src/driver/mvimpactdriver.h b/src/driver/mvimpactdriver.h index eb69883..b8bc58a 100644 --- a/src/driver/mvimpactdriver.h +++ b/src/driver/mvimpactdriver.h @@ -14,7 +14,7 @@ limitations under the License. */ #pragma once -#ifdef MVIMPACT +#ifdef MVIMPACT_AVAILABLE #include "cameradriver.h" #include diff --git a/src/driver/spinnakerdriver.cpp b/src/driver/spinnakerdriver.cpp index 545ab52..ce86e51 100644 --- a/src/driver/spinnakerdriver.cpp +++ b/src/driver/spinnakerdriver.cpp @@ -13,7 +13,7 @@ See the License for the specific language governing permissions and limitations under the License. */ -#ifdef SPINNAKER +#ifdef SPINNAKER_AVAILABLE #include "spinnakerdriver.h" @@ -44,7 +44,7 @@ SpinnakerDriver::SpinnakerDriver(const CameraConfig& config) { if (camList.GetSize() > config.hardwareId) { pCam = camList.GetByIndex(config.hardwareId); pCam->Init(); - LOG("Opened " << pCam->DeviceModelName.GetValue() << " - " << pCam->DeviceSerialNumber.GetValue().c_str()); + VP_LOG("Opened " << pCam->DeviceModelName.GetValue() << " - " << pCam->DeviceSerialNumber.GetValue().c_str()); camList.Clear(); break; } diff --git a/src/driver/spinnakerdriver.h b/src/driver/spinnakerdriver.h index af0d52b..fd6be82 100644 --- a/src/driver/spinnakerdriver.h +++ b/src/driver/spinnakerdriver.h @@ -14,7 +14,7 @@ limitations under the License. */ #pragma once -#ifdef SPINNAKER +#ifdef SPINNAKER_AVAILABLE #include "cameradriver.h" #include "Spinnaker.h" diff --git a/src/log.h b/src/log.h index 77185b2..a289b11 100644 --- a/src/log.h +++ b/src/log.h @@ -16,6 +16,6 @@ #pragma once #include -#define LOG(data) std::cout << "[" << __FILE__ << ":" << __LINE__ << "] " << data << std::endl +#define VP_LOG(data) std::cout << "[" << __FILE__ << ":" << __LINE__ << "] " << data << std::endl #define WARN(data) std::cerr << "[" << __FILE__ << ":" << __LINE__ << "] " << data << std::endl #define FATAL(data) { WARN(data); exit(1); } diff --git a/src/main.cpp b/src/main.cpp index 7a0baa5..047b169 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -362,7 +362,7 @@ int main(int argc, char* argv[]) { #if BENCHMARK detection->set_t_sent(startTime + processingTime); - LOG("time " << processingTime * 1000.0 << " ms " << matches.size() << " blobs " << detection->balls().size() << " balls " << (detection->robots_yellow_size() + detection->robots_blue_size()) << " bots"); + VP_LOG("time " << processingTime * 1000.0 << " ms " << matches.size() << " blobs " << detection->balls().size() << " balls " << (detection->robots_yellow_size() + detection->robots_blue_size()) << " bots"); r.openCl->printRuntimes(); #else detection->set_t_sent(r.camera->getTime()); @@ -372,7 +372,7 @@ int main(int argc, char* argv[]) { r.openCl->clearEvents(); if(processingTime > r.camera->expectedFrametime()) - LOG("frame time overrun: " << processingTime * 1000.0 << " ms " << matches.size() << " blobs " << detection->balls().size() << " balls " << (detection->robots_yellow_size() + detection->robots_blue_size()) << " bots"); + VP_LOG("frame time overrun: " << processingTime * 1000.0 << " ms " << matches.size() << " blobs " << detection->balls().size() << " balls " << (detection->robots_yellow_size() + detection->robots_blue_size()) << " bots"); if(r.rawFeed) { r.streamQuad(channels); @@ -417,11 +417,11 @@ int main(int argc, char* argv[]) { r.snapshotWriter->offer(r.quad2rgba(channels), "img/" + std::to_string(r.camId) + ".raw.jpg"); lastDebugSaveTime = realStartTime; if(frameId == 100) - LOG("Saved sample image"); + VP_LOG("Saved sample image"); } } } - LOG("Stopping vision_processor"); + VP_LOG("Stopping vision_processor"); return 0; } diff --git a/src/opencl.cpp b/src/opencl.cpp index dbe0465..31c3379 100644 --- a/src/opencl.cpp +++ b/src/opencl.cpp @@ -57,7 +57,7 @@ bool OpenCL::searchDevice(const std::vector& platforms, cl_device_ for(cl::Device& d : devices) { device = d; - LOG("Using device: " << platform.getInfo() << " » " << device.getInfo()); + VP_LOG("Using device: " << platform.getInfo() << " » " << device.getInfo()); return true; } } diff --git a/src/rtpstreamer.cpp b/src/rtpstreamer.cpp index e975431..00da74f 100644 --- a/src/rtpstreamer.cpp +++ b/src/rtpstreamer.cpp @@ -97,7 +97,7 @@ void RTPStreamer::allocResources() { FATAL("Failed to find suitable encoder."); } - LOG("Using codec: " << codec->long_name); + VP_LOG("Using codec: " << codec->long_name); fmtCtx = avformat_alloc_context(); auto* avFormat = (AVOutputFormat*)av_guess_format("rtp", nullptr, nullptr); diff --git a/src/udpsocket.cpp b/src/udpsocket.cpp index 990e5d6..77f57e2 100644 --- a/src/udpsocket.cpp +++ b/src/udpsocket.cpp @@ -124,7 +124,7 @@ void VisionSocket::geometryCheck() { ballRadius = geometry.field().ball_radius(); geometryVersion++; - LOG("New geometry received"); + VP_LOG("New geometry received"); } geometryMutex.unlock(); } @@ -319,11 +319,11 @@ void GCSocket::parse(char *data, int length) { if(botHeights.find(referee.yellow().name()) != botHeights.end() && botHeights[referee.yellow().name()] != yellowBotHeight) { yellowBotHeight = botHeights[referee.yellow().name()]; - LOG("Updated yellow bot height to " << yellowBotHeight << "mm"); + VP_LOG("Updated yellow bot height to " << yellowBotHeight << "mm"); } if(botHeights.find(referee.blue().name()) != botHeights.end() && botHeights[referee.blue().name()] != blueBotHeight) { blueBotHeight = botHeights[referee.blue().name()]; - LOG("Updated blue bot height to " << blueBotHeight << "mm"); + VP_LOG("Updated blue bot height to " << blueBotHeight << "mm"); } }