1076 lines
34 KiB
C++
1076 lines
34 KiB
C++
|
//--------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\file ExposureGain.cpp
|
||
|
|
\brief CExposureGain Class implementation file
|
||
|
|
|
||
|
|
\version v1.0.1807.9271
|
||
|
|
\date 2018-07-27
|
||
|
|
|
||
|
|
<p>Copyright (c) 2017-2018</p>
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
#include "ExposureGain.h"
|
||
|
|
#include "ui_ExposureGain.h"
|
||
|
|
#include <QDebug>
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\Constructor of CExposureGain
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
CExposureGain::CExposureGain(QWidget *parent) :
|
||
|
|
QDialog(parent),
|
||
|
|
ui(new Ui::CExposureGain),
|
||
|
|
m_hDevice(NULL),
|
||
|
|
m_dExposureTime(0),
|
||
|
|
m_dAutoExposureTimeMax(0),
|
||
|
|
m_dAutoExposureTimeMin(0),
|
||
|
|
m_dGain(0),
|
||
|
|
m_dAutoGainMax(0),
|
||
|
|
m_dAutoGainMin(0),
|
||
|
|
m_i64AAROIWidth(0),
|
||
|
|
m_i64AAROIHeight(0),
|
||
|
|
m_i64AAROIOffsetX(0),
|
||
|
|
m_i64AAROIOffsetY(0),
|
||
|
|
m_i64AAWidthInc(0),
|
||
|
|
m_i64AAHeightInc(0),
|
||
|
|
m_i64AAOffsetXInc(0),
|
||
|
|
m_i64AAOffsetYInc(0),
|
||
|
|
m_i64GrayValue(0),
|
||
|
|
m_pExposureTimer(NULL),
|
||
|
|
m_pGainTimer(NULL)
|
||
|
|
{
|
||
|
|
ui->setupUi(this);
|
||
|
|
|
||
|
|
// Set font size of UI
|
||
|
|
QFont font = this->font();
|
||
|
|
font.setPointSize(10);
|
||
|
|
this->setFont(font);
|
||
|
|
|
||
|
|
// Avoid Strong focus policy which will exit this dialog by every time pressing "Enter"
|
||
|
|
ui->AA_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_pExposureTimer = new QTimer(this);
|
||
|
|
m_pGainTimer = new QTimer(this);
|
||
|
|
connect(m_pExposureTimer, SIGNAL(timeout()), this, SLOT(ExposureUpdate()));
|
||
|
|
connect(m_pGainTimer, SIGNAL(timeout()), this, SLOT(GainUpdate()));
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\Destructor of CExposureGain
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
CExposureGain::~CExposureGain()
|
||
|
|
{
|
||
|
|
// Release Timer
|
||
|
|
RELEASE_ALLOC_MEM(m_pExposureTimer);
|
||
|
|
RELEASE_ALLOC_MEM(m_pGainTimer);
|
||
|
|
|
||
|
|
ClearUI();
|
||
|
|
|
||
|
|
delete ui;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ Close this dialog
|
||
|
|
\param[in]
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CExposureGain::on_AA_Close_clicked()
|
||
|
|
{
|
||
|
|
this->close();
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\Clear ComboBox Items
|
||
|
|
\param[in]
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CExposureGain::ClearUI()
|
||
|
|
{
|
||
|
|
// Clear ComboBox items
|
||
|
|
ui->ExposureAuto->clear();
|
||
|
|
ui->GainAuto->clear();
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ Enable all UI Groups
|
||
|
|
\param[in]
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CExposureGain::EnableUI()
|
||
|
|
{
|
||
|
|
// Release item signals
|
||
|
|
QObjectList pobjGroupList = this->children();
|
||
|
|
foreach (QObject *pobjGroup, pobjGroupList)
|
||
|
|
{
|
||
|
|
QObjectList pobjItemList = pobjGroup->children();
|
||
|
|
foreach (QObject *pobjItem, pobjItemList)
|
||
|
|
{
|
||
|
|
pobjItem->blockSignals(false);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
ui->Exposure->setEnabled(true);
|
||
|
|
ui->Gain->setEnabled(true);
|
||
|
|
ui->AA_Param->setEnabled(true);
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ Disable all UI Groups
|
||
|
|
\param[in]
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CExposureGain::DisableUI()
|
||
|
|
{
|
||
|
|
// Block item signals
|
||
|
|
QObjectList pobjGroupList = this->children();
|
||
|
|
foreach (QObject *pobjGroup, pobjGroupList)
|
||
|
|
{
|
||
|
|
QObjectList pobjItemList = pobjGroup->children();
|
||
|
|
foreach (QObject *pobjItem, pobjItemList)
|
||
|
|
{
|
||
|
|
pobjItem->blockSignals(true);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
ui->Exposure->setEnabled(false);
|
||
|
|
ui->Gain->setEnabled(false);
|
||
|
|
ui->AA_Param->setEnabled(false);
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ Update AAROI UI Item range
|
||
|
|
\param[in]
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CExposureGain::AAROIRangeUpdate()
|
||
|
|
{
|
||
|
|
GX_STATUS emStatus = GX_STATUS_SUCCESS;
|
||
|
|
GX_INT_RANGE stIntRange;
|
||
|
|
|
||
|
|
// Get the range of image width (nMax is Maximum, nMin is Minimum, nInc is Step)
|
||
|
|
emStatus = GXGetIntRange(m_hDevice, GX_INT_AAROI_WIDTH, &stIntRange);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
// Storage step of this parameter for input correction
|
||
|
|
m_i64AAWidthInc = stIntRange.nInc;
|
||
|
|
|
||
|
|
// Set Range to UI Items
|
||
|
|
ui->AAROIWidthSlider->setRange(stIntRange.nMin, stIntRange.nMax);
|
||
|
|
ui->AAROIWidthSpin->setRange(stIntRange.nMin, stIntRange.nMax);
|
||
|
|
ui->AAROIWidthSlider->setSingleStep(stIntRange.nInc);
|
||
|
|
ui->AAROIWidthSlider->setPageStep(0);
|
||
|
|
ui->AAROIWidthSpin->setSingleStep(stIntRange.nInc);
|
||
|
|
ui->AAROIWidthSpin->setToolTip(QString("(Min:%1 Max:%2 Inc:%3)")
|
||
|
|
.arg(stIntRange.nMin)
|
||
|
|
.arg(stIntRange.nMax)
|
||
|
|
.arg(stIntRange.nInc));
|
||
|
|
ui->AAROIWidthSlider->setToolTip(QString("(Min:%1 Max:%2 Inc:%3)")
|
||
|
|
.arg(stIntRange.nMin)
|
||
|
|
.arg(stIntRange.nMax)
|
||
|
|
.arg(stIntRange.nInc));
|
||
|
|
|
||
|
|
// Get the range of image height (nMax is Maximum, nMin is Minimum, nInc is Step)
|
||
|
|
emStatus = GXGetIntRange(m_hDevice, GX_INT_AAROI_HEIGHT, &stIntRange);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
// Storage step of this parameter for input correction
|
||
|
|
m_i64AAHeightInc = stIntRange.nInc;
|
||
|
|
|
||
|
|
// Set Range to UI Items
|
||
|
|
ui->AAROIHeightSlider->setRange(stIntRange.nMin, stIntRange.nMax);
|
||
|
|
ui->AAROIHeightSpin->setRange(stIntRange.nMin, stIntRange.nMax);
|
||
|
|
ui->AAROIHeightSlider->setSingleStep(stIntRange.nInc);
|
||
|
|
ui->AAROIHeightSlider->setPageStep(0);
|
||
|
|
ui->AAROIHeightSpin->setSingleStep(stIntRange.nInc);
|
||
|
|
ui->AAROIHeightSpin->setToolTip(QString("(Min:%1 Max:%2 Inc:%3)")
|
||
|
|
.arg(stIntRange.nMin)
|
||
|
|
.arg(stIntRange.nMax)
|
||
|
|
.arg(stIntRange.nInc));
|
||
|
|
ui->AAROIHeightSlider->setToolTip(QString("(Min:%1 Max:%2 Inc:%3)")
|
||
|
|
.arg(stIntRange.nMin)
|
||
|
|
.arg(stIntRange.nMax)
|
||
|
|
.arg(stIntRange.nInc));
|
||
|
|
|
||
|
|
|
||
|
|
// Get the range of image offsetx (nMax is Maximum, nMin is Minimum, nInc is Step)
|
||
|
|
emStatus = GXGetIntRange(m_hDevice, GX_INT_AAROI_OFFSETX, &stIntRange);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
// Storage step of this parameter for input correction
|
||
|
|
m_i64AAOffsetXInc = stIntRange.nInc;
|
||
|
|
|
||
|
|
// Set Range to UI Items
|
||
|
|
ui->AAROIOffsetXSlider->setRange(stIntRange.nMin, stIntRange.nMax);
|
||
|
|
ui->AAROIOffsetXSpin->setRange(stIntRange.nMin, stIntRange.nMax);
|
||
|
|
ui->AAROIOffsetXSlider->setSingleStep(stIntRange.nInc);
|
||
|
|
ui->AAROIOffsetXSlider->setPageStep(0);
|
||
|
|
ui->AAROIOffsetXSpin->setSingleStep(stIntRange.nInc);
|
||
|
|
ui->AAROIOffsetXSpin->setToolTip(QString("(Min:%1 Max:%2 Inc:%3)")
|
||
|
|
.arg(stIntRange.nMin)
|
||
|
|
.arg(stIntRange.nMax)
|
||
|
|
.arg(stIntRange.nInc));
|
||
|
|
ui->AAROIOffsetXSlider->setToolTip(QString("(Min:%1 Max:%2 Inc:%3)")
|
||
|
|
.arg(stIntRange.nMin)
|
||
|
|
.arg(stIntRange.nMax)
|
||
|
|
.arg(stIntRange.nInc));
|
||
|
|
|
||
|
|
|
||
|
|
// Get the range of image offsety (nMax is Maximum, nMin is Minimum, nInc is Step)
|
||
|
|
emStatus = GXGetIntRange(m_hDevice, GX_INT_AAROI_OFFSETY, &stIntRange);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
// Storage step of this parameter for input correction
|
||
|
|
m_i64AAOffsetYInc = stIntRange.nInc;
|
||
|
|
|
||
|
|
// Set Range to UI Items
|
||
|
|
ui->AAROIOffsetYSlider->setRange(stIntRange.nMin, stIntRange.nMax);
|
||
|
|
ui->AAROIOffsetYSpin->setRange(stIntRange.nMin, stIntRange.nMax);
|
||
|
|
ui->AAROIOffsetYSlider->setSingleStep(stIntRange.nInc);
|
||
|
|
ui->AAROIOffsetYSlider->setPageStep(0);
|
||
|
|
ui->AAROIOffsetYSpin->setSingleStep(stIntRange.nInc);
|
||
|
|
ui->AAROIOffsetYSpin->setToolTip(QString("(Min:%1 Max:%2 Inc:%3)")
|
||
|
|
.arg(stIntRange.nMin)
|
||
|
|
.arg(stIntRange.nMax)
|
||
|
|
.arg(stIntRange.nInc));
|
||
|
|
ui->AAROIOffsetYSlider->setToolTip(QString("(Min:%1 Max:%2 Inc:%3)")
|
||
|
|
.arg(stIntRange.nMin)
|
||
|
|
.arg(stIntRange.nMax)
|
||
|
|
.arg(stIntRange.nInc));
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ Update Auto ExposureTime UI Item range
|
||
|
|
\param[in]
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CExposureGain::AutoExposureTimeRangeUpdate()
|
||
|
|
{
|
||
|
|
GX_STATUS emStatus = GX_STATUS_SUCCESS;
|
||
|
|
GX_FLOAT_RANGE stFloatRange;
|
||
|
|
|
||
|
|
// Get the range of ExposureTimeMax
|
||
|
|
emStatus = GXGetFloatRange(m_hDevice, GX_FLOAT_AUTO_EXPOSURE_TIME_MAX, &stFloatRange);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
// Set Range to UI Items
|
||
|
|
ui->AutoExposureTimeMaxSpin->setRange(stFloatRange.dMin, stFloatRange.dMax);
|
||
|
|
ui->AutoExposureTimeMaxSpin->setSingleStep(EXPOSURE_INCREMENT);
|
||
|
|
ui->AutoExposureTimeMaxSpin->setToolTip(QString("(Min:%1 Max:%2 Inc:%3)")
|
||
|
|
.arg(stFloatRange.dMin, 0, 'f', 1)
|
||
|
|
.arg(stFloatRange.dMax, 0, 'f', 1)
|
||
|
|
.arg(EXPOSURE_INCREMENT));
|
||
|
|
// Get the range of ExposureTimeMin
|
||
|
|
emStatus = GXGetFloatRange(m_hDevice, GX_FLOAT_AUTO_EXPOSURE_TIME_MIN, &stFloatRange);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
// Set Range to UI Items
|
||
|
|
ui->AutoExposureTimeMinSpin->setRange(stFloatRange.dMin, stFloatRange.dMax);
|
||
|
|
ui->AutoExposureTimeMinSpin->setSingleStep(EXPOSURE_INCREMENT);
|
||
|
|
ui->AutoExposureTimeMinSpin->setToolTip(QString("(Min:%1 Max:%2 Inc:%3)")
|
||
|
|
.arg(stFloatRange.dMin, 0, 'f', 1)
|
||
|
|
.arg(stFloatRange.dMax, 0, 'f', 1)
|
||
|
|
.arg(EXPOSURE_INCREMENT));
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ Update Auto ExposureTime UI Item range
|
||
|
|
\param[in]
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CExposureGain::AutoGainRangeUpdate()
|
||
|
|
{
|
||
|
|
GX_STATUS emStatus = GX_STATUS_SUCCESS;
|
||
|
|
GX_FLOAT_RANGE stFloatRange;
|
||
|
|
|
||
|
|
// Get the range of GainMax
|
||
|
|
emStatus = GXGetFloatRange(m_hDevice, GX_FLOAT_AUTO_GAIN_MAX, &stFloatRange);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
// Set Range to UI Items
|
||
|
|
ui->AutoGainMaxSpin->setRange(stFloatRange.dMin, stFloatRange.dMax);
|
||
|
|
ui->AutoGainMaxSpin->setSingleStep(GAIN_INCREMENT);
|
||
|
|
ui->AutoGainMaxSpin->setToolTip(QString("(Min:%1 Max:%2 Inc:%3)")
|
||
|
|
.arg(stFloatRange.dMin, 0, 'f', 1)
|
||
|
|
.arg(stFloatRange.dMax, 0, 'f', 1)
|
||
|
|
.arg(GAIN_INCREMENT));
|
||
|
|
// Get the range of GainMin
|
||
|
|
emStatus = GXGetFloatRange(m_hDevice, GX_FLOAT_AUTO_GAIN_MIN, &stFloatRange);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
// Set Range to UI Items
|
||
|
|
ui->AutoGainMinSpin->setRange(stFloatRange.dMin, stFloatRange.dMax);
|
||
|
|
ui->AutoGainMinSpin->setSingleStep(GAIN_INCREMENT);
|
||
|
|
ui->AutoGainMinSpin->setToolTip(QString("(Min:%1 Max:%2 Inc:%3)")
|
||
|
|
.arg(stFloatRange.dMin, 0, 'f', 1)
|
||
|
|
.arg(stFloatRange.dMax, 0, 'f', 1)
|
||
|
|
.arg(GAIN_INCREMENT));
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ Get device handle from mainwindow, and get param for this dialog
|
||
|
|
\param[in]
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CExposureGain::GetDialogInitParam(GX_DEV_HANDLE hDeviceHandle)
|
||
|
|
{
|
||
|
|
GX_STATUS emStatus = GX_STATUS_SUCCESS;
|
||
|
|
GX_FLOAT_RANGE stFloatRange;
|
||
|
|
GX_INT_RANGE stIntRange;
|
||
|
|
|
||
|
|
// Device handle transfered and storaged
|
||
|
|
m_hDevice = hDeviceHandle;
|
||
|
|
|
||
|
|
// Clear Dialog Items
|
||
|
|
ClearUI();
|
||
|
|
|
||
|
|
// Disable all UI items and block signals
|
||
|
|
DisableUI();
|
||
|
|
|
||
|
|
// Init exposre auto combobox entrys
|
||
|
|
emStatus = InitComboBox(m_hDevice, ui->ExposureAuto, GX_ENUM_EXPOSURE_AUTO);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
// If auto mode is on, start a timer to refresh new value and disable value edit manually
|
||
|
|
if (ui->ExposureAuto->itemData(ui->ExposureAuto->currentIndex()).value<int64_t>() != GX_EXPOSURE_AUTO_OFF)
|
||
|
|
{
|
||
|
|
// Refresh interval 100ms
|
||
|
|
const int nExposureTimeRefreshInterval = 100;
|
||
|
|
m_pExposureTimer->start(nExposureTimeRefreshInterval);
|
||
|
|
ui->ExposureTimeSpin->setEnabled(false);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
m_pExposureTimer->stop();
|
||
|
|
ui->ExposureTimeSpin->setEnabled(true);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Get exposure time(us)
|
||
|
|
double dExposureTime = 0;
|
||
|
|
emStatus = GXGetFloat(m_hDevice, GX_FLOAT_EXPOSURE_TIME, &dExposureTime);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
// Get the maximum auto exposure time(us)
|
||
|
|
double dExposureTimeMax = 0;
|
||
|
|
emStatus = GXGetFloat(m_hDevice, GX_FLOAT_AUTO_EXPOSURE_TIME_MAX, &dExposureTimeMax);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
// Get the minimum auto exposure time(us)
|
||
|
|
double dExposureTimeMin = 0;
|
||
|
|
emStatus = GXGetFloat(m_hDevice, GX_FLOAT_AUTO_EXPOSURE_TIME_MIN, &dExposureTimeMin);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
// Get the range of ExposureTime
|
||
|
|
emStatus = GXGetFloatRange(m_hDevice, GX_FLOAT_EXPOSURE_TIME, &stFloatRange);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
// Set Range to UI Items
|
||
|
|
ui->ExposureTimeSpin->setRange(stFloatRange.dMin, stFloatRange.dMax);
|
||
|
|
ui->ExposureTimeSpin->setSingleStep(EXPOSURE_INCREMENT);
|
||
|
|
ui->ExposureTimeSpin->setToolTip(QString("(Min:%1 Max:%2 Inc:%3)")
|
||
|
|
.arg(stFloatRange.dMin, 0, 'f', 1)
|
||
|
|
.arg(stFloatRange.dMax, 0, 'f', 1)
|
||
|
|
.arg(EXPOSURE_INCREMENT));
|
||
|
|
|
||
|
|
// Update Auto ExposureTime UI Item range
|
||
|
|
AutoExposureTimeRangeUpdate();
|
||
|
|
|
||
|
|
ui->ExposureTimeSpin->setValue(dExposureTime);
|
||
|
|
ui->AutoExposureTimeMaxSpin->setValue(dExposureTimeMax);
|
||
|
|
ui->AutoExposureTimeMinSpin->setValue(dExposureTimeMin);
|
||
|
|
|
||
|
|
// Init gain auto combobox entrys
|
||
|
|
emStatus = InitComboBox(m_hDevice, ui->GainAuto, GX_ENUM_GAIN_AUTO);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
// If auto mode is on, start a timer to refresh new value
|
||
|
|
if (ui->GainAuto->itemData(ui->GainAuto->currentIndex()).value<int64_t>() != GX_GAIN_AUTO_OFF)
|
||
|
|
{
|
||
|
|
// Refresh interval 100ms
|
||
|
|
const int nGainRefreshInterval = 100;
|
||
|
|
m_pGainTimer->start(nGainRefreshInterval);
|
||
|
|
ui->GainSpin->setEnabled(false);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
m_pGainTimer->stop();
|
||
|
|
ui->GainSpin->setEnabled(true);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Get gain(dB)
|
||
|
|
double dGain = 0;
|
||
|
|
emStatus = GXGetFloat(m_hDevice, GX_FLOAT_GAIN, &dGain);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
// Get the maximum auto gain(dB)
|
||
|
|
double dGainMax = 0;
|
||
|
|
emStatus = GXGetFloat(m_hDevice, GX_FLOAT_AUTO_GAIN_MAX, &dGainMax);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
// Get the minimum auto gain(dB)
|
||
|
|
double dGainMin = 0;
|
||
|
|
emStatus = GXGetFloat(m_hDevice, GX_FLOAT_AUTO_GAIN_MIN, &dGainMin);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
// Get the range of Gain
|
||
|
|
emStatus = GXGetFloatRange(m_hDevice, GX_FLOAT_GAIN, &stFloatRange);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
// Set Range to UI Items
|
||
|
|
ui->GainSpin->setRange(stFloatRange.dMin, stFloatRange.dMax);
|
||
|
|
ui->GainSpin->setSingleStep(GAIN_INCREMENT);
|
||
|
|
ui->GainSpin->setToolTip(QString("(Min:%1 Max:%2 Inc:%3)")
|
||
|
|
.arg(stFloatRange.dMin, 0, 'f', 1)
|
||
|
|
.arg(stFloatRange.dMax, 0, 'f', 1)
|
||
|
|
.arg(GAIN_INCREMENT));
|
||
|
|
|
||
|
|
// Update Auto ExposureTime UI Item range
|
||
|
|
AutoGainRangeUpdate();
|
||
|
|
|
||
|
|
ui->GainSpin->setValue(dGain);
|
||
|
|
ui->AutoGainMaxSpin->setValue(dGainMax);
|
||
|
|
ui->AutoGainMinSpin->setValue(dGainMin);
|
||
|
|
|
||
|
|
int64_t i64AAROIWidth = 0;
|
||
|
|
int64_t i64AAROIHeight = 0;
|
||
|
|
int64_t i64AAROIOffsetX = 0;
|
||
|
|
int64_t i64AAROIOffsetY = 0;
|
||
|
|
|
||
|
|
bool bRegionMode = false;
|
||
|
|
int64_t emRegionSendMode = GX_REGION_SEND_SINGLE_ROI_MODE;
|
||
|
|
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, AAROI param cannot access
|
||
|
|
if (emRegionSendMode != GX_REGION_SEND_MULTI_ROI_MODE)
|
||
|
|
{
|
||
|
|
// Get AAROI width
|
||
|
|
emStatus = GXGetInt(m_hDevice, GX_INT_AAROI_WIDTH, &i64AAROIWidth);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
// Get AAROI height
|
||
|
|
emStatus = GXGetInt(m_hDevice, GX_INT_AAROI_HEIGHT, &i64AAROIHeight);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
// Get AAROI offestX
|
||
|
|
emStatus = GXGetInt(m_hDevice, GX_INT_AAROI_OFFSETX, &i64AAROIOffsetX);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
// Get AAROI offsetY
|
||
|
|
emStatus = GXGetInt(m_hDevice, GX_INT_AAROI_OFFSETY, &i64AAROIOffsetY);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
// Update AAROI UI Item range
|
||
|
|
AAROIRangeUpdate();
|
||
|
|
}
|
||
|
|
|
||
|
|
ui->AAROIWidthSlider->setEnabled(emRegionSendMode != GX_REGION_SEND_MULTI_ROI_MODE);
|
||
|
|
ui->AAROIWidthSpin->setEnabled(emRegionSendMode != GX_REGION_SEND_MULTI_ROI_MODE);
|
||
|
|
ui->AAROIHeightSlider->setEnabled(emRegionSendMode != GX_REGION_SEND_MULTI_ROI_MODE);
|
||
|
|
ui->AAROIHeightSpin->setEnabled(emRegionSendMode != GX_REGION_SEND_MULTI_ROI_MODE);
|
||
|
|
ui->AAROIOffsetXSlider->setEnabled(emRegionSendMode != GX_REGION_SEND_MULTI_ROI_MODE);
|
||
|
|
ui->AAROIOffsetXSpin->setEnabled(emRegionSendMode != GX_REGION_SEND_MULTI_ROI_MODE);
|
||
|
|
ui->AAROIOffsetYSlider->setEnabled(emRegionSendMode != GX_REGION_SEND_MULTI_ROI_MODE);
|
||
|
|
ui->AAROIOffsetYSpin->setEnabled(emRegionSendMode != GX_REGION_SEND_MULTI_ROI_MODE);
|
||
|
|
|
||
|
|
// Get expected gray value
|
||
|
|
int64_t i64GrayValue = 0;
|
||
|
|
emStatus = GXGetInt(m_hDevice, GX_INT_GRAY_VALUE, &i64GrayValue);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
// Get the range of ExpectedGrayValue
|
||
|
|
emStatus = GXGetIntRange(m_hDevice, GX_INT_GRAY_VALUE, &stIntRange);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
// Set Range to UI Items
|
||
|
|
ui->ExpectedGrayValueSlider->setRange(stIntRange.nMin, stIntRange.nMax);
|
||
|
|
ui->ExpectedGrayValueSpin->setRange(stIntRange.nMin, stIntRange.nMax);
|
||
|
|
ui->ExpectedGrayValueSlider->setSingleStep(stIntRange.nInc);
|
||
|
|
ui->ExpectedGrayValueSlider->setPageStep(0);
|
||
|
|
ui->ExpectedGrayValueSpin->setSingleStep(stIntRange.nInc);
|
||
|
|
ui->ExpectedGrayValueSpin->setToolTip(QString("(Min:%1 Max:%2 Inc:%3)")
|
||
|
|
.arg(stIntRange.nMin)
|
||
|
|
.arg(stIntRange.nMax)
|
||
|
|
.arg(stIntRange.nInc));
|
||
|
|
ui->ExpectedGrayValueSlider->setToolTip(QString("(Min:%1 Max:%2 Inc:%3)")
|
||
|
|
.arg(stIntRange.nMin)
|
||
|
|
.arg(stIntRange.nMax)
|
||
|
|
.arg(stIntRange.nInc));
|
||
|
|
|
||
|
|
// Set Value to UI Items
|
||
|
|
ui->AAROIWidthSpin->setValue(i64AAROIWidth);
|
||
|
|
ui->AAROIWidthSlider->setValue(i64AAROIWidth);
|
||
|
|
ui->AAROIHeightSpin->setValue(i64AAROIHeight);
|
||
|
|
ui->AAROIHeightSlider->setValue(i64AAROIHeight);
|
||
|
|
ui->AAROIOffsetXSpin->setValue(i64AAROIOffsetX);
|
||
|
|
ui->AAROIOffsetXSlider->setValue(i64AAROIOffsetX);
|
||
|
|
ui->AAROIOffsetYSpin->setValue(i64AAROIOffsetY);
|
||
|
|
ui->AAROIOffsetYSlider->setValue(i64AAROIOffsetY);
|
||
|
|
|
||
|
|
ui->ExpectedGrayValueSpin->setValue(i64GrayValue);
|
||
|
|
ui->ExpectedGrayValueSlider->setValue(i64GrayValue);
|
||
|
|
|
||
|
|
// Enable all UI Items and release signals when initialze success
|
||
|
|
EnableUI();
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ ExposureAuto nIndex changed slot
|
||
|
|
\param[in] nIndex nIndex selected
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CExposureGain::on_ExposureAuto_activated(int nIndex)
|
||
|
|
{
|
||
|
|
GX_STATUS emStatus = GX_STATUS_SUCCESS;
|
||
|
|
|
||
|
|
// Set exposure auto
|
||
|
|
emStatus = GXSetEnum(m_hDevice, GX_ENUM_EXPOSURE_AUTO, ui->ExposureAuto->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->ExposureAuto->itemData(nIndex).value<int64_t>() != GX_EXPOSURE_AUTO_OFF)
|
||
|
|
{
|
||
|
|
// Refresh interval 100ms
|
||
|
|
const int nExposureTimeRefreshInterval = 100;
|
||
|
|
m_pExposureTimer->start(nExposureTimeRefreshInterval);
|
||
|
|
ui->ExposureTimeSpin->setEnabled(false);
|
||
|
|
ui->ExposureTimeSpin->blockSignals(true);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
m_pExposureTimer->stop();
|
||
|
|
ui->ExposureTimeSpin->setEnabled(true);
|
||
|
|
ui->ExposureTimeSpin->blockSignals(false);
|
||
|
|
}
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ Update Exposure mode and value timeout slot
|
||
|
|
\param[in]
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CExposureGain::ExposureUpdate()
|
||
|
|
{
|
||
|
|
GX_STATUS emStatus = GX_STATUS_SUCCESS;
|
||
|
|
int64_t i64Entry = GX_EXPOSURE_AUTO_OFF;
|
||
|
|
|
||
|
|
emStatus = GXGetEnum(m_hDevice, GX_ENUM_EXPOSURE_AUTO, &i64Entry);
|
||
|
|
if (emStatus != GX_STATUS_SUCCESS)
|
||
|
|
{
|
||
|
|
m_pExposureTimer->stop();
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
}
|
||
|
|
|
||
|
|
// If auto mode is off, stop the timer and enable value edit
|
||
|
|
if (i64Entry == GX_EXPOSURE_AUTO_OFF)
|
||
|
|
{
|
||
|
|
ui->ExposureAuto->setCurrentIndex(ui->ExposureAuto->findData(qVariantFromValue(i64Entry)));
|
||
|
|
|
||
|
|
ui->ExposureTimeSpin->setEnabled(true);
|
||
|
|
ui->ExposureTimeSpin->blockSignals(false);
|
||
|
|
m_pExposureTimer->stop();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
ui->ExposureTimeSpin->blockSignals(true);
|
||
|
|
}
|
||
|
|
|
||
|
|
double dExposureTime = 0;
|
||
|
|
emStatus = GXGetFloat(m_hDevice, GX_FLOAT_EXPOSURE_TIME, &dExposureTime);
|
||
|
|
if (emStatus != GX_STATUS_SUCCESS)
|
||
|
|
{
|
||
|
|
m_pExposureTimer->stop();
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
}
|
||
|
|
|
||
|
|
ui->ExposureTimeSpin->setValue(dExposureTime);
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ ExposureTime Value changed slot
|
||
|
|
\param[in]
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CExposureGain::on_ExposureTimeSpin_valueChanged(double dExposureTime)
|
||
|
|
{
|
||
|
|
GX_STATUS emStatus = GX_STATUS_SUCCESS;
|
||
|
|
emStatus = GXSetFloat(m_hDevice, GX_FLOAT_EXPOSURE_TIME, dExposureTime);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ AutoExposureTimeMin Value changed slot
|
||
|
|
\param[in]
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CExposureGain::on_AutoExposureTimeMinSpin_valueChanged(double dAutoExposureTimeMin)
|
||
|
|
{
|
||
|
|
GX_STATUS emStatus = GX_STATUS_SUCCESS;
|
||
|
|
emStatus = GXSetFloat(m_hDevice, GX_FLOAT_AUTO_EXPOSURE_TIME_MIN, dAutoExposureTimeMin);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
AutoExposureTimeRangeUpdate();
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ AutoExposureTimeMax Value changed slot
|
||
|
|
\param[in]
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CExposureGain::on_AutoExposureTimeMaxSpin_valueChanged(double dAutoExposureTimeMax)
|
||
|
|
{
|
||
|
|
GX_STATUS emStatus = GX_STATUS_SUCCESS;
|
||
|
|
emStatus = GXSetFloat(m_hDevice, GX_FLOAT_AUTO_EXPOSURE_TIME_MAX, dAutoExposureTimeMax);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
AutoExposureTimeRangeUpdate();
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ GainAuto nIndex changed slot
|
||
|
|
\param[in] nIndex nIndex selected
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CExposureGain::on_GainAuto_activated(int nIndex)
|
||
|
|
{
|
||
|
|
GX_STATUS emStatus = GX_STATUS_SUCCESS;
|
||
|
|
// Set gain auto
|
||
|
|
emStatus = GXSetEnum(m_hDevice, GX_ENUM_GAIN_AUTO, ui->GainAuto->itemData(nIndex).value<int64_t>());
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
// If auto mode is on, start a timer to refresh new value
|
||
|
|
if (ui->GainAuto->itemData(nIndex).value<int64_t>() != GX_GAIN_AUTO_OFF)
|
||
|
|
{
|
||
|
|
// Refresh interval 100ms
|
||
|
|
const int nGainRefreshInterval = 100;
|
||
|
|
m_pGainTimer->start(nGainRefreshInterval);
|
||
|
|
ui->GainSpin->setEnabled(false);
|
||
|
|
ui->GainSpin->blockSignals(true);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
m_pExposureTimer->stop();
|
||
|
|
ui->GainSpin->setEnabled(true);
|
||
|
|
ui->GainSpin->blockSignals(false);
|
||
|
|
}
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ Update Gain mode and value timeout slot
|
||
|
|
\param[in]
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CExposureGain::GainUpdate()
|
||
|
|
{
|
||
|
|
GX_STATUS emStatus = GX_STATUS_SUCCESS;
|
||
|
|
int64_t i64Entry = GX_GAIN_AUTO_OFF;
|
||
|
|
|
||
|
|
emStatus = GXGetEnum(m_hDevice, GX_ENUM_GAIN_AUTO, &i64Entry);
|
||
|
|
if (emStatus != GX_STATUS_SUCCESS)
|
||
|
|
{
|
||
|
|
m_pGainTimer->stop();
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (i64Entry == GX_GAIN_AUTO_OFF)
|
||
|
|
{
|
||
|
|
ui->GainAuto->setCurrentIndex(ui->GainAuto->findData(qVariantFromValue(i64Entry)));
|
||
|
|
|
||
|
|
ui->GainSpin->setEnabled(true);
|
||
|
|
ui->GainSpin->blockSignals(false);
|
||
|
|
m_pGainTimer->stop();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
ui->GainSpin->blockSignals(true);
|
||
|
|
}
|
||
|
|
|
||
|
|
double dGain = 0;
|
||
|
|
emStatus = GXGetFloat(m_hDevice, GX_FLOAT_GAIN, &dGain);
|
||
|
|
if (emStatus != GX_STATUS_SUCCESS)
|
||
|
|
{
|
||
|
|
m_pGainTimer->stop();
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
}
|
||
|
|
|
||
|
|
ui->GainSpin->setValue(dGain);
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ Gain Value changed slot
|
||
|
|
\param[in]
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CExposureGain::on_GainSpin_valueChanged(double dGain)
|
||
|
|
{
|
||
|
|
GX_STATUS emStatus = GX_STATUS_SUCCESS;
|
||
|
|
emStatus = GXSetFloat(m_hDevice, GX_FLOAT_GAIN, dGain);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ AutoGainMin Value changed slot
|
||
|
|
\param[in]
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CExposureGain::on_AutoGainMinSpin_valueChanged(double dAutoGainMin)
|
||
|
|
{
|
||
|
|
GX_STATUS emStatus = GX_STATUS_SUCCESS;
|
||
|
|
emStatus = GXSetFloat(m_hDevice, GX_FLOAT_AUTO_GAIN_MIN, dAutoGainMin);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
AutoGainRangeUpdate();
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ AutoGainMax Value changed slot
|
||
|
|
\param[in]
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CExposureGain::on_AutoGainMaxSpin_valueChanged(double dAutoGainMax)
|
||
|
|
{
|
||
|
|
GX_STATUS emStatus = GX_STATUS_SUCCESS;
|
||
|
|
emStatus = GXSetFloat(m_hDevice, GX_FLOAT_AUTO_GAIN_MAX, dAutoGainMax);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
AutoGainRangeUpdate();
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ AAROIWidth Value changed slot
|
||
|
|
\param[in] nWidth Changed value from slider
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CExposureGain::on_AAROIWidthSlider_valueChanged(int nWidth)
|
||
|
|
{
|
||
|
|
nWidth = (nWidth / m_i64AAWidthInc) * m_i64AAWidthInc;
|
||
|
|
|
||
|
|
GX_STATUS emStatus = GX_STATUS_SUCCESS;
|
||
|
|
emStatus = GXSetInt(m_hDevice, GX_INT_AAROI_WIDTH, nWidth);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
ui->AAROIWidthSpin->setValue(nWidth);
|
||
|
|
|
||
|
|
AAROIRangeUpdate();
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ AAROIWidth Value changed slot
|
||
|
|
\param[in]
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CExposureGain::on_AAROIWidthSpin_valueChanged(int nWidth)
|
||
|
|
{
|
||
|
|
nWidth = (nWidth / m_i64AAWidthInc) * m_i64AAWidthInc;
|
||
|
|
|
||
|
|
GX_STATUS emStatus = GX_STATUS_SUCCESS;
|
||
|
|
emStatus = GXSetInt(m_hDevice, GX_INT_AAROI_WIDTH, nWidth);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
ui->AAROIWidthSpin->setValue(nWidth);
|
||
|
|
ui->AAROIWidthSlider->setValue(nWidth);
|
||
|
|
|
||
|
|
AAROIRangeUpdate();
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ AAROIHeight Value changed slot
|
||
|
|
\param[in] nHeight Changed value from slider
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CExposureGain::on_AAROIHeightSlider_valueChanged(int nHeight)
|
||
|
|
{
|
||
|
|
nHeight = (nHeight / m_i64AAHeightInc) * m_i64AAHeightInc;
|
||
|
|
|
||
|
|
GX_STATUS emStatus = GX_STATUS_SUCCESS;
|
||
|
|
emStatus = GXSetInt(m_hDevice, GX_INT_AAROI_HEIGHT, nHeight);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
ui->AAROIHeightSpin->setValue(nHeight);
|
||
|
|
|
||
|
|
AAROIRangeUpdate();
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ AAROIHeight Value changed slot
|
||
|
|
\param[in]
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CExposureGain::on_AAROIHeightSpin_valueChanged(int nHeight)
|
||
|
|
{
|
||
|
|
nHeight = (nHeight / m_i64AAHeightInc) * m_i64AAHeightInc;
|
||
|
|
|
||
|
|
GX_STATUS emStatus = GX_STATUS_SUCCESS;
|
||
|
|
emStatus = GXSetInt(m_hDevice, GX_INT_AAROI_HEIGHT, nHeight);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
ui->AAROIHeightSpin->setValue(nHeight);
|
||
|
|
ui->AAROIHeightSlider->setValue(nHeight);
|
||
|
|
|
||
|
|
AAROIRangeUpdate();
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ AAROIOffsetX Value changed slot
|
||
|
|
\param[in] nOffsetX Changed value from slider
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CExposureGain::on_AAROIOffsetXSlider_valueChanged(int nOffsetX)
|
||
|
|
{
|
||
|
|
nOffsetX = (nOffsetX / m_i64AAOffsetXInc) * m_i64AAOffsetXInc;
|
||
|
|
|
||
|
|
GX_STATUS emStatus = GX_STATUS_SUCCESS;
|
||
|
|
emStatus = GXSetInt(m_hDevice, GX_INT_AAROI_OFFSETX, nOffsetX);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
ui->AAROIOffsetXSpin->setValue(nOffsetX);
|
||
|
|
|
||
|
|
AAROIRangeUpdate();
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ AAROIOffsetX Value changed slot
|
||
|
|
\param[in]
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CExposureGain::on_AAROIOffsetXSpin_valueChanged(int nOffsetX)
|
||
|
|
{
|
||
|
|
nOffsetX = (nOffsetX / m_i64AAOffsetXInc) * m_i64AAOffsetXInc;
|
||
|
|
|
||
|
|
GX_STATUS emStatus = GX_STATUS_SUCCESS;
|
||
|
|
emStatus = GXSetInt(m_hDevice, GX_INT_AAROI_OFFSETX, nOffsetX);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
ui->AAROIOffsetXSpin->setValue(nOffsetX);
|
||
|
|
ui->AAROIOffsetXSlider->setValue(nOffsetX);
|
||
|
|
|
||
|
|
AAROIRangeUpdate();
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ AAROIOffsetY Value changed slot
|
||
|
|
\param[in] nOffsetY Changed value from slider
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CExposureGain::on_AAROIOffsetYSlider_valueChanged(int nOffsetY)
|
||
|
|
{
|
||
|
|
nOffsetY = (nOffsetY / m_i64AAOffsetYInc) * m_i64AAOffsetYInc;
|
||
|
|
|
||
|
|
GX_STATUS emStatus = GX_STATUS_SUCCESS;
|
||
|
|
emStatus = GXSetInt(m_hDevice, GX_INT_AAROI_OFFSETY, nOffsetY);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
ui->AAROIOffsetYSpin->setValue(nOffsetY);
|
||
|
|
|
||
|
|
AAROIRangeUpdate();
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ AAROIOffsetY Value changed slot
|
||
|
|
\param[in]
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CExposureGain::on_AAROIOffsetYSpin_valueChanged(int nOffsetY)
|
||
|
|
{
|
||
|
|
nOffsetY = (nOffsetY / m_i64AAOffsetYInc) * m_i64AAOffsetYInc;
|
||
|
|
|
||
|
|
GX_STATUS emStatus = GX_STATUS_SUCCESS;
|
||
|
|
emStatus = GXSetInt(m_hDevice, GX_INT_AAROI_OFFSETY, nOffsetY);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
ui->AAROIOffsetYSpin->setValue(nOffsetY);
|
||
|
|
ui->AAROIOffsetYSlider->setValue(nOffsetY);
|
||
|
|
|
||
|
|
AAROIRangeUpdate();
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ ExpectedGray Value changed slot
|
||
|
|
\param[in] nGrayValue Changed value from slider
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CExposureGain::on_ExpectedGrayValueSlider_valueChanged(int nGrayValue)
|
||
|
|
{
|
||
|
|
GX_STATUS emStatus = GX_STATUS_SUCCESS;
|
||
|
|
emStatus = GXSetInt(m_hDevice, GX_INT_GRAY_VALUE, nGrayValue);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
ui->ExpectedGrayValueSpin->setValue(nGrayValue);
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ ExpectedGray Value changed slot
|
||
|
|
\param[in]
|
||
|
|
\param[out]
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CExposureGain::on_ExpectedGrayValueSpin_valueChanged(int nGrayValue)
|
||
|
|
{
|
||
|
|
GX_STATUS emStatus = GX_STATUS_SUCCESS;
|
||
|
|
emStatus = GXSetInt(m_hDevice, GX_INT_GRAY_VALUE, nGrayValue);
|
||
|
|
GX_VERIFY(emStatus);
|
||
|
|
|
||
|
|
ui->ExpectedGrayValueSlider->setValue(nGrayValue);
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|