711 lines
23 KiB
C++
711 lines
23 KiB
C++
|
//--------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\file WhiteBalance.cpp
|
||
|
|
\brief CWhiteBalance Class implementation file
|
||
|
|
|
||
|
|
\version v1.0.1807.9271
|
||
|
|
\date 2018-07-27
|
||
|
|
|
||
|
|
<p>Copyright (c) 2017-2018</p>
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
#include "WhiteBalance.h"
|
||
|
|
#include "ui_WhiteBalance.h"
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\Constructor of CWhiteBalance
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
CWhiteBalance::CWhiteBalance(QWidget *parent) :
|
||
|
|
QDialog(parent),
|
||
|
|
ui(new Ui::CWhiteBalance),
|
||
|
|
m_hDevice(NULL),
|
||
|
|
m_i64AWBWidthInc(0),
|
||
|
|
m_i64AWBHeightInc(0),
|
||
|
|
m_i64AWBOffsetXInc(0),
|
||
|
|
m_i64AWBOffsetYInc(0),
|
||
|
|
m_pWhiteBalanceTimer(NULL)
|
||
|
|
{
|
||
|
|
ui->setupUi(this);
|
||
|
|
|
||
|
|
QFont font = this->font();
|
||
|
|
font.setPointSize(10);
|
||
|
|
this->setFont(font);
|
||
|
|
|
||
|
|
//This property holds the way the widget accepts keyboard focus.
|
||
|
|
//Avoid other focus policy which will exit this dialog by every time pressing "Enter"
|
||
|
|
ui->WhiteBalance_Close->setFocusPolicy(Qt::NoFocus);
|
||
|
|
|
||
|
|
// Close when Mainwindow is closed
|
||
|
|
this->setAttribute(Qt::WA_QuitOnClose, false);
|
||
|
|
|
||
|
|
// Set all spinbox do not emit the valueChanged() signal while typing.
|
||
|
|
QObjectList pobjGroupList = this->children();
|
||
|
|
foreach (QObject *pobjGroup, pobjGroupList)
|
||
|
|
{
|
||
|
|
QObjectList pobjItemList = pobjGroup->children();
|
||
|
|
QAbstractSpinBox *pobjSpinbox;
|
||
|
|
foreach (QObject *pobjItem, pobjItemList)
|
||
|
|
{
|
||
|
|
pobjSpinbox = qobject_cast<QAbstractSpinBox*>(pobjItem);
|
||
|
|
if (pobjSpinbox)
|
||
|
|
{
|
||
|
|
pobjSpinbox->setKeyboardTracking(false);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Setup auto change parameter refresh timer
|
||
|
|
m_pWhiteBalanceTimer = new QTimer(this);
|
||
|
|
connect(m_pWhiteBalanceTimer, SIGNAL(timeout()), this, SLOT(WhiteBalanceRatioUpdate()));
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\Destructor of CWhiteBalance
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
CWhiteBalance::~CWhiteBalance()
|
||
|
|
{
|
||
|
|
RELEASE_ALLOC_MEM(m_pWhiteBalanceTimer)
|
||
|
|
|
||
|
|
ClearUI();
|
||
|
|
|
||
|
|
delete ui;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ Close this dialog
|
||
|
|
\param[in]
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CWhiteBalance::on_WhiteBalance_Close_clicked()
|
||
|
|
{
|
||
|
|
this->close();
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\Clear ComboBox Items
|
||
|
|
\param[in]
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CWhiteBalance::ClearUI()
|
||
|
|
{
|
||
|
|
// Clear ComboBox items
|
||
|
|
ui->BalanceRatioSelector->clear();
|
||
|
|
ui->WhiteBalanceAuto->clear();
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ Enable all UI Groups
|
||
|
|
\param[in]
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CWhiteBalance::EnableUI()
|
||
|
|
{
|
||
|
|
// Release item signals
|
||
|
|
QObjectList pobjGroupList = this->children();
|
||
|
|
foreach (QObject *pobjGroup, pobjGroupList)
|
||
|
|
{
|
||
|
|
QObjectList pobjItemList = pobjGroup->children();
|
||
|
|
foreach (QObject *pobjItem, pobjItemList)
|
||
|
|
{
|
||
|
|
pobjItem->blockSignals(false);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
ui->Balance_White->setEnabled(true);
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ Disable all UI Groups
|
||
|
|
\param[in]
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CWhiteBalance::DisableUI()
|
||
|
|
{
|
||
|
|
// Block item signals
|
||
|
|
QObjectList pobjGroupList = this->children();
|
||
|
|
foreach (QObject *pobjGroup, pobjGroupList)
|
||
|
|
{
|
||
|
|
QObjectList pobjItemList = pobjGroup->children();
|
||
|
|
foreach (QObject *pobjItem, pobjItemList)
|
||
|
|
{
|
||
|
|
pobjItem->blockSignals(true);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
ui->Balance_White->setEnabled(false);
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ Update AWBROI UI Item range
|
||
|
|
\param[in]
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CWhiteBalance::AWBROIRangeUpdate()
|
||
|
|
{
|
||
|
|
GX_STATUS emStatus = GX_STATUS_SUCCESS;
|
||
|
|
GX_INT_RANGE stIntRange;
|
||
|
|
|
||
|
|
// Get the range of AWBROI width
|
||
|
|
emStatus = GXGetIntRange(m_hDevice, GX_INT_AWBROI_WIDTH, &stIntRange);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
// Storage step of this parameter for input correction
|
||
|
|
m_i64AWBWidthInc = stIntRange.nInc;
|
||
|
|
|
||
|
|
// Set Range to UI Items
|
||
|
|
ui->AWBROIWidthSlider->setRange(stIntRange.nMin, stIntRange.nMax);
|
||
|
|
ui->AWBROIWidthSpin->setRange(stIntRange.nMin, stIntRange.nMax);
|
||
|
|
ui->AWBROIWidthSlider->setSingleStep(stIntRange.nInc);
|
||
|
|
ui->AWBROIWidthSlider->setPageStep(0);
|
||
|
|
ui->AWBROIWidthSpin->setSingleStep(stIntRange.nInc);
|
||
|
|
ui->AWBROIWidthSpin->setToolTip(QString("(Min:%1 Max:%2 Inc:%3)")
|
||
|
|
.arg(stIntRange.nMin)
|
||
|
|
.arg(stIntRange.nMax)
|
||
|
|
.arg(stIntRange.nInc));
|
||
|
|
ui->AWBROIWidthSlider->setToolTip(QString("(Min:%1 Max:%2 Inc:%3)")
|
||
|
|
.arg(stIntRange.nMin)
|
||
|
|
.arg(stIntRange.nMax)
|
||
|
|
.arg(stIntRange.nInc));
|
||
|
|
|
||
|
|
// Get the range of AWBROI height
|
||
|
|
emStatus = GXGetIntRange(m_hDevice, GX_INT_AWBROI_HEIGHT, &stIntRange);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
// Storage step of this parameter for input correction
|
||
|
|
m_i64AWBHeightInc = stIntRange.nInc;
|
||
|
|
|
||
|
|
// Set Range to UI Items
|
||
|
|
ui->AWBROIHeightSlider->setRange(stIntRange.nMin, stIntRange.nMax);
|
||
|
|
ui->AWBROIHeightSpin->setRange(stIntRange.nMin, stIntRange.nMax);
|
||
|
|
ui->AWBROIHeightSlider->setSingleStep(stIntRange.nInc);
|
||
|
|
ui->AWBROIHeightSlider->setPageStep(0);
|
||
|
|
ui->AWBROIHeightSpin->setSingleStep(stIntRange.nInc);
|
||
|
|
ui->AWBROIHeightSpin->setToolTip(QString("(Min:%1 Max:%2 Inc:%3)")
|
||
|
|
.arg(stIntRange.nMin)
|
||
|
|
.arg(stIntRange.nMax)
|
||
|
|
.arg(stIntRange.nInc));
|
||
|
|
ui->AWBROIHeightSlider->setToolTip(QString("(Min:%1 Max:%2 Inc:%3)")
|
||
|
|
.arg(stIntRange.nMin)
|
||
|
|
.arg(stIntRange.nMax)
|
||
|
|
.arg(stIntRange.nInc));
|
||
|
|
|
||
|
|
// Get the range of AWBROI offsetx
|
||
|
|
emStatus = GXGetIntRange(m_hDevice, GX_INT_AWBROI_OFFSETX, &stIntRange);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
// Storage step of this parameter for input correction
|
||
|
|
m_i64AWBOffsetXInc = stIntRange.nInc;
|
||
|
|
|
||
|
|
// Set Range to UI Items
|
||
|
|
ui->AWBROIOffsetXSlider->setRange(stIntRange.nMin, stIntRange.nMax);
|
||
|
|
ui->AWBROIOffsetXSpin->setRange(stIntRange.nMin, stIntRange.nMax);
|
||
|
|
ui->AWBROIOffsetXSlider->setSingleStep(stIntRange.nInc);
|
||
|
|
ui->AWBROIOffsetXSlider->setPageStep(0);
|
||
|
|
ui->AWBROIOffsetXSpin->setSingleStep(stIntRange.nInc);
|
||
|
|
ui->AWBROIOffsetXSpin->setToolTip(QString("(Min:%1 Max:%2 Inc:%3)")
|
||
|
|
.arg(stIntRange.nMin)
|
||
|
|
.arg(stIntRange.nMax)
|
||
|
|
.arg(stIntRange.nInc));
|
||
|
|
ui->AWBROIOffsetXSlider->setToolTip(QString("(Min:%1 Max:%2 Inc:%3)")
|
||
|
|
.arg(stIntRange.nMin)
|
||
|
|
.arg(stIntRange.nMax)
|
||
|
|
.arg(stIntRange.nInc));
|
||
|
|
|
||
|
|
// Get the range of AWBROI offsety
|
||
|
|
emStatus = GXGetIntRange(m_hDevice, GX_INT_AWBROI_OFFSETY, &stIntRange);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
// Storage step of this parameter for input correction
|
||
|
|
m_i64AWBOffsetYInc = stIntRange.nInc;
|
||
|
|
|
||
|
|
// Set Range to UI Items
|
||
|
|
ui->AWBROIOffsetYSlider->setRange(stIntRange.nMin, stIntRange.nMax);
|
||
|
|
ui->AWBROIOffsetYSpin->setRange(stIntRange.nMin, stIntRange.nMax);
|
||
|
|
ui->AWBROIOffsetYSlider->setSingleStep(stIntRange.nInc);
|
||
|
|
ui->AWBROIOffsetYSlider->setPageStep(0);
|
||
|
|
ui->AWBROIOffsetYSpin->setSingleStep(stIntRange.nInc);
|
||
|
|
ui->AWBROIOffsetYSpin->setToolTip(QString("(Min:%1 Max:%2 Inc:%3)")
|
||
|
|
.arg(stIntRange.nMin)
|
||
|
|
.arg(stIntRange.nMax)
|
||
|
|
.arg(stIntRange.nInc));
|
||
|
|
ui->AWBROIOffsetYSlider->setToolTip(QString("(Min:%1 Max:%2 Inc:%3)")
|
||
|
|
.arg(stIntRange.nMin)
|
||
|
|
.arg(stIntRange.nMax)
|
||
|
|
.arg(stIntRange.nInc));
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ Get device handle from mainwindow, and get param for this dialog
|
||
|
|
\param[in] hDeviceHandle Device handle
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CWhiteBalance::GetDialogInitParam(GX_DEV_HANDLE hDeviceHandle)
|
||
|
|
{
|
||
|
|
// Device handle transfered and storaged
|
||
|
|
m_hDevice = hDeviceHandle;
|
||
|
|
GX_STATUS emStatus = GX_STATUS_SUCCESS;
|
||
|
|
|
||
|
|
// Clear Dialog Items
|
||
|
|
ClearUI();
|
||
|
|
|
||
|
|
// Disable all UI items and block signals
|
||
|
|
DisableUI();
|
||
|
|
|
||
|
|
// Init balance ratio selector combobox entrys
|
||
|
|
emStatus = InitComboBox(m_hDevice, ui->BalanceRatioSelector, GX_ENUM_BALANCE_RATIO_SELECTOR);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
// Init white balance auto combobox entrys
|
||
|
|
emStatus = InitComboBox(m_hDevice, ui->WhiteBalanceAuto, GX_ENUM_BALANCE_WHITE_AUTO);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
// If auto mode is on, start a timer to refresh new value and disable value edit manually
|
||
|
|
if (ui->WhiteBalanceAuto->itemData(ui->WhiteBalanceAuto->currentIndex()).value<int64_t>() != GX_BALANCE_WHITE_AUTO_OFF)
|
||
|
|
{
|
||
|
|
// Refresh interval 100ms
|
||
|
|
const int nAWBRefreshInterval = 100;
|
||
|
|
m_pWhiteBalanceTimer->start(nAWBRefreshInterval);
|
||
|
|
ui->BalanceRatioSpin->setEnabled(false);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
m_pWhiteBalanceTimer->stop();
|
||
|
|
ui->BalanceRatioSpin->setEnabled(true);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Get balance ratio for current channel
|
||
|
|
double dBalanceRatio = 0;
|
||
|
|
emStatus = GXGetFloat(m_hDevice, GX_FLOAT_BALANCE_RATIO, &dBalanceRatio);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
// Get the range of balance ratio
|
||
|
|
GX_FLOAT_RANGE stFloatRange;
|
||
|
|
emStatus = GXGetFloatRange(m_hDevice, GX_FLOAT_BALANCE_RATIO, &stFloatRange);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
// Set Range to UI Items
|
||
|
|
ui->BalanceRatioSpin->setRange(stFloatRange.dMin, stFloatRange.dMax);
|
||
|
|
ui->BalanceRatioSpin->setDecimals(WHITEBALANCE_DECIMALS);
|
||
|
|
ui->BalanceRatioSpin->setSingleStep(WHITEBALANCE_INCREMENT);
|
||
|
|
ui->BalanceRatioSpin->setToolTip(QString("(Min:%1 Max:%2 Inc:%3)")
|
||
|
|
.arg(stFloatRange.dMin, 0, 'f', 1)
|
||
|
|
.arg(stFloatRange.dMax, 0, 'f', 1)
|
||
|
|
.arg(WHITEBALANCE_INCREMENT));
|
||
|
|
|
||
|
|
// Set value to UI Items
|
||
|
|
ui->BalanceRatioSpin->setValue(dBalanceRatio);
|
||
|
|
|
||
|
|
int64_t i64AWBROIWidth = 0;
|
||
|
|
int64_t i64AWBROIHeight = 0;
|
||
|
|
int64_t i64AWBROIOffsetX = 0;
|
||
|
|
int64_t i64AWBROIOffsetY = 0;
|
||
|
|
|
||
|
|
int64_t emRegionSendMode = GX_REGION_SEND_SINGLE_ROI_MODE;
|
||
|
|
bool bRegionMode = false;
|
||
|
|
emStatus = GXIsImplemented(m_hDevice, GX_ENUM_REGION_SEND_MODE, &bRegionMode);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
if (bRegionMode)
|
||
|
|
{
|
||
|
|
emStatus = GXGetEnum(m_hDevice, GX_ENUM_REGION_SEND_MODE, &emRegionSendMode);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
}
|
||
|
|
|
||
|
|
// When camera setting as MultiROI, AWBROI param cannot access
|
||
|
|
if (emRegionSendMode != GX_REGION_SEND_MULTI_ROI_MODE)
|
||
|
|
{
|
||
|
|
// Get AWBROI width
|
||
|
|
emStatus = GXGetInt(m_hDevice, GX_INT_AWBROI_WIDTH, &i64AWBROIWidth);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
// Get AWBROI height
|
||
|
|
emStatus = GXGetInt(m_hDevice, GX_INT_AWBROI_HEIGHT, &i64AWBROIHeight);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
// Get AWBROI offestX
|
||
|
|
emStatus = GXGetInt(m_hDevice, GX_INT_AWBROI_OFFSETX, &i64AWBROIOffsetX);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
// Get AWBROI offsetY
|
||
|
|
emStatus = GXGetInt(m_hDevice, GX_INT_AWBROI_OFFSETY, &i64AWBROIOffsetY);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
AWBROIRangeUpdate();
|
||
|
|
}
|
||
|
|
|
||
|
|
ui->AWBROIWidthSlider->setEnabled(emRegionSendMode != GX_REGION_SEND_MULTI_ROI_MODE);
|
||
|
|
ui->AWBROIWidthSpin->setEnabled(emRegionSendMode != GX_REGION_SEND_MULTI_ROI_MODE);
|
||
|
|
ui->AWBROIHeightSlider->setEnabled(emRegionSendMode != GX_REGION_SEND_MULTI_ROI_MODE);
|
||
|
|
ui->AWBROIHeightSpin->setEnabled(emRegionSendMode != GX_REGION_SEND_MULTI_ROI_MODE);
|
||
|
|
ui->AWBROIOffsetXSlider->setEnabled(emRegionSendMode != GX_REGION_SEND_MULTI_ROI_MODE);
|
||
|
|
ui->AWBROIOffsetXSpin->setEnabled(emRegionSendMode != GX_REGION_SEND_MULTI_ROI_MODE);
|
||
|
|
ui->AWBROIOffsetYSlider->setEnabled(emRegionSendMode != GX_REGION_SEND_MULTI_ROI_MODE);
|
||
|
|
ui->AWBROIOffsetYSpin->setEnabled(emRegionSendMode != GX_REGION_SEND_MULTI_ROI_MODE);
|
||
|
|
|
||
|
|
// Set value to UI Items
|
||
|
|
ui->AWBROIWidthSpin->setValue(i64AWBROIWidth);
|
||
|
|
ui->AWBROIWidthSlider->setValue(i64AWBROIWidth);
|
||
|
|
ui->AWBROIHeightSpin->setValue(i64AWBROIHeight);
|
||
|
|
ui->AWBROIHeightSlider->setValue(i64AWBROIHeight);
|
||
|
|
ui->AWBROIOffsetXSpin->setValue(i64AWBROIOffsetX);
|
||
|
|
ui->AWBROIOffsetXSlider->setValue(i64AWBROIOffsetX);
|
||
|
|
ui->AWBROIOffsetYSpin->setValue(i64AWBROIOffsetY);
|
||
|
|
ui->AWBROIOffsetYSlider->setValue(i64AWBROIOffsetY);
|
||
|
|
|
||
|
|
// Enable all UI Items and release signals when initialze success
|
||
|
|
EnableUI();
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ Balance white channel changed slot
|
||
|
|
\param[in] nIndex Balance white channel selected
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CWhiteBalance::on_BalanceRatioSelector_activated(int nIndex)
|
||
|
|
{
|
||
|
|
GX_STATUS emStatus = GX_STATUS_SUCCESS;
|
||
|
|
double dBalanceRatio = 0;
|
||
|
|
|
||
|
|
// Set balance ratio channel
|
||
|
|
emStatus = GXSetEnum(m_hDevice, GX_ENUM_BALANCE_RATIO_SELECTOR, ui->BalanceRatioSelector->itemData(nIndex).value<int64_t>());
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
// Get current channel balance ratio
|
||
|
|
emStatus = GXGetFloat(m_hDevice, GX_FLOAT_BALANCE_RATIO, &dBalanceRatio);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
ui->BalanceRatioSpin->setValue(dBalanceRatio);
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ Balance white ratio of current channel changed slot
|
||
|
|
\param[in] dBalanceRatio BalanceRatio user input
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CWhiteBalance::on_BalanceRatioSpin_valueChanged(double dBalanceRatio)
|
||
|
|
{
|
||
|
|
GX_STATUS emStatus = GX_STATUS_SUCCESS;
|
||
|
|
emStatus = GXSetFloat(m_hDevice, GX_FLOAT_BALANCE_RATIO, dBalanceRatio);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
// Balance white setting value always corrected by camera, so get it back to UI Item
|
||
|
|
emStatus = GXGetFloat(m_hDevice, GX_FLOAT_BALANCE_RATIO, &dBalanceRatio);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
ui->BalanceRatioSpin->setValue(dBalanceRatio);
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ Balance white mode changed slot
|
||
|
|
\param[in] nIndex Balance white mode selected
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CWhiteBalance::on_WhiteBalanceAuto_activated(int nIndex)
|
||
|
|
{
|
||
|
|
GX_STATUS emStatus = GX_STATUS_SUCCESS;
|
||
|
|
|
||
|
|
// Set balance mode
|
||
|
|
emStatus = GXSetEnum(m_hDevice, GX_ENUM_BALANCE_WHITE_AUTO, ui->WhiteBalanceAuto->itemData(nIndex).value<int64_t>());
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
// If auto mode is on, start a timer to refresh new value and disable value edit manually
|
||
|
|
if (ui->WhiteBalanceAuto->itemData(nIndex).value<int64_t>() != GX_BALANCE_WHITE_AUTO_OFF)
|
||
|
|
{
|
||
|
|
// Refresh interval 100ms
|
||
|
|
const int nAWBRefreshInterval = 100;
|
||
|
|
m_pWhiteBalanceTimer->start(nAWBRefreshInterval);
|
||
|
|
ui->BalanceRatioSpin->setEnabled(false);
|
||
|
|
ui->BalanceRatioSpin->blockSignals(true);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
m_pWhiteBalanceTimer->stop();
|
||
|
|
ui->BalanceRatioSpin->setEnabled(true);
|
||
|
|
ui->BalanceRatioSpin->blockSignals(false);
|
||
|
|
}
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ Update WhiteBalanceRatio mode and value timeout slot
|
||
|
|
\param[in]
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CWhiteBalance::WhiteBalanceRatioUpdate()
|
||
|
|
{
|
||
|
|
GX_STATUS emStatus = GX_STATUS_SUCCESS;
|
||
|
|
int64_t i64Entry = GX_BALANCE_WHITE_AUTO_OFF;
|
||
|
|
|
||
|
|
emStatus = GXGetEnum(m_hDevice, GX_ENUM_BALANCE_WHITE_AUTO, &i64Entry);
|
||
|
|
if (emStatus != GX_STATUS_SUCCESS)
|
||
|
|
{
|
||
|
|
m_pWhiteBalanceTimer->stop();
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
}
|
||
|
|
|
||
|
|
// If auto mode is off, stop the timer and enable value edit manually
|
||
|
|
if (i64Entry == GX_BALANCE_WHITE_AUTO_OFF)
|
||
|
|
{
|
||
|
|
ui->WhiteBalanceAuto->setCurrentIndex(ui->WhiteBalanceAuto->findData(qVariantFromValue(i64Entry)));
|
||
|
|
|
||
|
|
ui->BalanceRatioSpin->setEnabled(true);
|
||
|
|
ui->BalanceRatioSpin->blockSignals(false);
|
||
|
|
m_pWhiteBalanceTimer->stop();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
ui->BalanceRatioSpin->blockSignals(true);
|
||
|
|
}
|
||
|
|
|
||
|
|
double dBalanceRatio = 0;
|
||
|
|
emStatus = GXGetFloat(m_hDevice, GX_FLOAT_BALANCE_RATIO, &dBalanceRatio);
|
||
|
|
if (emStatus != GX_STATUS_SUCCESS)
|
||
|
|
{
|
||
|
|
m_pWhiteBalanceTimer->stop();
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
}
|
||
|
|
|
||
|
|
ui->BalanceRatioSpin->setValue(dBalanceRatio);
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ AWBROIWidth Value changed slot
|
||
|
|
\param[in] nAWBROIWidth Changed value from slider
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CWhiteBalance::on_AWBROIWidthSlider_valueChanged(int nAWBROIWidth)
|
||
|
|
{
|
||
|
|
// Param correction
|
||
|
|
nAWBROIWidth = (nAWBROIWidth / m_i64AWBWidthInc) * m_i64AWBWidthInc;
|
||
|
|
|
||
|
|
GX_STATUS emStatus = GX_STATUS_SUCCESS;
|
||
|
|
emStatus = GXSetInt(m_hDevice, GX_INT_AWBROI_WIDTH, nAWBROIWidth);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
ui->AWBROIWidthSpin->setValue(nAWBROIWidth);
|
||
|
|
|
||
|
|
AWBROIRangeUpdate();
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ AWBROIWidth Value changed slot
|
||
|
|
\param[in] nAWBROIWidth AWBROIWidth user input
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CWhiteBalance::on_AWBROIWidthSpin_valueChanged(int nAWBROIWidth)
|
||
|
|
{
|
||
|
|
nAWBROIWidth = (nAWBROIWidth / m_i64AWBWidthInc) * m_i64AWBWidthInc;
|
||
|
|
|
||
|
|
GX_STATUS emStatus = GX_STATUS_SUCCESS;
|
||
|
|
emStatus = GXSetInt(m_hDevice, GX_INT_AWBROI_WIDTH, nAWBROIWidth);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
ui->AWBROIWidthSpin->setValue(nAWBROIWidth);
|
||
|
|
ui->AWBROIWidthSlider->setValue(nAWBROIWidth);
|
||
|
|
|
||
|
|
AWBROIRangeUpdate();
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ AWBROIHeight Value changed slot
|
||
|
|
\param[in] nAWBROIHeight Changed value from slider
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CWhiteBalance::on_AWBROIHeightSlider_valueChanged(int nAWBROIHeight)
|
||
|
|
{
|
||
|
|
nAWBROIHeight = (nAWBROIHeight / m_i64AWBHeightInc) * m_i64AWBHeightInc;
|
||
|
|
|
||
|
|
GX_STATUS emStatus = GX_STATUS_SUCCESS;
|
||
|
|
emStatus = GXSetInt(m_hDevice, GX_INT_AWBROI_HEIGHT, nAWBROIHeight);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
ui->AWBROIHeightSpin->setValue(nAWBROIHeight);
|
||
|
|
|
||
|
|
AWBROIRangeUpdate();
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ AWBROIHeight Value changed slot
|
||
|
|
\param[in] nAWBROIHeight AWBROIHeight user input
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CWhiteBalance::on_AWBROIHeightSpin_valueChanged(int nAWBROIHeight)
|
||
|
|
{
|
||
|
|
nAWBROIHeight = (nAWBROIHeight / m_i64AWBHeightInc) * m_i64AWBHeightInc;
|
||
|
|
|
||
|
|
GX_STATUS emStatus = GX_STATUS_SUCCESS;
|
||
|
|
emStatus = GXSetInt(m_hDevice, GX_INT_AWBROI_HEIGHT, nAWBROIHeight);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
ui->AWBROIHeightSpin->setValue(nAWBROIHeight);
|
||
|
|
ui->AWBROIHeightSlider->setValue(nAWBROIHeight);
|
||
|
|
|
||
|
|
AWBROIRangeUpdate();
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ AWBROIOffsetX Value changed slot
|
||
|
|
\param[in] nAWBROIOffsetX Changed value from slider
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CWhiteBalance::on_AWBROIOffsetXSlider_valueChanged(int nAWBROIOffsetX)
|
||
|
|
{
|
||
|
|
nAWBROIOffsetX = (nAWBROIOffsetX / m_i64AWBWidthInc) * m_i64AWBWidthInc;
|
||
|
|
|
||
|
|
GX_STATUS emStatus = GX_STATUS_SUCCESS;
|
||
|
|
emStatus = GXSetInt(m_hDevice, GX_INT_AWBROI_OFFSETX, nAWBROIOffsetX);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
ui->AWBROIOffsetXSpin->setValue(nAWBROIOffsetX);
|
||
|
|
|
||
|
|
AWBROIRangeUpdate();
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ AWBROIOffsetX Value changed slot
|
||
|
|
\param[in] nAWBROIOffsetX AWBROIOffsetX user input
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CWhiteBalance::on_AWBROIOffsetXSpin_valueChanged(int nAWBROIOffsetX)
|
||
|
|
{
|
||
|
|
nAWBROIOffsetX = (nAWBROIOffsetX / m_i64AWBWidthInc) * m_i64AWBWidthInc;
|
||
|
|
|
||
|
|
GX_STATUS emStatus = GX_STATUS_SUCCESS;
|
||
|
|
emStatus = GXSetInt(m_hDevice, GX_INT_AWBROI_OFFSETX, nAWBROIOffsetX);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
ui->AWBROIOffsetXSpin->setValue(nAWBROIOffsetX);
|
||
|
|
ui->AWBROIOffsetXSlider->setValue(nAWBROIOffsetX);
|
||
|
|
|
||
|
|
AWBROIRangeUpdate();
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ AWBROIOffsetY Value changed slot
|
||
|
|
\param[in] nAWBROIOffsetY Changed value from slider
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CWhiteBalance::on_AWBROIOffsetYSlider_valueChanged(int nAWBROIOffsetY)
|
||
|
|
{
|
||
|
|
nAWBROIOffsetY = (nAWBROIOffsetY / m_i64AWBHeightInc) * m_i64AWBHeightInc;
|
||
|
|
|
||
|
|
GX_STATUS emStatus = GX_STATUS_SUCCESS;
|
||
|
|
emStatus = GXSetInt(m_hDevice, GX_INT_AWBROI_OFFSETY, nAWBROIOffsetY);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
ui->AWBROIOffsetYSpin->setValue(nAWBROIOffsetY);
|
||
|
|
|
||
|
|
AWBROIRangeUpdate();
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ AWBROIOffsetY Value changed slot
|
||
|
|
\param[in] nAWBROIOffsetY AWBROIOffsetY user input
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CWhiteBalance::on_AWBROIOffsetYSpin_valueChanged(int nAWBROIOffsetY)
|
||
|
|
{
|
||
|
|
nAWBROIOffsetY = (nAWBROIOffsetY / m_i64AWBHeightInc) * m_i64AWBHeightInc;
|
||
|
|
|
||
|
|
GX_STATUS emStatus = GX_STATUS_SUCCESS;
|
||
|
|
emStatus = GXSetInt(m_hDevice, GX_INT_AWBROI_OFFSETY, nAWBROIOffsetY);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
ui->AWBROIOffsetYSpin->setValue(nAWBROIOffsetY);
|
||
|
|
ui->AWBROIOffsetYSlider->setValue(nAWBROIOffsetY);
|
||
|
|
|
||
|
|
AWBROIRangeUpdate();
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|