You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
871 lines
21 KiB
C++
871 lines
21 KiB
C++
#include "CameraPool.h"
|
|
#include <QDebug>
|
|
#include "callbackFunc.h"
|
|
#include "lpCameraConfig.h"
|
|
#include "QFunctionTransfer.h"
|
|
|
|
CCameraPool::CCameraPool(void)
|
|
: m_libs("")
|
|
{
|
|
m_nFrameRate = 0;
|
|
m_nCameraEncode = 0;
|
|
}
|
|
|
|
CCameraPool::~CCameraPool(void)
|
|
{
|
|
releaseImagesList();
|
|
}
|
|
|
|
int CCameraPool::InitPool()
|
|
{
|
|
int nRet = 0;
|
|
|
|
return nRet;
|
|
}
|
|
|
|
void CCameraPool::FreePool()
|
|
{
|
|
|
|
ICloseDevices();
|
|
IDeleteDameraes();
|
|
}
|
|
|
|
int CCameraPool::ICreateCamDevices()
|
|
{
|
|
QList<QString> keys = lpCameraConfig::instance()->CameraKeys();
|
|
for (int i = 0; i < keys.size(); ++i)
|
|
{
|
|
if (m_CamDevMap.contains(keys[i]))
|
|
{
|
|
continue;
|
|
}
|
|
ICameraObject* pObject = m_libs.Create(lpCameraConfig::instance()->getCameraOption(keys[i]), this);
|
|
if (NULL == pObject)
|
|
{
|
|
continue;
|
|
}
|
|
pObject->m_pCamOpt->status = TP_CAMERA_STATUS_INITED;
|
|
m_CamDevMap.insert(keys[i], pObject);
|
|
}
|
|
return m_CamDevMap.size();
|
|
}
|
|
|
|
bool CCameraPool::ICreateCamera(const QString& strSerial, int nType)
|
|
{
|
|
if (m_CamDevMap.contains(strSerial))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
TP_CAMERA_OPTION camOpt;
|
|
camOpt.deviceType = nType;
|
|
camOpt.uniqueName = strSerial;
|
|
|
|
ICameraObject* pObject = m_libs.Create(&camOpt, this);
|
|
if (NULL == pObject)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
pObject->m_pCamOpt->status = TP_CAMERA_STATUS_INITED;
|
|
m_CamDevMap.insert(strSerial, pObject);
|
|
lpCameraConfig::instance()->addCameraOption(strSerial, camOpt);
|
|
return true;
|
|
}
|
|
|
|
bool CCameraPool::IOpenCamera(const QString& strSerial, bool bReopen)
|
|
{
|
|
ICameraObject* pCamera = m_CamDevMap.value(strSerial);
|
|
if (!pCamera)
|
|
return false;
|
|
|
|
if (bReopen)
|
|
{
|
|
pCamera->ICloseCamera();
|
|
pCamera->m_pCamOpt->status = TP_CAMERA_STATUS_CLOSED;
|
|
}
|
|
|
|
int nret = pCamera->IOpenCamera();
|
|
if (nret == 1){
|
|
pCamera->m_pCamOpt->status = TP_CAMERA_STATUS_OPENED;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CCameraPool::ICloseCamera(const QString& strSerial)
|
|
{
|
|
ICameraObject* pCamera = m_CamDevMap.value(strSerial);
|
|
if (!pCamera)
|
|
return false;
|
|
|
|
pCamera->ICloseCamera();
|
|
pCamera->m_pCamOpt->status = TP_CAMERA_STATUS_CLOSED;
|
|
return true;
|
|
}
|
|
|
|
bool CCameraPool::IDelCamera(const QString& strSerial)
|
|
{
|
|
ICameraObject* pCamera = m_CamDevMap.value(strSerial);
|
|
if (pCamera){
|
|
pCamera->IStopCamera();
|
|
pCamera->ICloseCamera();
|
|
|
|
pCamera->m_pCamOpt->status = TP_CAMERA_STATUS_UNINIT;
|
|
m_libs.Delete(pCamera);
|
|
}
|
|
m_CamDevMap.remove(strSerial);
|
|
lpCameraConfig::instance()->delCameraOption(strSerial);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CCameraPool::IAddCamera(const QString& strName, const TP_CAMERA_OPTION& camOpt)
|
|
{
|
|
bool bret = false;
|
|
if(m_CamDevMap.contains(strName))
|
|
{
|
|
bret = ICloseCamera(strName);
|
|
if (!bret) return bret;
|
|
}
|
|
|
|
lpCameraConfig::instance()->addCameraOption(strName, camOpt);
|
|
|
|
{
|
|
ICameraObject* pCamObj = m_libs.Create(lpCameraConfig::instance()->getCameraOption(strName), this);
|
|
if (pCamObj)
|
|
{
|
|
pCamObj->m_pCamOpt->status = TP_CAMERA_STATUS_INITED;
|
|
m_CamDevMap.insert(strName, pCamObj);
|
|
}
|
|
else{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bret = IOpenCamera(strName, true);
|
|
if (!bret) return bret;
|
|
|
|
{
|
|
bret = IStartCamera(strName);
|
|
}
|
|
return bret;
|
|
}
|
|
|
|
bool CCameraPool::IRunAlg(const QString& strSerial, bool bRun)
|
|
{
|
|
ICameraObject* pCamera = m_CamDevMap.value(strSerial);
|
|
if (!pCamera)
|
|
return false;
|
|
pCamera->m_pCamOpt->bAutoRunAlg = bRun;
|
|
return true;
|
|
}
|
|
|
|
bool CCameraPool::IStartCamera(const QString& strSerial)
|
|
{
|
|
ICameraObject* pCamera = m_CamDevMap.value(strSerial);
|
|
if (!pCamera)
|
|
return false;
|
|
|
|
int nret = pCamera->IStartCamera();
|
|
if (nret == 1){
|
|
pCamera->m_pCamOpt->status = TP_CAMERA_STATUS_STARTED;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CCameraPool::IStopCamera(const QString& strSerial)
|
|
{
|
|
ICameraObject* pCamera = m_CamDevMap.value(strSerial);
|
|
if (!pCamera)
|
|
return false;
|
|
|
|
pCamera->IStopCamera();
|
|
pCamera->m_pCamOpt->status = TP_CAMERA_STATUS_STOPPED;
|
|
return true;
|
|
}
|
|
|
|
void CCameraPool::IDeleteDameraes()
|
|
{
|
|
IStopDevices();
|
|
ICloseDevices();
|
|
m_CamDevMap.clear(cameraErased, &m_libs);
|
|
}
|
|
|
|
void CCameraPool::cameraOpen(class ICameraObject*& pCam, void* pData)
|
|
{
|
|
if (!pCam) return;
|
|
|
|
if (pCam->IOpenCamera() == 1)
|
|
{
|
|
pCam->m_pCamOpt->status = TP_CAMERA_STATUS_OPENED;
|
|
}
|
|
}
|
|
|
|
void CCameraPool::cameraOpenEx(class ICameraObject*& pCam, void* pData)
|
|
{
|
|
if (!pCam) return;
|
|
if (pCam->m_pCamOpt->bAutoOpen)
|
|
{
|
|
if (pCam->IOpenCamera() == 1)
|
|
{
|
|
pCam->m_pCamOpt->status = TP_CAMERA_STATUS_OPENED;
|
|
}
|
|
}
|
|
}
|
|
|
|
int CCameraPool::IOpenDevices(bool bReopenAll)
|
|
{
|
|
if( bReopenAll )
|
|
{
|
|
ICloseDevices();
|
|
}
|
|
m_CamDevMap.iterateCall(cameraOpen, NULL);
|
|
m_CamDevMap.iterateCall(cameraCalRelyOn, &m_CamDevMap);
|
|
return 1;
|
|
}
|
|
|
|
int CCameraPool::IOpenDevicesEx(bool bReopenAll)
|
|
{
|
|
if (bReopenAll)
|
|
{
|
|
ICloseDevices();
|
|
}
|
|
m_CamDevMap.iterateCall(cameraOpenEx, NULL);
|
|
m_CamDevMap.iterateCall(cameraCalRelyOnEx, &m_CamDevMap);
|
|
return 1;
|
|
}
|
|
|
|
int CCameraPool::InitDevices()
|
|
{
|
|
for (QZkMutexMap<QString, class ICameraObject *>::iterator it = m_CamDevMap.begin(); it != m_CamDevMap.end(); ++it)
|
|
{
|
|
ICameraObject* pCamObj = *it;
|
|
if (pCamObj)
|
|
{
|
|
pCamObj->InitProperty();
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
void CCameraPool::cameraClose(class ICameraObject*& pCam, void* pData)
|
|
{
|
|
if (!pCam) return;
|
|
|
|
pCam->ICloseCamera();
|
|
pCam->m_pCamOpt->status = TP_CAMERA_STATUS_CLOSED;
|
|
}
|
|
void CCameraPool::ICloseDevices()
|
|
{
|
|
m_CamDevMap.iterateCall(cameraClose, NULL);
|
|
}
|
|
|
|
|
|
void CCameraPool::IStartDevices()
|
|
{
|
|
|
|
m_CamDevMap.iterateCall(cameraStartDevices, NULL);
|
|
}
|
|
|
|
void CCameraPool::IStopDevices(const QString& sDef/* = NULL*/)
|
|
{
|
|
if (sDef.isEmpty())
|
|
{
|
|
m_CamDevMap.iterateCall(cameraStopDevices, NULL);
|
|
}
|
|
else
|
|
{
|
|
m_CamDevMap.valueCall(sDef, cameraStopDevices, NULL);
|
|
}
|
|
}
|
|
|
|
void CCameraPool::ISetTriggerMode(emTpDeviceTriggerMode mode)
|
|
{
|
|
|
|
}
|
|
|
|
// void CCameraPool::DeviceLost(const QString& strName)
|
|
// {
|
|
// ICameraObject* pObj = m_CamDevMap.take(strName);
|
|
// if (NULL != pObj)
|
|
// {
|
|
// m_libs.Delete(pObj);
|
|
// }
|
|
// }
|
|
|
|
QList<QString> CCameraPool::ICameraKeys()
|
|
{
|
|
return lpCameraConfig::instance()->CameraKeys();
|
|
}
|
|
|
|
QList<QString> CCameraPool::ICameraKeysOrderByIds()
|
|
{
|
|
return lpCameraConfig::instance()->CameraKeysOrderByIds();
|
|
}
|
|
|
|
bool CCameraPool::ICameraOption(const QString& strSerial, TP_CAMERA_OPTION& camOpt)
|
|
{
|
|
return lpCameraConfig::instance()->getCameraOption(strSerial, camOpt);
|
|
}
|
|
|
|
bool CCameraPool::ICameraOptionByKey(const QString& strSerial, TP_CAMERA_OPTION& camOpt)
|
|
{
|
|
return lpCameraConfig::instance()->CameraOptionByKey(strSerial, camOpt);
|
|
}
|
|
|
|
bool CCameraPool::ISetCameraOption(const QString& strSerial, const TP_CAMERA_OPTION& camOpt)
|
|
{
|
|
bool bRet = lpCameraConfig::instance()->SetCameraOption(strSerial, camOpt);
|
|
if (bRet)
|
|
{
|
|
ICameraObject* pCam = m_CamDevMap.value(strSerial, NULL);
|
|
if (NULL != pCam)
|
|
{
|
|
pCam->ISetProperty(NULL);
|
|
}
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
bool CCameraPool::IGetCameraOption(const QString& strSerial, const TP_CAMERA_OPTION& camOpt)
|
|
{
|
|
bool bRet = lpCameraConfig::instance()->SetCameraOption(strSerial, camOpt);
|
|
if (bRet)
|
|
{
|
|
ICameraObject* pCam = m_CamDevMap.value(strSerial, NULL);
|
|
if (NULL != pCam)
|
|
{
|
|
//return pCam->IGetProperty(&camOpt);
|
|
}
|
|
}
|
|
return bRet;
|
|
}
|
|
QList<QString> CCameraPool::IEnumAvailableCameras(emTpDeviceType camType)
|
|
{
|
|
QList<QString> ret;
|
|
|
|
// if the camera dll has been loaded
|
|
QZkMutexMap<QString, class ICameraObject*>::const_iterator iter = m_CamDevMap.constBegin();
|
|
while (iter != m_CamDevMap.constEnd())
|
|
{
|
|
ICameraObject* pCam = iter.value();
|
|
if (pCam && pCam->m_pCamOpt->deviceType == camType){
|
|
ret = pCam->IEnumAvailableCameras();
|
|
return ret;
|
|
}
|
|
iter++;
|
|
}
|
|
|
|
// the camera dll has not been loaded
|
|
TP_CAMERA_OPTION camOpt;
|
|
camOpt.deviceType = camType;
|
|
|
|
ret = m_libs.enumAvailableCameras(&camOpt, this);
|
|
return ret;
|
|
}
|
|
|
|
// void CCameraPool::ISetTriggerMode(emTpDeviceTriggerMode mode/* = TRIGGER_DIRECT_FOREWARD */, long nFrameRate /* = 0 */)
|
|
// {
|
|
// // gGlobalPoolOption.triggerMode = mode;
|
|
// // gGlobalPoolOption.triggerDirection = nDirection;
|
|
// // gGlobalPoolOption.frameRate = nFrameRate;
|
|
// // gGlobalPoolOption.fixedFrames = nFrameRate;
|
|
// // m_nTriggerMode = mode;
|
|
// // m_nFrameRate = nFrameRate;
|
|
// // //set every device's trigger
|
|
// // m_thdTrigger.LockWorked();
|
|
// // m_cameraes.iterateCall(cameraSetTriggerMode, &gGlobalPoolOption);
|
|
// // IStartDevices();
|
|
// // m_thdTrigger.UnlockWorked();
|
|
// //begin or end trigger's thread
|
|
// if( DEV_TRIGGER_MODE_AUTO != mode &&
|
|
// DEV_TRIGGER_MODE_FIXED_AUTO != mode )
|
|
// {
|
|
// //m_thdTrigger.EndThread();
|
|
// // m_thdTrigger.SetAutoTrigger(false);
|
|
// }
|
|
// else
|
|
// {
|
|
// // m_thdTrigger.SetFrame(nFrameRate);
|
|
// //m_thdTrigger.StartTrigger();
|
|
// // m_thdTrigger.SetAutoTrigger(true);
|
|
// }
|
|
// }
|
|
|
|
void gfunc_snap_camera_image(const QString& key, class ICameraObject*& pCam, void* pData)
|
|
{
|
|
if (!pCam)
|
|
return;
|
|
QStringList* pKeys = (QStringList*)pData;
|
|
if (!pKeys->contains(key))
|
|
{
|
|
return;
|
|
}
|
|
pCam->ISnapCamera();
|
|
}
|
|
|
|
void CCameraPool::ISnapImage(const QStringList& camKeys)
|
|
{
|
|
foreach(QString var, camKeys) {
|
|
QZkMutexMap<QString, class ICameraObject *>::iterator it = m_CamDevMap.find(var);
|
|
if (it != m_CamDevMap.end())
|
|
{
|
|
ICameraObject* pObj = *it;
|
|
if (pObj)
|
|
{
|
|
pObj->ISnapCamera();
|
|
}
|
|
}
|
|
}
|
|
// m_CamDevMap.iterateCall2(gfunc_snap_camera_image, (void*)(&camKeys));
|
|
}
|
|
|
|
void gfunc_send_soft_trigger(const QString& key, class ICameraObject*& pCam, void* pData)
|
|
{
|
|
if (!pCam) return;
|
|
|
|
// if (NULL != pCam->RelyOnCamera())
|
|
// {
|
|
// return;
|
|
// }
|
|
if (NULL != pData)
|
|
{
|
|
QStringList* pKeys = (QStringList*)pData;
|
|
if (!pKeys->contains(key))
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
// pCam->ISendSoftTrigger();
|
|
}
|
|
|
|
void CCameraPool::ISendSoftTrigger(const QStringList& camKeys)
|
|
{
|
|
if (camKeys.isEmpty())
|
|
{
|
|
m_CamDevMap.iterateCall2(gfunc_send_soft_trigger, NULL);
|
|
}
|
|
else
|
|
{
|
|
m_CamDevMap.iterateCall2(gfunc_send_soft_trigger, (void*)(&camKeys));
|
|
}
|
|
}
|
|
|
|
|
|
void CCameraPool::calRelyOn()
|
|
{
|
|
m_CamDevMap.iterateCall(cameraCalRelyOn, &m_CamDevMap);
|
|
}
|
|
|
|
void CCameraPool::ISetCameraProperty(const QString& camera, emTpCameraProperty property, long nValue)
|
|
{
|
|
}
|
|
|
|
void CCameraPool::ISetCameraProperty(const QString& camera, TP_CAMERA_PROPERTY& property)
|
|
{
|
|
if( camera.isNull() )
|
|
{
|
|
m_CamDevMap.iterateCall(cameraSetProperty, &property);
|
|
}
|
|
else
|
|
{
|
|
m_CamDevMap.valueCall(camera, cameraSetProperty, &property);
|
|
}
|
|
}
|
|
|
|
|
|
void CCameraPool::IGetCameraProperty(const QString& camera, TP_CAMERA_PROPERTY& property)
|
|
{
|
|
|
|
}
|
|
|
|
void CCameraPool::cameraSetProperty(class ICameraObject*& pCam, void* pData)
|
|
{
|
|
if (!pCam) return;
|
|
pCam->ISetProperty((TP_CAMERA_PROPERTY*)pData);
|
|
}
|
|
|
|
lpCameraImage* CCameraPool::IPopCameraImage()
|
|
{
|
|
return m_imagesList.takeFirst(NULL);
|
|
}
|
|
|
|
int CCameraPool::createDeviceByOptiones()
|
|
{
|
|
QList<QString> keys = lpCameraConfig::instance()->CameraKeys();
|
|
for( int i = 0; i < keys.size(); ++i )
|
|
{
|
|
if( m_CamDevMap.contains(keys[i]) )
|
|
{
|
|
continue;
|
|
}
|
|
ICameraObject* pObject = m_libs.Create(lpCameraConfig::instance()->getCameraOption(keys[i]), this);
|
|
if( NULL == pObject )
|
|
{
|
|
continue;
|
|
}
|
|
if( 0 == pObject->IOpenCamera() )
|
|
{
|
|
m_libs.Delete(pObject);
|
|
continue;
|
|
}
|
|
pObject->m_pCamOpt->status = TP_CAMERA_STATUS_OPENED;
|
|
m_CamDevMap.insert(keys[i], pObject);
|
|
}
|
|
return m_CamDevMap.size();
|
|
}
|
|
|
|
void CCameraPool::cameraErased(class ICameraObject*& pCam, void* pData)
|
|
{
|
|
if (!pCam)
|
|
return;
|
|
CLibCamera* pLibs = (CLibCamera*)pData;
|
|
pCam->IStopCamera();
|
|
pCam->ICloseCamera();
|
|
|
|
pCam->m_pCamOpt->status = TP_CAMERA_STATUS_UNINIT;
|
|
pLibs->Delete(pCam);
|
|
}
|
|
|
|
void CCameraPool::cameraStartDevices(class ICameraObject*& pCam, void* pData)
|
|
{
|
|
if (!pCam)
|
|
return;
|
|
if (pCam->IStartCamera() == 1){
|
|
pCam->m_pCamOpt->status = TP_CAMERA_STATUS_STARTED;
|
|
}
|
|
}
|
|
|
|
void CCameraPool::cameraStopDevices(class ICameraObject*& pCam, void* pData)
|
|
{
|
|
if (!pCam) return;
|
|
pCam->IStopCamera();
|
|
pCam->m_pCamOpt->status = TP_CAMERA_STATUS_STOPPED;
|
|
}
|
|
|
|
void CCameraPool::cameraSetTriggerMode(class ICameraObject*& pCam, void* pData)
|
|
{
|
|
|
|
}
|
|
|
|
void CCameraPool::cameraSnaps(class ICameraObject*& pCam, void* pData)
|
|
{
|
|
if (!pCam) return;
|
|
|
|
pCam->ISnapCamera();
|
|
}
|
|
|
|
void CCameraPool::cameraIntervalCaptures(class ICameraObject*& pCam, void* pData)
|
|
{
|
|
if (!pCam) return;
|
|
//tagCOMMIT_TRIGGER_PARAM* pParam = (tagCOMMIT_TRIGGER_PARAM*)pData;
|
|
// if (NULL != pCam->RelyOnCamera())
|
|
// {
|
|
// return;
|
|
// }
|
|
//pCam->ISnapCamera(pParam->direct);
|
|
pCam->IAutoCapture();
|
|
}
|
|
|
|
void CCameraPool::cameraCalRelyOn(class ICameraObject*& pCam, void* pData)
|
|
{
|
|
// if (!pCam) return;
|
|
// QZkMutexMap<QString, class ICameraObject*>* pCameraes = (QZkMutexMap<QString, class ICameraObject*>*)pData;
|
|
// TP_CAMERA_OPTION* pOpt = pCam->m_pCamOpt;
|
|
// if( DEV_CAM_VIRTUAL_FOLDER == pOpt->deviceType && NULL == pCam->RelyOnCamera() && pCameraes->contains(pOpt->relyOnCamera) )
|
|
// {
|
|
// ICameraObject* pCamRelyOn = pCameraes->value(pOpt->relyOnCamera, NULL);
|
|
// if( NULL != pCamRelyOn )
|
|
// {
|
|
// pCam->SetRelyOnCamera(pCamRelyOn);
|
|
// pCamRelyOn->SetReliedByCamera(pCam);
|
|
// }
|
|
// }
|
|
}
|
|
|
|
void CCameraPool::cameraCalRelyOnEx(class ICameraObject*& pCam, void* pData)
|
|
{
|
|
// if (!pCam) return;
|
|
// QZkMutexMap<QString, class ICameraObject*>* pCameraes = (QZkMutexMap<QString, class ICameraObject*>*)pData;
|
|
// TP_CAMERA_OPTION* pOpt = pCam->m_pCamOpt;
|
|
// if (DEV_CAM_VIRTUAL_FOLDER == pOpt->deviceType && pOpt->bAutoOpen && NULL == pCam->RelyOnCamera() && pCameraes->contains(pOpt->relyOnCamera))
|
|
// {
|
|
// ICameraObject* pCamRelyOn = pCameraes->value(pOpt->relyOnCamera, NULL);
|
|
// if (NULL != pCamRelyOn)
|
|
// {
|
|
// pCam->SetRelyOnCamera(pCamRelyOn);
|
|
// pCamRelyOn->SetReliedByCamera(pCam);
|
|
// }
|
|
// }
|
|
}
|
|
//在主线程中运行？
|
|
int CCameraPool::IPushCameraData(ICameraObject* pCamObj)
|
|
{
|
|
if (m_imagesList.size() >= 32)
|
|
{
|
|
qWarning("Cache OverFlow, Camera Image Count:%d", m_imagesList.size());
|
|
if (pCamObj->m_nFrameNum > 0)
|
|
{
|
|
pCamObj->m_nFrameNum--;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
if (NULL == pCamObj || NULL == pCamObj->m_pCamOpt )
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
lpCameraImage *pImage = m_imagesMerging.value(pCamObj->m_pCamOpt->uniqueName, NULL);
|
|
if (NULL == pImage)
|
|
{
|
|
pImage = new lpCameraImage();
|
|
}
|
|
int nRet = 0;
|
|
if (NULL != pImage)
|
|
{
|
|
//
|
|
int nRet = pImage->CopyCameraObject(pCamObj);
|
|
if (-1 == nRet)
|
|
{
|
|
delete pImage;
|
|
pImage = NULL;
|
|
}
|
|
else if (1 == nRet)
|
|
{
|
|
// if (pCamObj->m_pCamOpt->bAutoRunAlg == false)
|
|
// {
|
|
//
|
|
// delete pImage;
|
|
// pImage = NULL;
|
|
// }
|
|
// else
|
|
{
|
|
QString strSerial = pImage->Serial();
|
|
QImage showImg = pImage->ToQImage();
|
|
QFunctionTransfer::Instance()->execInMain([this, strSerial, showImg]() {
|
|
if (lpCallBackFunc::instance()->m_ImageCallBackFunc)
|
|
{
|
|
lpCallBackFunc::instance()->m_ImageCallBackFunc(strSerial, showImg);
|
|
}
|
|
});
|
|
|
|
try {
|
|
//获取算法参数 绑定到图像
|
|
if (lpCallBackFunc::instance()->m_GetVariantCallBackFunc)
|
|
{
|
|
QVariant val = lpCallBackFunc::instance()->m_GetVariantCallBackFunc(pCamObj->m_pCamOpt->id);
|
|
pImage->SetVarFromUI(val);
|
|
}
|
|
}
|
|
catch (...) {
|
|
qCritical() << "Critical error." << __FUNCTION__;
|
|
return 0;
|
|
}
|
|
|
|
pImage->SetMeterCode(m_nCameraEncode);
|
|
m_imagesList.append(pImage);
|
|
pImage = NULL;
|
|
}
|
|
|
|
}
|
|
m_imagesMerging.insert(pCamObj->m_pCamOpt->uniqueName, pImage);
|
|
nRet = 1;
|
|
}
|
|
|
|
//checks to stop trigger in fixed_auto
|
|
return nRet;
|
|
}
|
|
|
|
//don't combine image
|
|
int CCameraPool::IPushCameraData2(ICameraObject* pCamObj)
|
|
{
|
|
if (m_imagesList.size() >= 32)
|
|
{
|
|
qWarning("Cache OverFlow, Camera Image Count:%d", m_imagesList.size());
|
|
}
|
|
|
|
quint64 msec = QDateTime::currentMSecsSinceEpoch();
|
|
if (NULL == pCamObj || NULL == pCamObj->m_pCamOpt)
|
|
{
|
|
return 0;
|
|
}
|
|
// if (pCamObj->m_pCamOpt->bIgnoreImage)
|
|
{
|
|
if (pCamObj->m_nFrameNum > 0)
|
|
{
|
|
pCamObj->m_nFrameNum--;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// pCamObj->SaveToFile();
|
|
|
|
lpCameraImage* pImage = new lpCameraImage();
|
|
if (NULL == pImage)
|
|
{
|
|
return 0;
|
|
}
|
|
if (0 == pImage->CopyCameraObject2(pCamObj))
|
|
{
|
|
delete pImage;
|
|
return 0;
|
|
}
|
|
|
|
if (lpCallBackFunc::instance()->m_GetVariantCallBackFunc)
|
|
{
|
|
QVariant val = lpCallBackFunc::instance()->m_GetVariantCallBackFunc(pCamObj->m_pCamOpt->id);
|
|
pImage->SetVarFromUI(val);
|
|
}
|
|
m_imagesList.append(pImage);
|
|
|
|
return 1;
|
|
}
|
|
|
|
bool CCameraPool::IGetWidth(const QString& strSerial, int& width)
|
|
{
|
|
ICameraObject* pCam = m_CamDevMap.value(strSerial, NULL);
|
|
if (NULL != pCam)
|
|
{
|
|
TP_CAMERA_PROPERTY nProperty;
|
|
nProperty.property = TP_CAM_PROPERTY_IMAGE_WIDTH;
|
|
bool bRet = pCam->IGetProperty(&nProperty);
|
|
width = nProperty.value;
|
|
return bRet;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CCameraPool::ISetWidth(const QString& strSerial, int& width)
|
|
{
|
|
ICameraObject* pCam = m_CamDevMap.value(strSerial, NULL);
|
|
if (NULL != pCam)
|
|
{
|
|
TP_CAMERA_PROPERTY nProperty;
|
|
nProperty.property = TP_CAM_PROPERTY_IMAGE_WIDTH;
|
|
nProperty.value = width;
|
|
TP_CAMERA_OPTION* opt = lpCameraConfig::instance()->getCameraOption(strSerial);
|
|
if (opt) {
|
|
opt->width = width;
|
|
}
|
|
return pCam->ISetProperty(&nProperty);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CCameraPool::IGetHeight(const QString& strSerial, int& height)
|
|
{
|
|
ICameraObject* pCam = m_CamDevMap.value(strSerial, NULL);
|
|
if (NULL != pCam)
|
|
{
|
|
TP_CAMERA_PROPERTY nProperty;
|
|
nProperty.property = TP_CAM_PROPERTY_IMAGE_HEIGHT;
|
|
bool bRet = pCam->IGetProperty(&nProperty);
|
|
height = nProperty.value;
|
|
return bRet;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CCameraPool::ISetHeight(const QString& strSerial, int& height)
|
|
{
|
|
ICameraObject* pCam = m_CamDevMap.value(strSerial, NULL);
|
|
if (NULL != pCam)
|
|
{
|
|
TP_CAMERA_PROPERTY nProperty;
|
|
nProperty.property = TP_CAM_PROPERTY_IMAGE_HEIGHT;
|
|
nProperty.value = height;
|
|
TP_CAMERA_OPTION* opt = lpCameraConfig::instance()->getCameraOption(strSerial);
|
|
if (opt) {
|
|
opt->height = height;
|
|
}
|
|
return pCam->ISetProperty(&nProperty);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CCameraPool::IGetGain(const QString& strSerial, int& height)
|
|
{
|
|
ICameraObject* pCam = m_CamDevMap.value(strSerial, NULL);
|
|
if (NULL != pCam)
|
|
{
|
|
TP_CAMERA_PROPERTY nProperty;
|
|
nProperty.property = TP_CAM_PROPERTY_GAIN;
|
|
bool bRet = pCam->IGetProperty(&nProperty);
|
|
height = nProperty.value;
|
|
return bRet;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CCameraPool::ISetGain(const QString& strSerial, int& height)
|
|
{
|
|
ICameraObject* pCam = m_CamDevMap.value(strSerial, NULL);
|
|
if (NULL != pCam)
|
|
{
|
|
TP_CAMERA_PROPERTY nProperty;
|
|
nProperty.property = TP_CAM_PROPERTY_GAIN;
|
|
nProperty.value = height;
|
|
pCam->ISetProperty(&nProperty);
|
|
TP_CAMERA_OPTION* opt = lpCameraConfig::instance()->getCameraOption(strSerial);
|
|
if (opt) {
|
|
opt->gain = height;
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CCameraPool::IGetExposureTime(const QString& strSerial, int& height)
|
|
{
|
|
ICameraObject* pCam = m_CamDevMap.value(strSerial, NULL);
|
|
if (NULL != pCam)
|
|
{
|
|
TP_CAMERA_PROPERTY nProperty;
|
|
nProperty.property = TP_CAM_PROPERTY_EXPOSURE;
|
|
bool bRet = pCam->IGetProperty(&nProperty);
|
|
height = nProperty.value;
|
|
return bRet;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CCameraPool::ISetExposureTime(const QString& strSerial, int& height)
|
|
{
|
|
ICameraObject* pCam = m_CamDevMap.value(strSerial, NULL);
|
|
if (NULL != pCam)
|
|
{
|
|
TP_CAMERA_PROPERTY nProperty;
|
|
nProperty.property = TP_CAM_PROPERTY_EXPOSURE;
|
|
nProperty.value = height;
|
|
pCam->ISetProperty(&nProperty);
|
|
|
|
TP_CAMERA_OPTION* opt = lpCameraConfig::instance()->getCameraOption(strSerial);
|
|
if (opt) {
|
|
opt->exposure = height;
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void CCameraPool::IFreeCameraImage(lpCameraImage *pCamImg)
|
|
{
|
|
delete pCamImg;
|
|
}
|
|
|
|
QMap<QString, QString> CCameraPool::IGetCamShowNames()
|
|
{
|
|
return lpCameraConfig::instance()->GetCamShowNames();
|
|
}
|
|
|
|
void CCameraPool::ISetCameraEncode(INT64 code, INT64 rate)
|
|
{
|
|
m_nCameraEncode = code;
|
|
m_nEncoderRate = rate;
|
|
}
|
|
|
|
|