|
|
|
|
@ -0,0 +1,883 @@
|
|
|
|
|
/******************************************************************************
|
|
|
|
|
Copyright(C):2015~2018 hzleaper
|
|
|
|
|
FileName:CameraPool.cpp
|
|
|
|
|
Author:zhikun wu
|
|
|
|
|
Email:zk.wu@hzleaper.com
|
|
|
|
|
Tools:vs2010 pc on company
|
|
|
|
|
Created:2015/03/25
|
|
|
|
|
History:25:3:2015 11:28
|
|
|
|
|
*******************************************************************************/
|
|
|
|
|
#include "CameraPool.h"
|
|
|
|
|
#include <QDebug>
|
|
|
|
|
|
|
|
|
|
CCameraPool::CCameraPool(void)
|
|
|
|
|
: m_thdTrigger(this)
|
|
|
|
|
, m_libs(gpGlobalData->tgdDllPath)
|
|
|
|
|
// :m_mutexImgQueue(QMutex::Recursive)
|
|
|
|
|
{
|
|
|
|
|
m_nTriggerMode = DEV_TRIGGER_MODE_STOP;
|
|
|
|
|
m_nFrameRate = 0;
|
|
|
|
|
m_nCameraEncode = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
CCameraPool::~CCameraPool(void)
|
|
|
|
|
{
|
|
|
|
|
releaseImagesList();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int CCameraPool::InitPool()
|
|
|
|
|
{
|
|
|
|
|
int nRet = 0;//IOpenDevices(true);
|
|
|
|
|
m_thdTrigger.StartTrigger();
|
|
|
|
|
return nRet;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void CCameraPool::FreePool()
|
|
|
|
|
{
|
|
|
|
|
m_thdTrigger.EndTrigger();
|
|
|
|
|
ICloseDevices();
|
|
|
|
|
IDeleteDameraes();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int CCameraPool::ICreateCameraes()
|
|
|
|
|
{
|
|
|
|
|
QList<QString> keys = gpGlobalCamera->CameraKeys();//cameraes.keys();
|
|
|
|
|
for (int i = 0; i < keys.size(); ++i)
|
|
|
|
|
{
|
|
|
|
|
if (m_cameraes.contains(keys[i]))
|
|
|
|
|
{
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
ICameraObject* pObject = m_libs.Create(gpGlobalCamera->CameraOption(keys[i]), this);
|
|
|
|
|
if (NULL == pObject)
|
|
|
|
|
{
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
pObject->m_pCamOpt->status = TP_CAMERA_STATUS_INITED;
|
|
|
|
|
m_cameraes.insert(keys[i], pObject);
|
|
|
|
|
}
|
|
|
|
|
return m_cameraes.size();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool CCameraPool::ICreateCamera(const QString& strSerial, int nType)
|
|
|
|
|
{
|
|
|
|
|
if (m_cameraes.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_cameraes.insert(strSerial, pObject);
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool CCameraPool::IOpenCamera(const QString& strSerial, bool bReopen)
|
|
|
|
|
{
|
|
|
|
|
ICameraObject* pCamera = m_cameraes.value(strSerial);
|
|
|
|
|
if (!pCamera)
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
//if (pCamera->m_pCamOpt->status != TP_CAMERA_STATUS_INITED &&
|
|
|
|
|
// pCamera->m_pCamOpt->status != TP_CAMERA_STATUS_CLOSED){
|
|
|
|
|
// 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_cameraes.value(strSerial);
|
|
|
|
|
if (!pCamera)
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
pCamera->ICloseCamera();
|
|
|
|
|
pCamera->m_pCamOpt->status = TP_CAMERA_STATUS_CLOSED;
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool CCameraPool::IDeleteCamera(const QString& strSerial)
|
|
|
|
|
{
|
|
|
|
|
ICameraObject* pCamera = m_cameraes.value(strSerial);
|
|
|
|
|
if (pCamera){
|
|
|
|
|
pCamera->IStopCamera();
|
|
|
|
|
pCamera->ICloseCamera();
|
|
|
|
|
|
|
|
|
|
pCamera->m_pCamOpt->status = TP_CAMERA_STATUS_UNINIT;
|
|
|
|
|
m_libs.Delete(pCamera);
|
|
|
|
|
}
|
|
|
|
|
m_cameraes.remove(strSerial);
|
|
|
|
|
gpGlobalCamera->delCameraOption(strSerial);
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool CCameraPool::IAddCamera(const QString& strName, const TP_CAMERA_OPTION& camOpt, bool bNew, bool bAutoRun/* = false */)
|
|
|
|
|
{
|
|
|
|
|
bool bret = false;
|
|
|
|
|
if (!bNew){
|
|
|
|
|
bret = ICloseCamera(strName);
|
|
|
|
|
if (!bret) return bret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
gpGlobalCamera->updateCameraOption(strName, camOpt);
|
|
|
|
|
|
|
|
|
|
if (bNew){
|
|
|
|
|
ICameraObject* pCamObj = m_libs.Create(gpGlobalCamera->CameraOption(strName), this);
|
|
|
|
|
if (pCamObj)
|
|
|
|
|
{
|
|
|
|
|
pCamObj->m_pCamOpt->status = TP_CAMERA_STATUS_INITED;
|
|
|
|
|
m_cameraes.insert(strName, pCamObj);
|
|
|
|
|
}
|
|
|
|
|
else{
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bret = IOpenCamera(strName, true);
|
|
|
|
|
if (!bret) return bret;
|
|
|
|
|
|
|
|
|
|
if (bAutoRun){
|
|
|
|
|
bret = IStartCamera(strName);
|
|
|
|
|
}
|
|
|
|
|
return bret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool CCameraPool::IStartCamera(const QString& strSerial)
|
|
|
|
|
{
|
|
|
|
|
ICameraObject* pCamera = m_cameraes.value(strSerial);
|
|
|
|
|
if (!pCamera)
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
//if (pCamera->m_pCamOpt->status != TP_CAMERA_STATUS_OPENED &&
|
|
|
|
|
// pCamera->m_pCamOpt->status != TP_CAMERA_STATUS_STOPPED )
|
|
|
|
|
//{
|
|
|
|
|
// 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_cameraes.value(strSerial);
|
|
|
|
|
if (!pCamera)
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
pCamera->IStopCamera();
|
|
|
|
|
pCamera->m_pCamOpt->status = TP_CAMERA_STATUS_STOPPED;
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void CCameraPool::IDeleteDameraes()
|
|
|
|
|
{
|
|
|
|
|
IStopDevices();
|
|
|
|
|
ICloseDevices();
|
|
|
|
|
m_cameraes.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_cameraes.iterateCall(cameraOpen, NULL);
|
|
|
|
|
m_cameraes.iterateCall(cameraCalRelyOn, &m_cameraes);
|
|
|
|
|
//calRelyOn();
|
|
|
|
|
//ISetTriggerMode(DEV_TRIGGER_MODE_AUTO, TRIGGER_DIRECT_FOREWARD, gGlobalPoolOption.frameRate);
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int CCameraPool::IOpenDevicesEx(bool bReopenAll)
|
|
|
|
|
{
|
|
|
|
|
if (bReopenAll)
|
|
|
|
|
{
|
|
|
|
|
ICloseDevices();
|
|
|
|
|
}
|
|
|
|
|
m_cameraes.iterateCall(cameraOpenEx, NULL);
|
|
|
|
|
m_cameraes.iterateCall(cameraCalRelyOnEx, &m_cameraes);
|
|
|
|
|
//calRelyOn();
|
|
|
|
|
//ISetTriggerMode(DEV_TRIGGER_MODE_AUTO, TRIGGER_DIRECT_FOREWARD, gGlobalPoolOption.frameRate);
|
|
|
|
|
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_cameraes.iterateCall(cameraClose, NULL);
|
|
|
|
|
// m_devVessel.Erase(NULL, deviceErased, false);
|
|
|
|
|
//m_cameraes.clear(cameraErased, &m_libs);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void CCameraPool::IStartDevices()
|
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
m_cameraes.iterateCall(cameraStartDevices, NULL);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void CCameraPool::IStopDevices(const QString& sDef/* = NULL*/)
|
|
|
|
|
{
|
|
|
|
|
if (sDef.isEmpty())
|
|
|
|
|
{
|
|
|
|
|
m_cameraes.iterateCall(cameraStopDevices, NULL);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
m_cameraes.valueCall(sDef, cameraStopDevices, NULL);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool CCameraPool::ICamsStartPush()
|
|
|
|
|
{
|
|
|
|
|
m_cameraes.iterateCall(camerasStartPush, NULL);
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void CCameraPool::camerasStartPush(class ICameraObject*& pCam, void* pData)
|
|
|
|
|
{
|
|
|
|
|
if (!pCam) return;
|
|
|
|
|
|
|
|
|
|
//if (pCam->m_pCamOpt->deviceType != 110) return;
|
|
|
|
|
|
|
|
|
|
pCam->IStartPush();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool CCameraPool::ICamsPausePush()
|
|
|
|
|
{
|
|
|
|
|
m_cameraes.iterateCall(camerasPausePush, NULL);
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void CCameraPool::camerasPausePush(class ICameraObject*& pCam, void* pData)
|
|
|
|
|
{
|
|
|
|
|
if (!pCam) return;
|
|
|
|
|
|
|
|
|
|
//if (pCam->m_pCamOpt->deviceType != 110) return;
|
|
|
|
|
|
|
|
|
|
pCam->IPausePush();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void CCameraPool::fixedFramesStopCamera(class ICameraObject*& pCam, void* pData)
|
|
|
|
|
{
|
|
|
|
|
if (!pCam) return;
|
|
|
|
|
if (pCam->NeedStopping())
|
|
|
|
|
{
|
|
|
|
|
pCam->IStopCamera();
|
|
|
|
|
pCam->m_pCamOpt->status = TP_CAMERA_STATUS_STOPPED;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void CCameraPool::DeviceLost(const QString& strName)
|
|
|
|
|
{
|
|
|
|
|
ICameraObject* pObj = m_cameraes.take(strName);
|
|
|
|
|
if (NULL != pObj)
|
|
|
|
|
{
|
|
|
|
|
m_libs.Delete(pObj);
|
|
|
|
|
}
|
|
|
|
|
// m_devVessel.Erase(strName, deviceErased, false);
|
|
|
|
|
// m_virVessel.Erase(strName, deviceErased, false);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
QList<QString> CCameraPool::ICameraKeys()
|
|
|
|
|
{
|
|
|
|
|
return gpGlobalCamera->CameraKeys();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
QList<QString> CCameraPool::ICameraKeysOrderByIds()
|
|
|
|
|
{
|
|
|
|
|
return gpGlobalCamera->CameraKeysOrderByIds();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool CCameraPool::ICameraOption(const QString& strSerial, TP_CAMERA_OPTION& camOpt)
|
|
|
|
|
{
|
|
|
|
|
return gpGlobalCamera->CameraOption(strSerial, camOpt);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool CCameraPool::ICameraOptionByKey(const QString& strSerial, TP_CAMERA_OPTION& camOpt)
|
|
|
|
|
{
|
|
|
|
|
return gpGlobalCamera->CameraOptionByKey(strSerial, camOpt);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool CCameraPool::ISetCameraOption(const QString& strSerial, const TP_CAMERA_OPTION& camOpt)
|
|
|
|
|
{
|
|
|
|
|
bool bRet = gpGlobalCamera->SetCameraOption(strSerial, camOpt);
|
|
|
|
|
if (bRet)
|
|
|
|
|
{
|
|
|
|
|
ICameraObject* pCam = m_cameraes.value(strSerial, NULL);
|
|
|
|
|
if (NULL != pCam)
|
|
|
|
|
{
|
|
|
|
|
pCam->ISetProperty(NULL);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
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_cameraes.constBegin();
|
|
|
|
|
while (iter != m_cameraes.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, emTpTriggerDirection nDirection /* = 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 CCameraPool::IManualTrigger(emTpTriggerDirection nDirection /* = TRIGGER_DIRECT_FOREWARD */)
|
|
|
|
|
{
|
|
|
|
|
if( DEV_TRIGGER_MODE_OUT != m_nTriggerMode )
|
|
|
|
|
{
|
|
|
|
|
ISetTriggerMode(DEV_TRIGGER_MODE_OUT);
|
|
|
|
|
}
|
|
|
|
|
tagCOMMIT_TRIGGER_PARAM prm;
|
|
|
|
|
prm.direct = nDirection;
|
|
|
|
|
prm.count = 0;
|
|
|
|
|
prm.bFromMenual = true;
|
|
|
|
|
m_cameraes.iterateCall(cameraSnaps, &prm);
|
|
|
|
|
// SnapImages(prm);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void gfunc_snap_camera_image(const QString& key, class ICameraObject*& pCam, void* pData)
|
|
|
|
|
{
|
|
|
|
|
if (!pCam)
|
|
|
|
|
return;
|
|
|
|
|
if (NULL != pCam->RelyOnCamera())
|
|
|
|
|
{
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
QStringList* pKeys = (QStringList*)pData;
|
|
|
|
|
if (!pKeys->contains(key))
|
|
|
|
|
{
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
pCam->ISnapCamera(TRIGGER_DIRECT_FOREWARD);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void CCameraPool::ISnapImage(const QStringList& camKeys)
|
|
|
|
|
{
|
|
|
|
|
m_cameraes.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_cameraes.iterateCall2(gfunc_send_soft_trigger, NULL);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
m_cameraes.iterateCall2(gfunc_send_soft_trigger, (void*)(&camKeys));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void CCameraPool::IntervalCaptureImages(tagCOMMIT_TRIGGER_PARAM& prm)
|
|
|
|
|
{
|
|
|
|
|
m_cameraes.iterateCall(cameraIntervalCaptures, &prm);
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//**difficult to understand**
|
|
|
|
|
//iterate the virtual camera's vessel and the device's vessel as the parameter
|
|
|
|
|
void CCameraPool::calRelyOn()
|
|
|
|
|
{
|
|
|
|
|
m_cameraes.iterateCall(cameraCalRelyOn, &m_cameraes);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void CCameraPool::ISetCameraProperty(const QString& camera, emTpCameraProperty property, long nValue)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void CCameraPool::ISetCameraProperty(const QString& camera, TP_CAMERA_PROPERTY& property)
|
|
|
|
|
{
|
|
|
|
|
if( camera.isNull() )
|
|
|
|
|
{
|
|
|
|
|
m_cameraes.iterateCall(cameraSetProperty, &property);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
m_cameraes.valueCall(camera, cameraSetProperty, &property);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void CCameraPool::cameraSetProperty(class ICameraObject*& pCam, void* pData)
|
|
|
|
|
{
|
|
|
|
|
if (!pCam) return;
|
|
|
|
|
pCam->ISetProperty((TP_CAMERA_PROPERTY*)pData);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//ICameraObject* CCameraPool::CreateCamera(TP_CAMERA_OPTION* pCamOpt)
|
|
|
|
|
//{
|
|
|
|
|
// if( NULL == pCamOpt )
|
|
|
|
|
// {
|
|
|
|
|
// return NULL;
|
|
|
|
|
// }
|
|
|
|
|
// ICameraObject* pObj = NULL;
|
|
|
|
|
// if( DEV_CAMERA == pCamOpt->deviceType )
|
|
|
|
|
// {
|
|
|
|
|
// //pObj = new CGigeCamera(pCamOpt, this);
|
|
|
|
|
// }
|
|
|
|
|
// else if( DEV_VIRTUAL == pCamOpt->deviceType )
|
|
|
|
|
// {
|
|
|
|
|
// //pObj = new CVirtualCamera(pCamOpt, this);
|
|
|
|
|
// }
|
|
|
|
|
// else if( DEV_BITFLOW == pCamOpt->deviceType )
|
|
|
|
|
// {
|
|
|
|
|
// //pObj = new CBitflowCameraBi(pCamOpt, this);
|
|
|
|
|
// }
|
|
|
|
|
// return pObj;
|
|
|
|
|
//}
|
|
|
|
|
|
|
|
|
|
QList<TP_CAMERA_WIN*> CCameraPool::ICameraWins()
|
|
|
|
|
{
|
|
|
|
|
return gpGlobalCamera->CameraWins();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
CZkCameraImage* CCameraPool::IPopCameraImage()
|
|
|
|
|
{
|
|
|
|
|
return m_imagesList.takeFirst(NULL);
|
|
|
|
|
/*CZkCameraImage *pCamImg = m_imagesList.takeFirst(NULL);
|
|
|
|
|
if (NULL != pCamImg)
|
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
return pCamImg;*/
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
int CCameraPool::createDeviceByOptiones()
|
|
|
|
|
{
|
|
|
|
|
QList<QString> keys = gpGlobalCamera->CameraKeys();//cameraes.keys();
|
|
|
|
|
for( int i = 0; i < keys.size(); ++i )
|
|
|
|
|
{
|
|
|
|
|
if( m_cameraes.contains(keys[i]) )
|
|
|
|
|
{
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
ICameraObject* pObject = m_libs.Create(gpGlobalCamera->CameraOption(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_cameraes.insert(keys[i], pObject);
|
|
|
|
|
}
|
|
|
|
|
return m_cameraes.size();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void CCameraPool::cameraErased(class ICameraObject*& pCam, void* pData)
|
|
|
|
|
{
|
|
|
|
|
if (!pCam) return;
|
|
|
|
|
CLibCameraes* pLibs = (CLibCameraes*)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->m_pCamOpt->status != TP_CAMERA_STATUS_OPENED &&
|
|
|
|
|
// pCam->m_pCamOpt->status != TP_CAMERA_STATUS_STOPPED)
|
|
|
|
|
//{
|
|
|
|
|
// 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)
|
|
|
|
|
{
|
|
|
|
|
if (!pCam) return;
|
|
|
|
|
TP_CAMERAPOOL_OPTION* pOpt = (TP_CAMERAPOOL_OPTION*)pData;
|
|
|
|
|
pCam->SetFixedFrames(pOpt->fixedFrames);
|
|
|
|
|
pCam->SetTriggerMode(pOpt->triggerMode);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void CCameraPool::cameraSnaps(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);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
if (pCamObj->m_pCamOpt->bIgnoreImage)
|
|
|
|
|
{
|
|
|
|
|
if (pCamObj->m_nFrameNum > 0)
|
|
|
|
|
{
|
|
|
|
|
pCamObj->m_nFrameNum--;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
//
|
|
|
|
|
pCamObj->SaveToFile();
|
|
|
|
|
|
|
|
|
|
CZkCameraImage *pImage = m_imagesMerging.value(pCamObj->m_pCamOpt->uniqueName, NULL);
|
|
|
|
|
if (NULL == pImage)
|
|
|
|
|
{
|
|
|
|
|
pImage = new CZkCameraImage();
|
|
|
|
|
}
|
|
|
|
|
int nRet = 0;
|
|
|
|
|
if (NULL != pImage)
|
|
|
|
|
{
|
|
|
|
|
//
|
|
|
|
|
if (!gpGlobalCamCallback){
|
|
|
|
|
delete pImage;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
try{
|
|
|
|
|
pImage->SetVarFromUI(gpGlobalCamCallback->IGetVariantById(pCamObj->m_pCamOpt->id));
|
|
|
|
|
|
|
|
|
|
//QVariantMap map;
|
|
|
|
|
//map.clear();
|
|
|
|
|
//map.insert("width", pCamObj->m_nImageWidth);
|
|
|
|
|
//map.insert("height", pCamObj->m_nImageHeight);
|
|
|
|
|
//map.insert("size", pCamObj->m_nImageSize);
|
|
|
|
|
//map.insert("frame", pCamObj->m_nFrameNum);
|
|
|
|
|
//qint64 nSizes = pCamObj->m_nImageHeight*pCamObj->m_nImageWidth*((pCamObj->m_nBitsPerPixel + 7) / 8);
|
|
|
|
|
////QByteArray baimgdat = QByteArray::fromRawData((const char*)(pCamObj->m_pCameraData), nSizes);
|
|
|
|
|
//QByteArray baimgdat = QByteArray((const char*)(pCamObj->m_pCameraData));
|
|
|
|
|
//map.insert("imgdata", baimgdat);
|
|
|
|
|
|
|
|
|
|
//std::string imgb64 = base64_encode(pCamObj->m_pCameraData, nSizes);
|
|
|
|
|
//int b64len = imgb64.length();
|
|
|
|
|
//QString qsimgb64(imgb64.c_str());
|
|
|
|
|
//map.insert("imgb64", qsimgb64);
|
|
|
|
|
//gpGlobalCamCallback->INewCameraImage(map);
|
|
|
|
|
}
|
|
|
|
|
catch (...){
|
|
|
|
|
qCritical() << "Critical error." << __FUNCTION__;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
//
|
|
|
|
|
int nRet = pImage->CopyCameraObject(pCamObj);
|
|
|
|
|
if (-1 == nRet)
|
|
|
|
|
{
|
|
|
|
|
delete pImage;
|
|
|
|
|
pImage = NULL;
|
|
|
|
|
}
|
|
|
|
|
else if (1 == nRet)
|
|
|
|
|
{
|
|
|
|
|
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
|
|
|
|
|
if (pCamObj->NeedStopping())
|
|
|
|
|
{
|
|
|
|
|
//IStopDevices(pCamObj->CameraOption()->uniqueName);//不是好方法,如果正在SetTriggerStart,这里可能会立刻Stop这次Start
|
|
|
|
|
//pCamObj->IStopCamera();//不是好方法,如果正在SetTriggerStart,这里可能会立刻Stop这次Start
|
|
|
|
|
m_cameraes.valueCall(pCamObj->m_pCamOpt->uniqueName, fixedFramesStopCamera, NULL);
|
|
|
|
|
}
|
|
|
|
|
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();
|
|
|
|
|
//
|
|
|
|
|
CZkCameraImage* pImage = new CZkCameraImage();
|
|
|
|
|
if (NULL == pImage)
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
if (0 == pImage->CopyCameraObject2(pCamObj))
|
|
|
|
|
{
|
|
|
|
|
delete pImage;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pImage->SetVarFromUI(gpGlobalCamCallback->IGetVariantById(pCamObj->m_pCamOpt->id));
|
|
|
|
|
m_imagesList.append(pImage);
|
|
|
|
|
//
|
|
|
|
|
if (pCamObj->NeedStopping())
|
|
|
|
|
{
|
|
|
|
|
m_cameraes.valueCall(pCamObj->m_pCamOpt->uniqueName, fixedFramesStopCamera, NULL);
|
|
|
|
|
}
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
char* CCameraPool::IGetMainPath()
|
|
|
|
|
{
|
|
|
|
|
return gpGlobalCamera->m_pGlobalData->tgdMainPath;
|
|
|
|
|
}
|
|
|
|
|
void CCameraPool::IFreeCameraImage(CZkCameraImage *pCamImg)
|
|
|
|
|
{
|
|
|
|
|
delete pCamImg;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
QMap<QString, QString> CCameraPool::IGetCamShowNames()
|
|
|
|
|
{
|
|
|
|
|
return gpGlobalCamera->GetCamShowNames();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void CCameraPool::ISetCameraEncode(INT64 code, INT64 rate)
|
|
|
|
|
{
|
|
|
|
|
m_nCameraEncode = code;
|
|
|
|
|
m_nEncoderRate = rate;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void CCameraPool::ISetVirtualImages(const QString& camera, const QStringList& szImages)
|
|
|
|
|
{
|
|
|
|
|
if (camera.isEmpty())
|
|
|
|
|
{
|
|
|
|
|
m_cameraes.iterateCall(cameraSetVirtuleImages, (void*)&szImages);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
m_cameraes.valueCall(camera, cameraSetVirtuleImages, (void*)&szImages);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
void CCameraPool::cameraSetVirtuleImages(class ICameraObject*& pCam, void* pData)
|
|
|
|
|
{
|
|
|
|
|
QStringList* pszImages = (QStringList*)pData;
|
|
|
|
|
if (pCam->m_pCamOpt->deviceType / 10 == DEV_CAM_VIRTUAL / 10)
|
|
|
|
|
{
|
|
|
|
|
pCam->ISetVirtualImages(*pszImages);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
QList<QString> CCameraPool::ICamWinKeys()
|
|
|
|
|
{
|
|
|
|
|
return gpGlobalCamera->camWinKeys();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool CCameraPool::ICamWinOptionByKey(const QString& strKey, TP_CAMERA_WIN& camwinOpt)
|
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
return gpGlobalCamera->camWinByKey(strKey, camwinOpt);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool CCameraPool::IAddCamWin(const QString& strKey, const TP_CAMERA_WIN& camwinOpt, bool bNew)
|
|
|
|
|
{
|
|
|
|
|
return gpGlobalCamera->addCamWin(strKey, camwinOpt, bNew);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool CCameraPool::IDelCamWin(const QString& strKey)
|
|
|
|
|
{
|
|
|
|
|
return gpGlobalCamera->delCamWin(strKey);
|
|
|
|
|
}
|