hubaoshun
/
Cigarette
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

较多变动主要是在于改变了编码，代码格式发生变化; 代码变动主要在syncworkthread.cpp，修复了相机断开后数据仍在变动的问题。

Browse Source
main
seiyu 1 year ago
parent c7c63a3b2e
commit 1864c6cf04
70 changed files with 12592 additions and 12582 deletions
Show Stats Download Patch File Download Diff File

50
Cigarette/ASyncQueue.h
Unescape Escape View File

@ -9,22 +9,22 @@ using namespace std;
template<class T> class ASyncQueue
{
public:
ASyncQueue(int max_size);
~ASyncQueue();
void put(const T& val);
void take(T& val);
void clear();
bool isEmpty();
bool isFull();
int count();
ASyncQueue(int max_size);
~ASyncQueue();
void put(const T& val);
void take(T& val);
void clear();
bool isEmpty();
bool isFull();
int count();
public:
string name;
string name;
private:
mutex lock;
//condition_variable_any cv_full, cv_empty;
list<T> q;
int size;
int max_size;
mutex lock;
//condition_variable_any cv_full, cv_empty;
list<T> q;
int size;
int max_size;
};
using namespace std;
@ -42,40 +42,40 @@ ASyncQueue<T>::~ASyncQueue()
template<class T>
void ASyncQueue<T>::put(const T& val)
{
lock_guard<mutex> locker(lock);
q.emplace_back(val);
lock_guard<mutex> locker(lock);
q.emplace_back(val);
}
template<class T>
void ASyncQueue<T>::take(T& val)
{
lock_guard<mutex> locker(lock);
val = q.front();
q.pop_front();
lock_guard<mutex> locker(lock);
val = q.front();
q.pop_front();
}
template<class T>
void ASyncQueue<T>::clear()
{
lock_guard<mutex> locker(lock);
q.clear();
lock_guard<mutex> locker(lock);
q.clear();
}
template<class T>
bool ASyncQueue<T>::isEmpty()
{
return q.size() == 0;
return q.size() == 0;
}
template<class T>
bool ASyncQueue<T>::isFull()
{
return q.size() == max_size;
return q.size() == max_size;
}
template<class T>
int ASyncQueue<T>::count()
{
lock_guard<mutex> locker(lock);
return q.size();
lock_guard<mutex> locker(lock);
return q.size();
}

3
Cigarette/AlarmInfo.cpp
Unescape Escape View File

@ -1,12 +1,9 @@
#include "AlarmInfo.h"
AlarmInfo::AlarmInfo()
{
}
AlarmInfo::~AlarmInfo()
{
}

13
Cigarette/AlarmInfo.h
Unescape Escape View File

@ -3,13 +3,12 @@
class AlarmInfo
{
public:
AlarmInfo();
~AlarmInfo();
AlarmInfo();
~AlarmInfo();
public:
std::string alarm_start; //报警发生时间
std::string alarm_handle; //报警处理时间
std::string alarm_msg; //报警信息
int alarm_code; //报警代码
std::string alarm_start; //报警发生时间
std::string alarm_handle; //报警处理时间
std::string alarm_msg; //报警信息
int alarm_code; //报警代码
};

200
Cigarette/CaptureThread.cpp
Unescape Escape View File

@ -2,162 +2,162 @@
#include "common.h"
#include "exportData.h"
extern bool g_debug_mode; //相机调试模式，工作模式必须停止状态才能打开
extern bool g_debug_mode; //相机调试模式，工作模式必须停止状态才能打开
extern SyncQueue<_XMLExportDataInfo>* export_XMLData_Info_queue;
//-----------------------------------------------------------------------------
CaptureThread::CaptureThread( Device* pCurrDev, bool boTerminated, FunctionInterface* pFI_ ,int Num) :
pDev_( pCurrDev ), boTerminated_( boTerminated ), requestPendingForDisplay_( INVALID_ID ), pFI_( pFI_ ),Local_Num(Num)
//-----------------------------------------------------------------------------
CaptureThread::CaptureThread(Device* pCurrDev, bool boTerminated, FunctionInterface* pFI_, int Num) :
pDev_(pCurrDev), boTerminated_(boTerminated), requestPendingForDisplay_(INVALID_ID), pFI_(pFI_), Local_Num(Num)
//-----------------------------------------------------------------------------
{
p_unit_queue = new ASyncQueue<cv::Mat>(Unit_Queue_Size);
p_unit_queue = new ASyncQueue<cv::Mat>(Unit_Queue_Size);
}
void CaptureThread::fpsTimeout(void)
{
uint64_t delta = m_cntGrabbedImages - m_cntLastGrabbedImages;
m_cntLastGrabbedImages = m_cntGrabbedImages;
QString data = QString("%1").arg(delta);
emit updateStatistics(data.left(4), Local_Num);
uint64_t delta = m_cntGrabbedImages - m_cntLastGrabbedImages;
m_cntLastGrabbedImages = m_cntGrabbedImages;
QString data = QString("%1").arg(delta);
emit updateStatistics(data.left(4), Local_Num);
}
CaptureThread::~CaptureThread()
{
delete p_unit_queue;
delete p_unit_queue;
}
//-----------------------------------------------------------------------------
void CaptureThread::process( void )
void CaptureThread::process(void)
//-----------------------------------------------------------------------------
{
try
{
//Line5回调
mvIMPACT::acquire::GenICam::EventControl pEventCtrl_(pDev_);
//pEventCtrl_.eventSelector.writeS("Line5FallingEdge");
//pEventCtrl_.eventNotification.writeS("Off");
//pEventCtrl_.eventSelector.writeS("Line5RisingEdge");
//pEventCtrl_.eventNotification.writeS("Off");
pEventCtrl_.eventSelector.writeS("Line5AnyEdge");
//Line5回调
mvIMPACT::acquire::GenICam::EventControl pEventCtrl_(pDev_);
//pEventCtrl_.eventSelector.writeS("Line5FallingEdge");
//pEventCtrl_.eventNotification.writeS("Off");
//pEventCtrl_.eventSelector.writeS("Line5RisingEdge");
//pEventCtrl_.eventNotification.writeS("Off");
pEventCtrl_.eventSelector.writeS("Line5AnyEdge");
#ifdef IMM_PROCESS
pEventCtrl_.eventNotification.writeS("Off");
pEventCtrl_.eventNotification.writeS("Off");
#else
pEventCtrl_.eventNotification.writeS("On");
pEventCtrl_.eventNotification.writeS("On");
#endif
#ifndef IMM_PROCESS
EventCallback eventCallback(&pEventCtrl_);
eventCallback.p_unit_queue_ = p_unit_queue;
EventCallback eventCallback(&pEventCtrl_);
eventCallback.p_unit_queue_ = p_unit_queue;
#ifdef SYNC_CAMERA
eventCallback.p_image_sync_arr_ = p_image_sync_arr;
eventCallback.p_image_sync_queue_ = p_image_sync_queue;
eventCallback.p_image_sync_arr_ = p_image_sync_arr;
eventCallback.p_image_sync_queue_ = p_image_sync_queue;
#else
eventCallback.p_image_queue_ = p_image_queue;
eventCallback.p_image_queue_ = p_image_queue;
#endif
eventCallback.p_result_wait_queue_ = p_result_wait_queue;
eventCallback.p_shooted_queue_ = p_shooted_queue;
eventCallback.p_double_queue_ = p_double_queue;
eventCallback.m_pMVCamera = pDev_;
eventCallback.pCaptureThread = this;
eventCallback.registerComponent(pEventCtrl_.eventLine5AnyEdge);
eventCallback.p_result_wait_queue_ = p_result_wait_queue;
eventCallback.p_shooted_queue_ = p_shooted_queue;
eventCallback.p_double_queue_ = p_double_queue;
eventCallback.m_pMVCamera = pDev_;
eventCallback.pCaptureThread = this;
eventCallback.registerComponent(pEventCtrl_.eventLine5AnyEdge);
#endif
m_threadFunc.m_pMVCamera = pDev_;
m_threadFunc.p_result_queue_ = p_result_queue;
m_threadFunc.p_double_queue_ = p_double_queue;
m_threadFunc.m_pMVCamera = pDev_;
m_threadFunc.p_result_queue_ = p_result_queue;
m_threadFunc.p_double_queue_ = p_double_queue;
//相机掉线回调
CIwtCameraLostCallbackMV cam_lost_cb;
cam_lost_cb.channel_ = Local_Num;
if (cam_lost_cb.registerComponent(pDev_->state) != true)
{
std::cout << "ERROR: Unable to register the camera's lost CallBack function!\n";
}
//图像采集循环
//相机掉线回调
CIwtCameraLostCallbackMV cam_lost_cb;
cam_lost_cb.channel_ = Local_Num;
if (cam_lost_cb.registerComponent(pDev_->state) != true)
{
std::cout << "ERROR: Unable to register the camera's lost CallBack function!\n";
}
//图像采集循环
TDMR_ERROR result = DMR_NO_ERROR;
while( ( result = static_cast< TDMR_ERROR >( pFI_->imageRequestSingle() ) ) == DMR_NO_ERROR ) {};
if( result != DEV_NO_FREE_REQUEST_AVAILABLE )
while ((result = static_cast<TDMR_ERROR>(pFI_->imageRequestSingle())) == DMR_NO_ERROR) {};
if (result != DEV_NO_FREE_REQUEST_AVAILABLE)
{
qDebug() << "'FunctionInterface.imageRequestSingle' returned with an unexpected result: " << QString::fromStdString( mvIMPACT::acquire::ImpactAcquireException::getErrorCodeAsString( result ) );
qDebug() << "'FunctionInterface.imageRequestSingle' returned with an unexpected result: " << QString::fromStdString(mvIMPACT::acquire::ImpactAcquireException::getErrorCodeAsString(result));
}
manuallyStartAcquisitionIfNeeded( pDev_, *pFI_ );
manuallyStartAcquisitionIfNeeded(pDev_, *pFI_);
int cnt = 0;
// run thread loop
mvIMPACT::acquire::Statistics statistics( pDev_ );
mvIMPACT::acquire::Statistics statistics(pDev_);
mvIMPACT::acquire::Request* pRequest = 0;
mvIMPACT::acquire::Request* pPreviousRequest = nullptr;
mvIMPACT::acquire::Request* pPreviousRequest = nullptr;
const unsigned int timeout_ms = 100;
Ready = true;
while( !boTerminated_ )
Ready = true;
while (!boTerminated_)
{
const int requestNr = pFI_->imageRequestWaitFor( timeout_ms );
pRequest = pFI_->isRequestNrValid( requestNr ) ? pFI_->getRequest( requestNr ) : 0;
if( pRequest )
const int requestNr = pFI_->imageRequestWaitFor(timeout_ms);
pRequest = pFI_->isRequestNrValid(requestNr) ? pFI_->getRequest(requestNr) : 0;
if (pRequest)
{
if (pRequest->isOK())
{
// do something with the image
int openCVDataType = CV_8UC1;
if ((pRequest->imagePixelFormat.read() == ibpfBGR888Packed) || (pRequest->imagePixelFormat.read() == ibpfRGB888Packed))
openCVDataType = CV_8UC3;
cv::Mat openCVImage(cv::Size(pRequest->imageWidth.read(), pRequest->imageHeight.read()), openCVDataType, pRequest->imageData.read(), pRequest->imageLinePitch.read());
cv::Mat image_clone = openCVImage.clone();
if (!g_debug_mode)
{
if (pRequest->isOK())
{
// do something with the image
int openCVDataType = CV_8UC1;
if ((pRequest->imagePixelFormat.read() == ibpfBGR888Packed) || (pRequest->imagePixelFormat.read() == ibpfRGB888Packed))
openCVDataType = CV_8UC3;
cv::Mat openCVImage(cv::Size(pRequest->imageWidth.read(), pRequest->imageHeight.read()), openCVDataType, pRequest->imageData.read(), pRequest->imageLinePitch.read());
cv::Mat image_clone = openCVImage.clone();
if (!g_debug_mode)
{
#ifdef IMM_PROCESS
p_image_queue->put(std::make_pair(1,image_clone)); //放入临时队列
p_image_queue->put(std::make_pair(1, image_clone)); //放入临时队列
#else
p_unit_queue->put(image_clone); //放入临时队列
p_unit_queue->put(image_clone); //放入临时队列
#endif
}
else
{
p_debug_queue->put(image_clone); //放入调试队列
}
cnt++;
// display some statistics
if (cnt % 10 == 0)
{
QString data = QString::fromStdString(statistics.framesPerSecond.readS());
emit updateStatistics(data.left(4),Local_Num);
}
}
else
{
// some error: pRequest->requestResult.readS() will return a string representation
}
// this image has been used thus the buffer is no longer needed...
if (pPreviousRequest)
{
// this image has been displayed thus the buffer is no longer needed...
pPreviousRequest->unlock();
}
pPreviousRequest = pRequest;
// send a new image request into the capture queue
pFI_->imageRequestSingle();
}
else
{
p_debug_queue->put(image_clone); //放入调试队列
}
cnt++;
// display some statistics
if (cnt % 10 == 0)
{
QString data = QString::fromStdString(statistics.framesPerSecond.readS());
emit updateStatistics(data.left(4), Local_Num);
}
}
else
{
// some error: pRequest->requestResult.readS() will return a string representation
}
// this image has been used thus the buffer is no longer needed...
if (pPreviousRequest)
{
// this image has been displayed thus the buffer is no longer needed...
pPreviousRequest->unlock();
}
pPreviousRequest = pRequest;
// send a new image request into the capture queue
pFI_->imageRequestSingle();
}
#if defined (IMM_FEED_BACK) || defined (CAP_FEED_BACK)
m_threadFunc.SendFeedBack(ImageCap);
m_threadFunc.SendFeedBack(ImageCap);
#endif
}
manuallyStopAcquisitionIfNeeded( pDev_, *pFI_ );
if( pRequest )
}
manuallyStopAcquisitionIfNeeded(pDev_, *pFI_);
if (pRequest)
{
pRequest->unlock();
}
pFI_->imageRequestReset( 0, 0 );
pFI_->imageRequestReset(0, 0);
}
catch( const ImpactAcquireException& e )
catch (const ImpactAcquireException& e)
{
emit error( QString::fromStdString( e.getErrorCodeAsString() ) );
emit error(QString::fromStdString(e.getErrorCodeAsString()));
}
}
//-----------------------------------------------------------------------------
int CaptureThread::getPendingRequestNr( void )
int CaptureThread::getPendingRequestNr(void)
//-----------------------------------------------------------------------------
{
QMutexLocker lockedScope( &lock_ );
QMutexLocker lockedScope(&lock_);
int result = requestPendingForDisplay_;
// Reset the ID of the request to tell the capture loop that this request has already been
// picked up and someone else will take care of it from now on.

328
Cigarette/CaptureThread.h
Unescape Escape View File

@ -25,20 +25,20 @@ class CaptureThread_Func
{
public:
Device* m_pMVCamera;
ASyncQueue<bool> *p_result_queue_;
ASyncQueue<bool> *p_double_queue_;
ASyncQueue<bool>* p_result_queue_;
ASyncQueue<bool>* p_double_queue_;
void SendFeedBack(int OpID)
{
bool send_ng=false;
bool send_ok=false;
if(OpID == EdgeEvent)
bool send_ng = false;
bool send_ok = false;
if (OpID == EdgeEvent)
{
#if defined DOUBLE_FEED_BACK
if(p_double_queue_->count() > 0)
if (p_double_queue_->count() > 0)
{
bool temp;
p_double_queue_->take(temp);
send_ng=true;
send_ng = true;
}
#endif
}
@ -47,88 +47,88 @@ public:
bool result;
p_result_queue_->take(result);
if (!result)
{
{
#if defined DOUBLE_FEED_BACK
p_double_queue_->put(true);
p_double_queue_->put(true);
#endif
send_ng=true;
send_ng = true;
}
else
{
send_ok = true;
}
else
{
send_ok=true;
}
}
try
{
mvIMPACT::acquire::GenICam::DigitalIOControl mvDIOC(m_pMVCamera);
if(send_ng){
mvDIOC.userOutputSelector.writeS("UserOutput0");
mvIMPACT::acquire::TBoolean tb = mvDIOC.userOutputValue.read();
if (tb == bFalse)
mvDIOC.userOutputValue.write(bTrue);
else
mvDIOC.userOutputValue.write(bFalse);
}
else if (send_ok)
{
mvDIOC.userOutputSelector.writeS("UserOutput1");
mvIMPACT::acquire::TBoolean tb = mvDIOC.userOutputValue.read();
if (tb == bFalse)
mvDIOC.userOutputValue.write(bTrue);
else
mvDIOC.userOutputValue.write(bFalse);
}
}
catch (const ImpactAcquireException& e)
{
std::cout<< "(error code: " << e.getErrorCodeAsString() << "). Press [ENTER] to end the application..." << std::endl;
}
try
{
mvIMPACT::acquire::GenICam::DigitalIOControl mvDIOC(m_pMVCamera);
if (send_ng) {
mvDIOC.userOutputSelector.writeS("UserOutput0");
mvIMPACT::acquire::TBoolean tb = mvDIOC.userOutputValue.read();
if (tb == bFalse)
mvDIOC.userOutputValue.write(bTrue);
else
mvDIOC.userOutputValue.write(bFalse);
}
else if (send_ok)
{
mvDIOC.userOutputSelector.writeS("UserOutput1");
mvIMPACT::acquire::TBoolean tb = mvDIOC.userOutputValue.read();
if (tb == bFalse)
mvDIOC.userOutputValue.write(bTrue);
else
mvDIOC.userOutputValue.write(bFalse);
}
}
catch (const ImpactAcquireException& e)
{
std::cout << "(error code: " << e.getErrorCodeAsString() << "). Press [ENTER] to end the application..." << std::endl;
}
}
};
class CaptureThread : public QObject
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
{
Q_OBJECT
public:
explicit CaptureThread( Device* pCurrDev, bool boTerminated, FunctionInterface* pFi ,int Num);
CaptureThread::~CaptureThread(void);
void terminate( void )
explicit CaptureThread(Device* pCurrDev, bool boTerminated, FunctionInterface* pFi, int Num);
CaptureThread::~CaptureThread(void);
void terminate(void)
{
boTerminated_ = true;
}
int getPendingRequestNr();
signals:
void error( QString err );
void finished( void );
void requestReady( void );
void updateStatistics( const QString& data ,int Num);
void error(QString err);
void finished(void);
void requestReady(void);
void updateStatistics(const QString& data, int Num);
private slots:
void process( void );
void fpsTimeout(void);
void process(void);
void fpsTimeout(void);
public:
int Local_Num;
QTimer* m_Timer;
uint64_t m_cntGrabbedImages = 0;
uint64_t m_cntLastGrabbedImages = 0;
int Local_Num;
QTimer* m_Timer;
uint64_t m_cntGrabbedImages = 0;
uint64_t m_cntLastGrabbedImages = 0;
#ifdef SYNC_CAMERA
ImageSyncArr *p_image_sync_arr;
SyncQueue<std::vector<std::pair<int, cv::Mat>>>* p_image_sync_queue;
ImageSyncArr* p_image_sync_arr;
SyncQueue<std::vector<std::pair<int, cv::Mat>>>* p_image_sync_queue;
#else
SyncQueue<std::pair<int, cv::Mat> > *p_image_queue;
SyncQueue<std::pair<int, cv::Mat> >* p_image_queue;
#endif
ASyncQueue<cv::Mat> *p_unit_queue;
ASyncQueue<bool> *p_result_queue;
ASyncQueue<bool> *p_result_wait_queue;
ASyncQueue<bool> *p_double_queue;
ASyncQueue<bool> *p_shooted_queue;
SyncQueue<cv::Mat> *p_debug_queue;
ASyncQueue<cv::Mat>* p_unit_queue;
ASyncQueue<bool>* p_result_queue;
ASyncQueue<bool>* p_result_wait_queue;
ASyncQueue<bool>* p_double_queue;
ASyncQueue<bool>* p_shooted_queue;
SyncQueue<cv::Mat>* p_debug_queue;
bool Ready = false;
CaptureThread_Func m_threadFunc;
CaptureThread_Func m_threadFunc;
private:
Device* pDev_;
volatile bool boTerminated_;
@ -143,125 +143,125 @@ private:
class EventCallback : public mvIMPACT::acquire::ComponentCallback
{
public:
ASyncQueue<cv::Mat> *p_unit_queue_;
ASyncQueue<cv::Mat>* p_unit_queue_;
#ifdef SYNC_CAMERA
ImageSyncArr *p_image_sync_arr_;
SyncQueue<std::vector<std::pair<int, cv::Mat>>> *p_image_sync_queue_;
ImageSyncArr* p_image_sync_arr_;
SyncQueue<std::vector<std::pair<int, cv::Mat>>>* p_image_sync_queue_;
#else
SyncQueue<std::pair<int, cv::Mat> > *p_image_queue_;
SyncQueue<std::pair<int, cv::Mat> >* p_image_queue_;
#endif
ASyncQueue<bool> *p_result_wait_queue_;
ASyncQueue<bool> *p_shooted_queue_;
ASyncQueue<bool> *p_double_queue_;
explicit EventCallback(void* pUserData = 0) : ComponentCallback(pUserData) {}
Device* m_pMVCamera;
CaptureThread* pCaptureThread = NULL;
int count = 0;
ASyncQueue<bool>* p_result_wait_queue_;
ASyncQueue<bool>* p_shooted_queue_;
ASyncQueue<bool>* p_double_queue_;
explicit EventCallback(void* pUserData = 0) : ComponentCallback(pUserData) {}
Device* m_pMVCamera;
CaptureThread* pCaptureThread = NULL;
int count = 0;
virtual void execute(Component& c, void* pUserData)
{
try
{
// re-generating the object/data previously attached to the callback object. This could now be used to call a certain member function e.g. to update a class instance about this event!
mvIMPACT::acquire::GenICam::EventControl* ec = reinterpret_cast<mvIMPACT::acquire::GenICam::EventControl*>(pUserData);
// Execute the followings if the component is a property.
if (c.isProp())
{
mvIMPACT::acquire::GenICam::DigitalIOControl mvDIOC(m_pMVCamera);
mvDIOC.lineSelector.writeS("Line5");
if (mvDIOC.lineStatus.read())
{
virtual void execute(Component& c, void* pUserData)
{
try
{
// re-generating the object/data previously attached to the callback object. This could now be used to call a certain member function e.g. to update a class instance about this event!
mvIMPACT::acquire::GenICam::EventControl* ec = reinterpret_cast<mvIMPACT::acquire::GenICam::EventControl*>(pUserData);
// Execute the followings if the component is a property.
if (c.isProp())
{
mvIMPACT::acquire::GenICam::DigitalIOControl mvDIOC(m_pMVCamera);
mvDIOC.lineSelector.writeS("Line5");
if (mvDIOC.lineStatus.read())
{
#ifdef IMM_FEED_BACK
if (p_shooted_queue_->count() > 0)
{
bool temp;
p_shooted_queue_->take(temp);
}
if (p_shooted_queue_->count() > 0)
{
bool temp;
p_shooted_queue_->take(temp);
}
#elif defined ONE_TIME_SHIFT
if (
p_shooted_queue_->count() > 0
if (
p_shooted_queue_->count() > 0
#if defined DOUBLE_FEED_BACK
|| p_double_queue_->count() >0
|| p_double_queue_->count() > 0
#endif
)
{
if (p_shooted_queue_->count() > 0){
bool temp;
p_shooted_queue_->take(temp);
}
pCaptureThread->m_threadFunc.SendFeedBack(EdgeEvent);
}
)
{
if (p_shooted_queue_->count() > 0) {
bool temp;
p_shooted_queue_->take(temp);
}
pCaptureThread->m_threadFunc.SendFeedBack(EdgeEvent);
}
#else
if (p_result_wait_queue_->count() > 0)
{
bool temp;
p_result_wait_queue_->take(temp);
pCaptureThread->m_threadFunc.SendFeedBack(EdgeEvent);
}
if (p_shooted_queue_->count() > 0)
{
bool temp;
p_shooted_queue_->take(temp);
p_result_wait_queue_->put(true);
}
if (p_result_wait_queue_->count() > 0)
{
bool temp;
p_result_wait_queue_->take(temp);
pCaptureThread->m_threadFunc.SendFeedBack(EdgeEvent);
}
if (p_shooted_queue_->count() > 0)
{
bool temp;
p_shooted_queue_->take(temp);
p_result_wait_queue_->put(true);
}
#endif
}
else
{
int unit_count = p_unit_queue_->count();
if (unit_count > 0)
{
cv::Mat long_image;
for (int i = 0; i < unit_count; i++)
{
cv::Mat image;
p_unit_queue_->take(image);
if (0 == i)
{
long_image = cv::Mat::zeros(image.rows * unit_count, image.cols, image.type());
}
cv::Rect r(0, i * image.rows, image.cols, image.rows);
cv::Mat roi = long_image(r);
image.copyTo(roi);
}
}
else
{
int unit_count = p_unit_queue_->count();
if (unit_count > 0)
{
cv::Mat long_image;
for (int i = 0; i < unit_count; i++)
{
cv::Mat image;
p_unit_queue_->take(image);
if (0 == i)
{
long_image = cv::Mat::zeros(image.rows * unit_count, image.cols, image.type());
}
cv::Rect r(0, i * image.rows, image.cols, image.rows);
cv::Mat roi = long_image(r);
image.copyTo(roi);
}
#ifdef SYNC_CAMERA
{
std::lock_guard<std::mutex> locker(p_image_sync_arr_->lock);
p_image_sync_arr_->image_sync_arr.at(pCaptureThread->Local_Num) = std::make_pair(unit_count, long_image);
p_image_sync_arr_->collect_cnt++;
if (p_image_sync_arr_->collect_cnt == work_camera_nums)
{
p_image_sync_queue_->put(p_image_sync_arr_->image_sync_arr);
p_image_sync_arr_->collect_cnt = 0;
}
}
{
std::lock_guard<std::mutex> locker(p_image_sync_arr_->lock);
p_image_sync_arr_->image_sync_arr.at(pCaptureThread->Local_Num) = std::make_pair(unit_count, long_image);
p_image_sync_arr_->collect_cnt++;
if (p_image_sync_arr_->collect_cnt == work_camera_nums)
{
p_image_sync_queue_->put(p_image_sync_arr_->image_sync_arr);
p_image_sync_arr_->collect_cnt = 0;
}
}
#else
p_image_queue_->put(std::make_pair(unit_count, long_image));
p_image_queue_->put(std::make_pair(unit_count, long_image));
#endif
p_shooted_queue_->put(true);
}
p_unit_queue_->clear();
}
}
}
catch (const ImpactAcquireException& e)
{
qDebug() << "Error";
}
}
p_shooted_queue_->put(true);
}
p_unit_queue_->clear();
}
}
}
catch (const ImpactAcquireException& e)
{
qDebug() << "Error";
}
}
};
class CIwtCameraLostCallbackMV : public mvIMPACT::acquire::ComponentCallback
{
public:
CIwtCameraLostCallbackMV() : ComponentCallback() {}
int channel_;
virtual void execute(mvIMPACT::acquire::Component& c, void* pDummy)
{
PropertyIDeviceState p(c);
std::cout << p.name() << " = " << p.readS() << endl;
SingleCamInfo[channel_].OffLine = true;
}
CIwtCameraLostCallbackMV() : ComponentCallback() {}
int channel_;
virtual void execute(mvIMPACT::acquire::Component& c, void* pDummy)
{
PropertyIDeviceState p(c);
std::cout << p.name() << " = " << p.readS() << endl;
SingleCamInfo[channel_].OffLine = true;
}
};
//-----------------------------------------------------------------------------

280
Cigarette/CaptureThreadBasler.cpp
Unescape Escape View File

@ -5,203 +5,203 @@
#include <qdebug.h>
#include <exportData.h>
extern SyncQueue<_XMLExportDataInfo>* export_XMLData_Info_queue;
extern PLCDevice * m_PLCDevice;
//-----------------------------------------------------------------------------
CaptureThreadBasler::CaptureThreadBasler(Pylon::CBaslerUniversalInstantCamera* pCurrDev, bool boTerminated,int Num,int shoot) :
pDev_( pCurrDev ), boTerminated_( boTerminated ),Local_Num(Num)
extern PLCDevice* m_PLCDevice;
//-----------------------------------------------------------------------------
CaptureThreadBasler::CaptureThreadBasler(Pylon::CBaslerUniversalInstantCamera* pCurrDev, bool boTerminated, int Num, int shoot) :
pDev_(pCurrDev), boTerminated_(boTerminated), Local_Num(Num)
//-----------------------------------------------------------------------------
{
p_unit_queue = new ASyncQueue<cv::Mat>(Unit_Queue_Size);
Shoot_Num = shoot;
p_unit_queue = new ASyncQueue<cv::Mat>(Unit_Queue_Size);
Shoot_Num = shoot;
}
CaptureThreadBasler::~CaptureThreadBasler()
{
delete p_unit_queue;
delete p_unit_queue;
}
//-----------------------------------------------------------------------------
void CaptureThreadBasler::process(void)
//-----------------------------------------------------------------------------
{
bool last_high = false;
bool last_result = false;
bool last_high = false;
bool last_result = false;
CSampleConfigurationEventHandler* CfgEvent = NULL;
CfgEvent = new CSampleConfigurationEventHandler;
CfgEvent->channel_ = Local_Num;
pDev_->RegisterConfiguration(CfgEvent, Pylon::RegistrationMode_Append, Pylon::Cleanup_None);
CSampleConfigurationEventHandler* CfgEvent = NULL;
CfgEvent = new CSampleConfigurationEventHandler;
CfgEvent->channel_ = Local_Num;
pDev_->RegisterConfiguration(CfgEvent, Pylon::RegistrationMode_Append, Pylon::Cleanup_None);
CSampleImageEventHandler ImageEvent;
CSampleImageEventHandler ImageEvent;
#ifdef SYNC_CAMERA
ImageEvent.p_image_sync_arr_ = p_image_sync_arr;
ImageEvent.p_image_sync_queue_ = p_image_sync_queue;
ImageEvent.p_image_sync_arr_ = p_image_sync_arr;
ImageEvent.p_image_sync_queue_ = p_image_sync_queue;
#else
ImageEvent.p_image_queue_ = p_image_queue;
ImageEvent.p_image_queue_ = p_image_queue;
#endif
ImageEvent.p_unit_queue_ = p_unit_queue;
ImageEvent.p_shooted_queue_ = p_shooted_queue;
ImageEvent.p_debug_queue_ = p_debug_queue;
ImageEvent.m_cntGrabbedImages_ = &m_cntGrabbedImages;
ImageEvent.Shoot_Num_ = Shoot_Num;
ImageEvent.pDev__ = pDev_;
pDev_->RegisterImageEventHandler(&ImageEvent, Pylon::RegistrationMode_Append, Pylon::Cleanup_None);
ImageEvent.p_unit_queue_ = p_unit_queue;
ImageEvent.p_shooted_queue_ = p_shooted_queue;
ImageEvent.p_debug_queue_ = p_debug_queue;
ImageEvent.m_cntGrabbedImages_ = &m_cntGrabbedImages;
ImageEvent.Shoot_Num_ = Shoot_Num;
ImageEvent.pDev__ = pDev_;
pDev_->RegisterImageEventHandler(&ImageEvent, Pylon::RegistrationMode_Append, Pylon::Cleanup_None);
CSampleCameraEventHandler BurstEvent;
CSampleCameraEventHandler BurstEvent;
#ifdef SYNC_CAMERA
BurstEvent.p_image_sync_arr_ = p_image_sync_arr;
BurstEvent.p_image_sync_queue_ = p_image_sync_queue;
BurstEvent.p_image_sync_arr_ = p_image_sync_arr;
BurstEvent.p_image_sync_queue_ = p_image_sync_queue;
#else
BurstEvent.p_image_queue_ = p_image_queue;
BurstEvent.p_image_queue_ = p_image_queue;
#endif
BurstEvent.p_unit_queue_ = p_unit_queue;
BurstEvent.p_result_wait_queue_ = p_result_wait_queue;
BurstEvent.p_result_queue_ = p_result_queue;
BurstEvent.p_shooted_queue_ = p_shooted_queue;
BurstEvent.p_double_queue_ = p_double_queue;
BurstEvent.pDev__ = pDev_;
BurstEvent.pCaptureThreadBasler = this;
BurstEvent.p_unit_queue_ = p_unit_queue;
BurstEvent.p_result_wait_queue_ = p_result_wait_queue;
BurstEvent.p_result_queue_ = p_result_queue;
BurstEvent.p_shooted_queue_ = p_shooted_queue;
BurstEvent.p_double_queue_ = p_double_queue;
BurstEvent.pDev__ = pDev_;
BurstEvent.pCaptureThreadBasler = this;
try
{
m_threadFunc.pDev__ = pDev_;
m_threadFunc.p_result_queue_ = p_result_queue;
m_threadFunc.p_double_queue_ = p_double_queue;
m_threadFunc.m_IOTimer_ = m_IOTimer;
try
{
m_threadFunc.pDev__ = pDev_;
m_threadFunc.p_result_queue_ = p_result_queue;
m_threadFunc.p_double_queue_ = p_double_queue;
m_threadFunc.m_IOTimer_ = m_IOTimer;
#ifndef USB_BASLER_NEW_FW
if (pDev_->TriggerSelector.TrySetValue(Basler_UniversalCameraParams::TriggerSelector_FrameBurstStart))
{
pDev_->TriggerMode.SetValue(Basler_UniversalCameraParams::TriggerMode_On);
pDev_->TriggerSource.SetValue(Basler_UniversalCameraParams::TriggerSource_Line1);
pDev_->TriggerActivation.SetValue(Basler_UniversalCameraParams::TriggerActivation_RisingEdge);
pDev_->AcquisitionBurstFrameCount.SetValue(Shoot_Num);
if (pDev_->EventSelector.TrySetValue(Basler_UniversalCameraParams::EventSelector_FrameBurstStart))
{
if (!pDev_->EventNotification.TrySetValue(Basler_UniversalCameraParams::EventNotification_On))
{
pDev_->EventNotification.SetValue(Basler_UniversalCameraParams::EventNotification_GenICamEvent);
}
if (pDev_->TriggerSelector.TrySetValue(Basler_UniversalCameraParams::TriggerSelector_FrameBurstStart))
{
pDev_->TriggerMode.SetValue(Basler_UniversalCameraParams::TriggerMode_On);
pDev_->TriggerSource.SetValue(Basler_UniversalCameraParams::TriggerSource_Line1);
pDev_->TriggerActivation.SetValue(Basler_UniversalCameraParams::TriggerActivation_RisingEdge);
pDev_->AcquisitionBurstFrameCount.SetValue(Shoot_Num);
if (pDev_->EventSelector.TrySetValue(Basler_UniversalCameraParams::EventSelector_FrameBurstStart))
{
if (!pDev_->EventNotification.TrySetValue(Basler_UniversalCameraParams::EventNotification_On))
{
pDev_->EventNotification.SetValue(Basler_UniversalCameraParams::EventNotification_GenICamEvent);
}
m_IOTimer = new QTimer();
connect(m_IOTimer, SIGNAL(timeout()), this, SLOT(ioTimeout()));
m_IOTimer->setSingleShot(true);
BurstEvent.ioTimer = m_IOTimer;
pDev_->RegisterCameraEventHandler(&BurstEvent, "EventFrameBurstStartData", eMyFrameBurstStartEvent, Pylon::RegistrationMode_Append, Pylon::Cleanup_None);
}
m_IOTimer = new QTimer();
connect(m_IOTimer, SIGNAL(timeout()), this, SLOT(ioTimeout()));
m_IOTimer->setSingleShot(true);
BurstEvent.ioTimer = m_IOTimer;
pDev_->RegisterCameraEventHandler(&BurstEvent, "EventFrameBurstStartData", eMyFrameBurstStartEvent, Pylon::RegistrationMode_Append, Pylon::Cleanup_None);
}
if(pDev_->EventSelector.TrySetValue("Line1RisingEdge"))
{
pDev_->EventNotification.SetValue(Basler_UniversalCameraParams::EventNotification_Off);
}
if(pDev_->EventSelector.TrySetValue("Line1FallingEdge"))
{
pDev_->EventNotification.SetValue(Basler_UniversalCameraParams::EventNotification_Off);
}
}
if (pDev_->EventSelector.TrySetValue("Line1RisingEdge"))
{
pDev_->EventNotification.SetValue(Basler_UniversalCameraParams::EventNotification_Off);
}
if (pDev_->EventSelector.TrySetValue("Line1FallingEdge"))
{
pDev_->EventNotification.SetValue(Basler_UniversalCameraParams::EventNotification_Off);
}
}
#else
/*Set here*/
if (pDev_->TriggerSelector.TrySetValue(Basler_UniversalCameraParams::TriggerSelector_FrameBurstStart))
{
pDev_->TriggerMode.SetValue(Basler_UniversalCameraParams::TriggerMode_Off);
if(pDev_->EventSelector.TrySetValue(Basler_UniversalCameraParams::EventSelector_FrameBurstStart))
{
pDev_->EventNotification.SetValue(Basler_UniversalCameraParams::EventNotification_Off);
}
}
/*Set here*/
if (pDev_->TriggerSelector.TrySetValue(Basler_UniversalCameraParams::TriggerSelector_FrameBurstStart))
{
pDev_->TriggerMode.SetValue(Basler_UniversalCameraParams::TriggerMode_Off);
if (pDev_->EventSelector.TrySetValue(Basler_UniversalCameraParams::EventSelector_FrameBurstStart))
{
pDev_->EventNotification.SetValue(Basler_UniversalCameraParams::EventNotification_Off);
}
}
pDev_->RegisterCameraEventHandler(&BurstEvent, "EventLine1RisingEdgeData", Line1RisingEdge, Pylon::RegistrationMode_Append, Pylon::Cleanup_None);
pDev_->EventSelector.SetValue("Line1RisingEdge");
pDev_->RegisterCameraEventHandler(&BurstEvent, "EventLine1RisingEdgeData", Line1RisingEdge, Pylon::RegistrationMode_Append, Pylon::Cleanup_None);
pDev_->EventSelector.SetValue("Line1RisingEdge");
#ifdef IMM_PROCESS
pDev_->EventNotification.SetValue(Basler_UniversalCameraParams::EventNotification_Off);
pDev_->EventNotification.SetValue(Basler_UniversalCameraParams::EventNotification_Off);
#else
pDev_->EventNotification.SetValue(Basler_UniversalCameraParams::EventNotification_On);
pDev_->EventNotification.SetValue(Basler_UniversalCameraParams::EventNotification_On);
#endif
pDev_->RegisterCameraEventHandler(&BurstEvent, "EventLine1FallingEdgeData", Line1FallingEdge, Pylon::RegistrationMode_Append, Pylon::Cleanup_None);
pDev_->EventSelector.SetValue("Line1FallingEdge");
pDev_->RegisterCameraEventHandler(&BurstEvent, "EventLine1FallingEdgeData", Line1FallingEdge, Pylon::RegistrationMode_Append, Pylon::Cleanup_None);
pDev_->EventSelector.SetValue("Line1FallingEdge");
#ifdef IMM_PROCESS
pDev_->EventNotification.SetValue(Basler_UniversalCameraParams::EventNotification_Off);
pDev_->EventNotification.SetValue(Basler_UniversalCameraParams::EventNotification_Off);
#else
pDev_->EventNotification.SetValue(Basler_UniversalCameraParams::EventNotification_On);
pDev_->EventNotification.SetValue(Basler_UniversalCameraParams::EventNotification_On);
#endif
#endif
const unsigned int timeout_ms = 100;
// This smart pointer will receive the grab result data.
Pylon::CGrabResultPtr ptrGrabResult;
const unsigned int timeout_ms = 100;
// This smart pointer will receive the grab result data.
Pylon::CGrabResultPtr ptrGrabResult;
pDev_->StartGrabbing();
pDev_->StartGrabbing();
m_Timer = new QTimer();
connect(m_Timer, SIGNAL(timeout()), this, SLOT(fpsTimeout()));
m_Timer->start(1000);
Ready = true;
while (!boTerminated_)
{
// Retrieve grab results and notify the camera event and image event handlers.
pDev_->RetrieveResult(timeout_ms, ptrGrabResult, Pylon::TimeoutHandling_Return);
m_Timer = new QTimer();
connect(m_Timer, SIGNAL(timeout()), this, SLOT(fpsTimeout()));
m_Timer->start(1000);
Ready = true;
while (!boTerminated_)
{
// Retrieve grab results and notify the camera event and image event handlers.
pDev_->RetrieveResult(timeout_ms, ptrGrabResult, Pylon::TimeoutHandling_Return);
#if defined (IMM_FEED_BACK) || defined (CAP_FEED_BACK)
m_threadFunc.SendFeedBack(ImageCap);
m_threadFunc.SendFeedBack(ImageCap);
#endif
QCoreApplication::processEvents();//Make sure the timer is triggered
}
QCoreApplication::processEvents();//Make sure the timer is triggered
}
#ifndef USB_BASLER_NEW_FW
// Disable sending Event Overrun events.
if (pDev_->EventSelector.TrySetValue(Basler_UniversalCameraParams::EventSelector_FrameBurstStart))
{
pDev_->EventNotification.TrySetValue(Basler_UniversalCameraParams::EventNotification_Off);
}
if (m_IOTimer) delete m_IOTimer;
// Disable sending Event Overrun events.
if (pDev_->EventSelector.TrySetValue(Basler_UniversalCameraParams::EventSelector_FrameBurstStart))
{
pDev_->EventNotification.TrySetValue(Basler_UniversalCameraParams::EventNotification_Off);
}
if (m_IOTimer) delete m_IOTimer;
#endif
if (m_Timer) delete m_Timer;
pDev_->StopGrabbing();
pDev_->Close();
pDev_->DeregisterConfiguration(CfgEvent);
pDev_->DeregisterImageEventHandler(&ImageEvent);
if (m_Timer) delete m_Timer;
pDev_->StopGrabbing();
pDev_->Close();
pDev_->DeregisterConfiguration(CfgEvent);
pDev_->DeregisterImageEventHandler(&ImageEvent);
#ifndef USB_BASLER_NEW_FW
pDev_->DeregisterCameraEventHandler(&BurstEvent, "EventFrameBurstStartData");
pDev_->DeregisterCameraEventHandler(&BurstEvent, "EventFrameBurstStartData");
#else
pDev_->DeregisterCameraEventHandler(&BurstEvent, "EventLine1RisingEdgeData");
pDev_->DeregisterCameraEventHandler(&BurstEvent, "EventLine1FallingEdgeData");
pDev_->DeregisterCameraEventHandler(&BurstEvent, "EventLine1RisingEdgeData");
pDev_->DeregisterCameraEventHandler(&BurstEvent, "EventLine1FallingEdgeData");
#endif
}
catch(const Pylon::GenericException& e)
catch (const Pylon::GenericException& e)
{
emit error( QString::fromStdString( e.GetDescription()) );
std::cout << e.GetSourceLine()<<e.GetDescription() << std::endl;
if (pDev_->IsCameraDeviceRemoved())
{
cout << "The camera has been removed from the computer." << endl;
}
else
{
pDev_->StopGrabbing();
pDev_->GrabCameraEvents = false;
pDev_->Close();
pDev_->DeregisterConfiguration(CfgEvent);
pDev_->DeregisterImageEventHandler(&ImageEvent);
emit error(QString::fromStdString(e.GetDescription()));
std::cout << e.GetSourceLine() << e.GetDescription() << std::endl;
if (pDev_->IsCameraDeviceRemoved())
{
cout << "The camera has been removed from the computer." << endl;
}
else
{
pDev_->StopGrabbing();
pDev_->GrabCameraEvents = false;
pDev_->Close();
pDev_->DeregisterConfiguration(CfgEvent);
pDev_->DeregisterImageEventHandler(&ImageEvent);
#ifndef USB_BASLER_NEW_FW
pDev_->DeregisterCameraEventHandler(&BurstEvent, "EventFrameBurstStartData");
pDev_->DeregisterCameraEventHandler(&BurstEvent, "EventFrameBurstStartData");
#else
pDev_->DeregisterCameraEventHandler(&BurstEvent, "EventLine1RisingEdgeData");
pDev_->DeregisterCameraEventHandler(&BurstEvent, "EventLine1FallingEdgeData");
pDev_->DeregisterCameraEventHandler(&BurstEvent, "EventLine1RisingEdgeData");
pDev_->DeregisterCameraEventHandler(&BurstEvent, "EventLine1FallingEdgeData");
#endif
}
}
}
}
void CaptureThreadBasler::fpsTimeout()
{
uint64_t delta = m_cntGrabbedImages - m_cntLastGrabbedImages;
m_cntLastGrabbedImages = m_cntGrabbedImages;
QString data = QString("%1").arg(delta);
emit updateStatistics(data.left(4), Local_Num);
uint64_t delta = m_cntGrabbedImages - m_cntLastGrabbedImages;
m_cntLastGrabbedImages = m_cntGrabbedImages;
QString data = QString("%1").arg(delta);
emit updateStatistics(data.left(4), Local_Num);
}
void CaptureThreadBasler::ioTimeout()
{
pDev_->UserOutputSelector.SetValue(Basler_UniversalCameraParams::UserOutputSelector_UserOutput1);
pDev_->UserOutputValue.SetValue(false);
pDev_->UserOutputSelector.SetValue(Basler_UniversalCameraParams::UserOutputSelector_UserOutput1);
pDev_->UserOutputValue.SetValue(false);
pDev_->UserOutputSelector.SetValue(Basler_UniversalCameraParams::UserOutputSelector_UserOutput3);
pDev_->UserOutputValue.SetValue(false);
pDev_->UserOutputSelector.SetValue(Basler_UniversalCameraParams::UserOutputSelector_UserOutput3);
pDev_->UserOutputValue.SetValue(false);
}

296
Cigarette/CaptureThreadBasler.h
Unescape Escape View File

@ -28,21 +28,21 @@ class CaptureThreadBasler_Func
{
public:
Pylon::CBaslerUniversalInstantCamera* pDev__;
ASyncQueue<bool> *p_result_queue_;
ASyncQueue<bool> *p_double_queue_;
QTimer *m_IOTimer_ = NULL;
ASyncQueue<bool>* p_result_queue_;
ASyncQueue<bool>* p_double_queue_;
QTimer* m_IOTimer_ = NULL;
void SendFeedBack(int OpID)
{
bool send_ng=false;
bool send_ok=false;
if(OpID == EdgeEvent)
bool send_ng = false;
bool send_ok = false;
if (OpID == EdgeEvent)
{
#if defined DOUBLE_FEED_BACK
if(p_double_queue_->count() > 0)
if (p_double_queue_->count() > 0)
{
bool temp;
p_double_queue_->take(temp);
send_ng=true;
send_ng = true;
}
#endif
}
@ -54,11 +54,11 @@ public:
#if defined DOUBLE_FEED_BACK
p_double_queue_->put(true);
#endif
send_ng=true;
send_ng = true;
}
else
{
send_ok=true;
send_ok = true;
}
}
#ifndef USB_BASLER_NEW_FW
@ -92,21 +92,21 @@ class CaptureThreadBasler : public QObject
Q_OBJECT
public:
explicit CaptureThreadBasler(Pylon::CBaslerUniversalInstantCamera* pCurrDev, bool boTerminated,int Num,int shoot);
explicit CaptureThreadBasler(Pylon::CBaslerUniversalInstantCamera* pCurrDev, bool boTerminated, int Num, int shoot);
CaptureThreadBasler::~CaptureThreadBasler(void);
void terminate( void )
void terminate(void)
{
boTerminated_ = true;
}
signals:
void error( QString err );
void finished( void );
void requestReady( void );
void updateStatistics( const QString& data ,int Num);
void error(QString err);
void finished(void);
void requestReady(void);
void updateStatistics(const QString& data, int Num);
private slots:
void process( void );
void process(void);
void fpsTimeout(void);
void ioTimeout(void);
@ -114,18 +114,18 @@ public:
int Local_Num;
int Shoot_Num;
#ifdef SYNC_CAMERA
ImageSyncArr *p_image_sync_arr;
ImageSyncArr* p_image_sync_arr;
SyncQueue<std::vector<std::pair<int, cv::Mat>>>* p_image_sync_queue;
#else
SyncQueue<std::pair<int, cv::Mat> >* p_image_queue;
#endif
ASyncQueue<cv::Mat> *p_unit_queue;
ASyncQueue<bool> *p_result_queue;
ASyncQueue<bool> *p_result_wait_queue;
ASyncQueue<bool> *p_double_queue;
ASyncQueue<bool> *p_shooted_queue;
SyncQueue<cv::Mat> *p_debug_queue;
QTimer *m_Timer = NULL,*m_IOTimer = NULL;
ASyncQueue<cv::Mat>* p_unit_queue;
ASyncQueue<bool>* p_result_queue;
ASyncQueue<bool>* p_result_wait_queue;
ASyncQueue<bool>* p_double_queue;
ASyncQueue<bool>* p_shooted_queue;
SyncQueue<cv::Mat>* p_debug_queue;
QTimer* m_Timer = NULL, * m_IOTimer = NULL;
uint64_t m_cntGrabbedImages = 0;
uint64_t m_cntLastGrabbedImages = 0;
bool Ready = false;
@ -141,7 +141,7 @@ class CSampleConfigurationEventHandler : public Pylon::CBaslerUniversalConfigura
public:
int channel_;
// This method is called from a different thread when the camera device removal has been detected.
void OnCameraDeviceRemoved( Pylon::CBaslerUniversalInstantCamera& camera )
void OnCameraDeviceRemoved(Pylon::CBaslerUniversalInstantCamera& camera)
{
SingleCamInfo[channel_].OffLine = true;
}
@ -151,158 +151,158 @@ public:
class CSampleCameraEventHandler : public Pylon::CBaslerUniversalCameraEventHandler
{
public:
QTimer * ioTimer;
QTimer* ioTimer;
ASyncQueue<cv::Mat>* p_unit_queue_;
ASyncQueue<bool> *p_result_wait_queue_;
ASyncQueue<bool> *p_result_queue_;
ASyncQueue<bool> *p_double_queue_;
ASyncQueue<bool> *p_shooted_queue_;
ASyncQueue<bool>* p_result_wait_queue_;
ASyncQueue<bool>* p_result_queue_;
ASyncQueue<bool>* p_double_queue_;
ASyncQueue<bool>* p_shooted_queue_;
#ifdef SYNC_CAMERA
ImageSyncArr *p_image_sync_arr_;
SyncQueue<std::vector<std::pair<int, cv::Mat>>> *p_image_sync_queue_;
ImageSyncArr* p_image_sync_arr_;
SyncQueue<std::vector<std::pair<int, cv::Mat>>>* p_image_sync_queue_;
#else
SyncQueue<std::pair<int, cv::Mat> >* p_image_queue_;
SyncQueue<std::pair<int, cv::Mat> >* p_image_queue_;
#endif
Pylon::CBaslerUniversalInstantCamera* pDev__;
CaptureThreadBasler* pCaptureThreadBasler = NULL;
// Only very short processing tasks should be performed by this method. Otherwise, the event notification will block the
// processing of images.
virtual void OnCameraEvent(Pylon::CBaslerUniversalInstantCamera& camera, intptr_t userProvidedId, GenApi::INode* pNode)
virtual void OnCameraEvent(Pylon::CBaslerUniversalInstantCamera& camera, intptr_t userProvidedId, GenApi::INode* pNode)
{
switch (userProvidedId)
{
#ifndef USB_BASLER_NEW_FW
case eMyFrameBurstStartEvent:
{
case eMyFrameBurstStartEvent:
{
#ifdef IMM_FEED_BACK
if (p_shooted_queue_->count() > 0)
{
if (p_shooted_queue_->count() > 0)
{
bool temp;
p_shooted_queue_->take(temp);
}
#elif defined ONE_TIME_SHIFT
if (
p_shooted_queue_->count() > 0
#if defined DOUBLE_FEED_BACK
|| p_double_queue_->count() > 0
#endif
)
{
if (p_shooted_queue_->count() > 0) {
bool temp;
p_shooted_queue_->take(temp);
}
#elif defined ONE_TIME_SHIFT
if (
p_shooted_queue_->count() > 0
#if defined DOUBLE_FEED_BACK
|| p_double_queue_->count() >0
#endif
)
{
if (p_shooted_queue_->count() > 0){
bool temp;
p_shooted_queue_->take(temp);
}
pCaptureThreadBasler->m_threadFunc.SendFeedBack(EdgeEvent);
}
pCaptureThreadBasler->m_threadFunc.SendFeedBack(EdgeEvent);
}
#else
if(p_unit_queue_->count() > 0){
int unit_count = p_unit_queue_->count();
cv::Mat long_image;
for (int i = 0; i < unit_count; i++)
if (p_unit_queue_->count() > 0) {
int unit_count = p_unit_queue_->count();
cv::Mat long_image;
for (int i = 0; i < unit_count; i++)
{
cv::Mat image;
p_unit_queue_->take(image);
if (0 == i)
{
cv::Mat image;
p_unit_queue_->take(image);
if (0 == i)
{
long_image = cv::Mat::zeros(image.rows * unit_count, image.cols, image.type());
}
cv::Rect r(0, i * image.rows, image.cols, image.rows);
cv::Mat roi = long_image(r);
image.copyTo(roi);
long_image = cv::Mat::zeros(image.rows * unit_count, image.cols, image.type());
}
p_image_queue_->put(std::make_pair(unit_count, long_image));
p_shooted_queue_->put(true);
p_unit_queue_->clear();
}
if(p_result_wait_queue_->count() > 0)
{
bool temp;
p_result_wait_queue_->take(temp);
pCaptureThreadBasler->m_threadFunc.SendFeedBack(EdgeEvent);
}
if(p_shooted_queue_->count() > 0)
{
bool temp;
p_shooted_queue_->take(temp);
p_result_wait_queue_->put(true);
cv::Rect r(0, i * image.rows, image.cols, image.rows);
cv::Mat roi = long_image(r);
image.copyTo(roi);
}
p_image_queue_->put(std::make_pair(unit_count, long_image));
p_shooted_queue_->put(true);
p_unit_queue_->clear();
}
if (p_result_wait_queue_->count() > 0)
{
bool temp;
p_result_wait_queue_->take(temp);
pCaptureThreadBasler->m_threadFunc.SendFeedBack(EdgeEvent);
}
if (p_shooted_queue_->count() > 0)
{
bool temp;
p_shooted_queue_->take(temp);
p_result_wait_queue_->put(true);
}
#endif
break;
}
}
#else
case Line1RisingEdge:
{
case Line1RisingEdge:
{
#ifdef IMM_FEED_BACK
if (p_shooted_queue_->count() > 0)
{
bool temp;
p_shooted_queue_->take(temp);
}
if (p_shooted_queue_->count() > 0)
{
bool temp;
p_shooted_queue_->take(temp);
}
#elif defined ONE_TIME_SHIFT
if (
p_shooted_queue_->count() > 0
#if defined DOUBLE_FEED_BACK
|| p_double_queue_->count() >0
#endif
)
{
bool temp;
p_shooted_queue_->take(temp);
pCaptureThreadBasler->m_threadFunc.SendFeedBack(EdgeEvent);
}
#else
if(p_result_wait_queue_->count() > 0)
{
bool temp;
p_result_wait_queue_->take(temp);
pCaptureThreadBasler->m_threadFunc.SendFeedBack(EdgeEvent);
}
if(p_shooted_queue_->count() > 0)
{
bool temp;
p_shooted_queue_->take(temp);
p_result_wait_queue_->put(true);
}
if (
p_shooted_queue_->count() > 0
#if defined DOUBLE_FEED_BACK
|| p_double_queue_->count() > 0
#endif
break;
)
{
bool temp;
p_shooted_queue_->take(temp);
pCaptureThreadBasler->m_threadFunc.SendFeedBack(EdgeEvent);
}
case Line1FallingEdge:
#else
if (p_result_wait_queue_->count() > 0)
{
int unit_count = p_unit_queue_->count();
if (unit_count > 0)
bool temp;
p_result_wait_queue_->take(temp);
pCaptureThreadBasler->m_threadFunc.SendFeedBack(EdgeEvent);
}
if (p_shooted_queue_->count() > 0)
{
bool temp;
p_shooted_queue_->take(temp);
p_result_wait_queue_->put(true);
}
#endif
break;
}
case Line1FallingEdge:
{
int unit_count = p_unit_queue_->count();
if (unit_count > 0)
{
cv::Mat long_image;
for (int i = 0; i < unit_count; i++)
{
cv::Mat long_image;
for (int i = 0; i < unit_count; i++)
cv::Mat image;
p_unit_queue_->take(image);
if (0 == i)
{
cv::Mat image;
p_unit_queue_->take(image);
if (0 == i)
{
long_image = cv::Mat::zeros(image.rows * unit_count, image.cols, image.type());
}
cv::Rect r(0, i * image.rows, image.cols, image.rows);
cv::Mat roi = long_image(r);
image.copyTo(roi);
long_image = cv::Mat::zeros(image.rows * unit_count, image.cols, image.type());
}
cv::Rect r(0, i * image.rows, image.cols, image.rows);
cv::Mat roi = long_image(r);
image.copyTo(roi);
}
#ifdef SYNC_CAMERA
{
std::lock_guard<std::mutex> locker(p_image_sync_arr_->lock);
p_image_sync_arr_->image_sync_arr.at(pCaptureThreadBasler->Local_Num) = std::make_pair(unit_count, long_image);
p_image_sync_arr_->collect_cnt++;
if (p_image_sync_arr_->collect_cnt == work_camera_nums)
{
p_image_sync_queue_->put(p_image_sync_arr_->image_sync_arr);
p_image_sync_arr_->collect_cnt = 0;
}
}
{
std::lock_guard<std::mutex> locker(p_image_sync_arr_->lock);
p_image_sync_arr_->image_sync_arr.at(pCaptureThreadBasler->Local_Num) = std::make_pair(unit_count, long_image);
p_image_sync_arr_->collect_cnt++;
if (p_image_sync_arr_->collect_cnt == work_camera_nums)
{
p_image_sync_queue_->put(p_image_sync_arr_->image_sync_arr);
p_image_sync_arr_->collect_cnt = 0;
}
}
#else
p_image_queue_->put(std::make_pair(unit_count, long_image));
p_image_queue_->put(std::make_pair(unit_count, long_image));
#endif
p_shooted_queue_->put(true);
}
p_unit_queue_->clear();
break;
p_shooted_queue_->put(true);
}
p_unit_queue_->clear();
break;
}
#endif
default:
break;
@ -315,13 +315,13 @@ class CSampleImageEventHandler : public Pylon::CBaslerUniversalImageEventHandler
public:
ASyncQueue<cv::Mat>* p_unit_queue_;
#ifdef SYNC_CAMERA
ImageSyncArr *p_image_sync_arr_;
SyncQueue<std::vector<std::pair<int, cv::Mat>>> *p_image_sync_queue_;
ImageSyncArr* p_image_sync_arr_;
SyncQueue<std::vector<std::pair<int, cv::Mat>>>* p_image_sync_queue_;
#else
SyncQueue<std::pair<int, cv::Mat> >* p_image_queue_;
SyncQueue<std::pair<int, cv::Mat> >* p_image_queue_;
#endif
SyncQueue<cv::Mat>* p_debug_queue_;
ASyncQueue<bool> *p_shooted_queue_;
ASyncQueue<bool>* p_shooted_queue_;
Pylon::CBaslerUniversalInstantCamera* pDev__;
uint64_t* m_cntGrabbedImages_;
int Shoot_Num_;
@ -347,7 +347,7 @@ public:
if (!g_debug_mode)
{
#ifdef IMM_PROCESS
p_image_queue_->put(std::make_pair(1,image_clone));
p_image_queue_->put(std::make_pair(1, image_clone));
#else
p_unit_queue_->put(image_clone);
#endif

379
Cigarette/CaptureThreadHIK.cpp
Unescape Escape View File

@ -4,105 +4,114 @@
#include "common.h"
#include <windows.h>
#include "exportData.h"
extern bool g_debug_mode; //相机调试模式，工作模式必须停止状态才能打开
extern bool g_debug_mode; //相机调试模式，工作模式必须停止状态才能打开
extern SingleCamInfoStruct SingleCamInfo[NumberOfSupportedCameras];
extern SyncQueue<_XMLExportDataInfo>* export_XMLData_Info_queue;
extern PLCDevice* m_PLCDevice;
extern int work_camera_nums;
inline void LossCallBackfunction(unsigned int pData, void* pUser){
try{
CaptureThreadHIK* CaptureThreadHIKptr = (CaptureThreadHIK*)pUser;
SingleCamInfo[CaptureThreadHIKptr->Local_Num].OffLine = true;
CaptureThreadHIKptr->terminate();
}
catch(...){
std::cout << "LossCallBackfunction error" << std::endl;
}
inline void LossCallBackfunction(unsigned int pData, void* pUser) {
try {
CaptureThreadHIK* CaptureThreadHIKptr = (CaptureThreadHIK*)pUser;
SingleCamInfo[CaptureThreadHIKptr->Local_Num].OffLine = true;
CaptureThreadHIKptr->terminate();
}
catch (...) {
std::cout << "LossCallBackfunction error" << std::endl;
}
}
inline void FallingGpioEventfunction(MV_EVENT_OUT_INFO* pEventInfo, void* pUser){
try{
CaptureThreadHIK* CaptureThreadHIKptr = (CaptureThreadHIK*)pUser;
int unit_count = CaptureThreadHIKptr->p_unit_queue->count();
if (unit_count > 0)
{
cv::Mat long_image;
for (int i = 0; i < unit_count; i++)
{
cv::Mat image;
CaptureThreadHIKptr->p_unit_queue->take(image);
if (0 == i)
{
long_image = cv::Mat::zeros(image.rows * unit_count, image.cols, image.type());
}
cv::Rect r(0, i * image.rows, image.cols, image.rows);
cv::Mat roi = long_image(r);
image.copyTo(roi);
}
inline void FallingGpioEventfunction(MV_EVENT_OUT_INFO* pEventInfo, void* pUser) {
try {
CaptureThreadHIK* CaptureThreadHIKptr = (CaptureThreadHIK*)pUser;
int unit_count = CaptureThreadHIKptr->p_unit_queue->count();
if (unit_count > 0)
{
cv::Mat long_image;
for (int i = 0; i < unit_count; i++)
{
cv::Mat image;
CaptureThreadHIKptr->p_unit_queue->take(image);
if (0 == i)
{
long_image = cv::Mat::zeros(image.rows * unit_count, image.cols, image.type());
}
cv::Rect r(0, i * image.rows, image.cols, image.rows);
cv::Mat roi = long_image(r);
image.copyTo(roi);
}
#ifdef SYNC_CAMERA
{
std::lock_guard<std::mutex> locker(CaptureThreadHIKptr->p_image_sync_arr->lock);
CaptureThreadHIKptr->p_image_sync_arr->image_sync_arr.at(CaptureThreadHIKptr->Local_Num) = std::make_pair(unit_count, long_image);
CaptureThreadHIKptr->p_image_sync_arr->collect_cnt++;
if (CaptureThreadHIKptr->p_image_sync_arr->collect_cnt == work_camera_nums)
{
CaptureThreadHIKptr->p_image_sync_queue->put(CaptureThreadHIKptr->p_image_sync_arr->image_sync_arr);
CaptureThreadHIKptr->p_image_sync_arr->collect_cnt = 0;
}
}
{
std::lock_guard<std::mutex> locker(CaptureThreadHIKptr->p_image_sync_arr->lock);
CaptureThreadHIKptr->p_image_sync_arr->image_sync_arr.at(CaptureThreadHIKptr->Local_Num) = std::make_pair(unit_count, long_image);
CaptureThreadHIKptr->p_image_sync_arr->collect_cnt++;
if (CaptureThreadHIKptr->p_image_sync_arr->collect_cnt == work_camera_nums)
{
CaptureThreadHIKptr->p_image_sync_queue->put(CaptureThreadHIKptr->p_image_sync_arr->image_sync_arr);
CaptureThreadHIKptr->p_image_sync_arr->collect_cnt = 0;
//CaptureThreadHIKptr->p_image_sync_arr->image_sync_arr.swap(std::vector<std::pair<int, cv::Mat>>());
}
}
#else
CaptureThreadHIKptr->p_image_queue->put(std::make_pair(unit_count, long_image));
#endif
CaptureThreadHIKptr->p_shooted_queue->put(true);
}
CaptureThreadHIKptr->p_unit_queue->clear();
}
catch(...){
std::cout << "FallingGpioEventfunction error" << std::endl;
}
CaptureThreadHIKptr->p_image_queue->put(std::make_pair(unit_count, long_image));
#endif
CaptureThreadHIKptr->p_shooted_queue->put(true);
}
CaptureThreadHIKptr->p_unit_queue->clear();
}
catch (...) {
//std::cout << "FallingGpioEventfunction error" << std::endl;
std::exception_ptr p = std::current_exception();
try {
if (p)
std::rethrow_exception(p);
}
catch (const std::exception& e) {
qDebug() << "Caught an exception: " << e.what();
}
}
}
inline void RisingGpioEventfunction(MV_EVENT_OUT_INFO* pEventInfo, void* pUser){
try{
CaptureThreadHIK* CaptureThreadHIKptr = (CaptureThreadHIK*)pUser;
inline void RisingGpioEventfunction(MV_EVENT_OUT_INFO* pEventInfo, void* pUser) {
try {
CaptureThreadHIK* CaptureThreadHIKptr = (CaptureThreadHIK*)pUser;
#ifdef IMM_FEED_BACK
if (CaptureThreadHIKptr->p_shooted_queue->count() > 0)
{
bool temp;
CaptureThreadHIKptr->p_shooted_queue->take(temp);
}
if (CaptureThreadHIKptr->p_shooted_queue->count() > 0)
{
bool temp;
CaptureThreadHIKptr->p_shooted_queue->take(temp);
}
#elif defined ONE_TIME_SHIFT
if(
CaptureThreadHIKptr->p_shooted_queue->count() > 0
#if defined DOUBLE_FEED_BACK
|| CaptureThreadHIKptr->p_double_queue->count() > 0
#endif
)
{
if (CaptureThreadHIKptr->p_shooted_queue->count() > 0){
bool temp;
CaptureThreadHIKptr->p_shooted_queue->take(temp);
}
CaptureThreadHIKptr->m_threadFunc.SendFeedBack(EdgeEvent);
}
if (
CaptureThreadHIKptr->p_shooted_queue->count() > 0
#if defined DOUBLE_FEED_BACK
|| CaptureThreadHIKptr->p_double_queue->count() > 0
#endif
)
{
if (CaptureThreadHIKptr->p_shooted_queue->count() > 0) {
bool temp;
CaptureThreadHIKptr->p_shooted_queue->take(temp);
}
CaptureThreadHIKptr->m_threadFunc.SendFeedBack(EdgeEvent);
}
#else
if(CaptureThreadHIKptr->p_result_wait_queue->count() > 0)
{
bool temp;
CaptureThreadHIKptr->p_result_wait_queue->take(temp);
CaptureThreadHIKptr->m_threadFunc.SendFeedBack(EdgeEvent);
}
if(CaptureThreadHIKptr->p_shooted_queue->count() > 0)
{
bool temp;
CaptureThreadHIKptr->p_shooted_queue->take(temp);
CaptureThreadHIKptr->p_result_wait_queue->put(true);
}
#endif
}
catch(...){
std::cout << "RisingGpioEventfunction error" << std::endl;
}
if (CaptureThreadHIKptr->p_result_wait_queue->count() > 0)
{
bool temp;
CaptureThreadHIKptr->p_result_wait_queue->take(temp);
CaptureThreadHIKptr->m_threadFunc.SendFeedBack(EdgeEvent);
}
if (CaptureThreadHIKptr->p_shooted_queue->count() > 0)
{
bool temp;
CaptureThreadHIKptr->p_shooted_queue->take(temp);
CaptureThreadHIKptr->p_result_wait_queue->put(true);
}
#endif
}
catch (...) {
std::cout << "RisingGpioEventfunction error" << std::endl;
}
}
#define CaptureThreadHIK_init(a)\
@ -136,183 +145,183 @@ CaptureThreadHIK_init(8)
void(*LossCallBack[NumberOfSupportedCameras])(unsigned int pData, void* pUser) = {
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>0)
LossCallBack1
LossCallBack1
#endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>1)
,LossCallBack2
,LossCallBack2
#endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>2)
,LossCallBack3
,LossCallBack3
#endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>3)
,LossCallBack4
,LossCallBack4
#endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>4)
,LossCallBack5
,LossCallBack5
#endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>5)
,LossCallBack6
,LossCallBack6
#endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>6)
,LossCallBack7
,LossCallBack7
#endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>7)
,LossCallBack8
,LossCallBack8
#endif
};
void(*FallingGpioEvent[NumberOfSupportedCameras])(MV_EVENT_OUT_INFO* pEventInfo, void* pUser) = {
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>0)
FallingGpioEvent1
FallingGpioEvent1
#endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>1)
,FallingGpioEvent2
,FallingGpioEvent2
#endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>2)
,FallingGpioEvent3
,FallingGpioEvent3
#endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>3)
,FallingGpioEvent4
,FallingGpioEvent4
#endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>4)
,FallingGpioEvent5
,FallingGpioEvent5
#endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>5)
,FallingGpioEvent6
,FallingGpioEvent6
#endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>6)
,FallingGpioEvent7
,FallingGpioEvent7
#endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>7)
,FallingGpioEvent8
,FallingGpioEvent8
#endif
};
void(*RisingGpioEvent[NumberOfSupportedCameras])(MV_EVENT_OUT_INFO* pEventInfo, void* pUser) = {
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>0)
RisingGpioEvent1
RisingGpioEvent1
#endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>1)
,RisingGpioEvent2
,RisingGpioEvent2
#endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>2)
,RisingGpioEvent3
,RisingGpioEvent3
#endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>3)
,RisingGpioEvent4
,RisingGpioEvent4
#endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>4)
,RisingGpioEvent5
,RisingGpioEvent5
#endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>5)
,RisingGpioEvent6
,RisingGpioEvent6
#endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>6)
,RisingGpioEvent7
,RisingGpioEvent7
#endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>7)
,RisingGpioEvent8
,RisingGpioEvent8
#endif
};
void CaptureThreadHIK::fpsTimeout(void)
{
uint64_t delta = m_cntGrabbedImages - m_cntLastGrabbedImages;
m_cntLastGrabbedImages = m_cntGrabbedImages;
QString data = QString("%1").arg(delta);
emit updateStatistics(data.left(4), Local_Num);
uint64_t delta = m_cntGrabbedImages - m_cntLastGrabbedImages;
m_cntLastGrabbedImages = m_cntGrabbedImages;
QString data = QString("%1").arg(delta);
emit updateStatistics(data.left(4), Local_Num);
}
//-----------------------------------------------------------------------------
CaptureThreadHIK::CaptureThreadHIK(void *camhandle, bool boTerminated,int Num) :
CamHandle( camhandle ), boTerminated_( boTerminated ),Local_Num(Num)
//-----------------------------------------------------------------------------
CaptureThreadHIK::CaptureThreadHIK(void* camhandle, bool boTerminated, int Num) :
CamHandle(camhandle), boTerminated_(boTerminated), Local_Num(Num)
//-----------------------------------------------------------------------------
{
p_unit_queue = new ASyncQueue<cv::Mat>(Unit_Queue_Size);
g_pImage_buf = (unsigned char*)malloc(3000 * 3000 * 3);
p_unit_queue = new ASyncQueue<cv::Mat>(Unit_Queue_Size);
g_pImage_buf = (unsigned char*)malloc(3000 * 3000 * 3);
}
CaptureThreadHIK::~CaptureThreadHIK()
{
delete p_unit_queue;
free(g_pImage_buf);
delete p_unit_queue;
free(g_pImage_buf);
}
//-----------------------------------------------------------------------------
void CaptureThreadHIK::process( void )
void CaptureThreadHIK::process(void)
//-----------------------------------------------------------------------------
{
try {
int nRet = MV_OK, nnRet = MV_OK;
try {
int nRet = MV_OK, nnRet = MV_OK;
m_threadFunc.CamHandle_ = CamHandle;
m_threadFunc.p_result_queue_ = p_result_queue;
m_threadFunc.p_double_queue_ = p_double_queue;
m_threadFunc.CamHandle_ = CamHandle;
m_threadFunc.p_result_queue_ = p_result_queue;
m_threadFunc.p_double_queue_ = p_double_queue;
nRet = MV_CC_RegisterExceptionCallBack(CamHandle, LossCallBack[Local_Num], this);
if (nRet) { std::cout << "can not register loss callback" << std::endl; nnRet = nRet; }
nRet = MV_CC_RegisterExceptionCallBack(CamHandle, LossCallBack[Local_Num], this);
if (nRet) { std::cout << "can not register loss callback" << std::endl; nnRet = nRet; }
//#ifdef IMM_FEED_BACK ///不打开无反馈等( 延后一次两次用ifndef // 不延后用ifdef)
nRet = MV_CC_SetEnumValueByString(CamHandle, "EventSelector", "Line0FallingEdge");
if (nRet) { std::cout << "can not set EventSelector" << std::endl; nnRet = nRet; }
//#ifdef IMM_FEED_BACK ///不打开无反馈等( 延后一次两次用ifndef // 不延后用ifdef)
nRet = MV_CC_SetEnumValueByString(CamHandle, "EventSelector", "Line0FallingEdge");
if (nRet) { std::cout << "can not set EventSelector" << std::endl; nnRet = nRet; }
nRet = MV_CC_SetEnumValueByString(CamHandle, "EventNotification", "On");
if (nRet) { std::cout << "can not set EventNotification" << std::endl; nnRet = nRet; }
nRet = MV_CC_SetEnumValueByString(CamHandle, "EventNotification", "On");
if (nRet) { std::cout << "can not set EventNotification" << std::endl; nnRet = nRet; }
nRet = MV_CC_SetEnumValueByString(CamHandle, "EventSelector", "Line0RisingEdge");
if (nRet) { std::cout << "can not set EventSelector" << std::endl; nnRet = nRet; }
nRet = MV_CC_SetEnumValueByString(CamHandle, "EventSelector", "Line0RisingEdge");
if (nRet) { std::cout << "can not set EventSelector" << std::endl; nnRet = nRet; }
nRet = MV_CC_SetEnumValueByString(CamHandle, "EventNotification", "On");
if (nRet) { std::cout << "can not set EventNotification" << std::endl; nnRet = nRet; }
nRet = MV_CC_SetEnumValueByString(CamHandle, "EventNotification", "On");
if (nRet) { std::cout << "can not set EventNotification" << std::endl; nnRet = nRet; }
nRet = MV_CC_RegisterEventCallBackEx(CamHandle, "Line0FallingEdge", FallingGpioEvent[Local_Num], this);
if (nRet) { std::cout << "can not register GPIO callback" << std::endl; nnRet = nRet; }
nRet = MV_CC_RegisterEventCallBackEx(CamHandle, "Line0FallingEdge", FallingGpioEvent[Local_Num], this);
if (nRet) { std::cout << "can not register GPIO callback" << std::endl; nnRet = nRet; }
nRet = MV_CC_RegisterEventCallBackEx(CamHandle, "Line0RisingEdge", RisingGpioEvent[Local_Num], this);
if (nRet) { std::cout << "can not register GPIO callback" << std::endl; nnRet = nRet; }
//#endif
nRet = MV_CC_RegisterEventCallBackEx(CamHandle, "Line0RisingEdge", RisingGpioEvent[Local_Num], this);
if (nRet) { std::cout << "can not register GPIO callback" << std::endl; nnRet = nRet; }
//#endif
m_Timer = new QTimer();
connect(m_Timer, SIGNAL(timeout()), this, SLOT(fpsTimeout()));
m_Timer->start(1000);
m_Timer = new QTimer();
connect(m_Timer, SIGNAL(timeout()), this, SLOT(fpsTimeout()));
m_Timer->start(1000);
unsigned int nDataSize;
MVCC_INTVALUE_EX stIntValue = { 0 };
nRet = MV_CC_GetIntValueEx(CamHandle, "PayloadSize", &stIntValue);
if (nRet) { std::cout << "Get PayloadSize error" << std::endl; }
nDataSize = stIntValue.nCurValue*3;///
MV_CC_StartGrabbing(CamHandle);
Ready = true;
while(!boTerminated_)
{
//nRet = MV_CC_GetOneFrameTimeout(CamHandle, g_pImage_buf, nDataSize, &stFrameInfo, 200);
nRet = MV_CC_GetImageForBGR(CamHandle, g_pImage_buf, nDataSize, &stFrameInfo, 100);
if (MV_OK == nRet)
{
m_cntGrabbedImages++;
unsigned int nDataSize;
MVCC_INTVALUE_EX stIntValue = { 0 };
nRet = MV_CC_GetIntValueEx(CamHandle, "PayloadSize", &stIntValue);
if (nRet) { std::cout << "Get PayloadSize error" << std::endl; }
nDataSize = stIntValue.nCurValue * 3;///
MV_CC_StartGrabbing(CamHandle);
Ready = true;
while (!boTerminated_)
{
//nRet = MV_CC_GetOneFrameTimeout(CamHandle, g_pImage_buf, nDataSize, &stFrameInfo, 200);
nRet = MV_CC_GetImageForBGR(CamHandle, g_pImage_buf, nDataSize, &stFrameInfo, 100);
if (MV_OK == nRet)
{
m_cntGrabbedImages++;
cv::Mat openCVImage(stFrameInfo.nHeight, stFrameInfo.nWidth, CV_8UC3, g_pImage_buf);
cv::Mat image_clone = openCVImage.clone();
if (!g_debug_mode)
{
cv::Mat openCVImage(stFrameInfo.nHeight, stFrameInfo.nWidth, CV_8UC3, g_pImage_buf);
cv::Mat image_clone = openCVImage.clone();
if (!g_debug_mode)
{
#ifdef IMM_PROCESS
p_image_queue->put(std::make_pair(1,image_clone));
p_image_queue->put(std::make_pair(1, image_clone));
#else
p_unit_queue->put(image_clone); //放入临时队列
#endif
}
else
{
p_debug_queue->put(image_clone); //放入调试队列
}
}
p_unit_queue->put(image_clone); //放入临时队列
#endif
}
else
{
p_debug_queue->put(image_clone); //放入调试队列
}
}
#if defined (IMM_FEED_BACK) || defined (CAP_FEED_BACK)
m_threadFunc.SendFeedBack(ImageCap);
#endif
QCoreApplication::processEvents();//Make sure the timer is triggered
}
MV_CC_StopGrabbing(CamHandle);
MV_CC_CloseDevice(CamHandle);
delete m_Timer;
}
catch (cv::Exception& e) {
const char* err_msg = e.what();
std::cout << "exception caught: " << err_msg << std::endl;
}
m_threadFunc.SendFeedBack(ImageCap);
#endif
QCoreApplication::processEvents();//Make sure the timer is triggered
}
MV_CC_StopGrabbing(CamHandle);
MV_CC_CloseDevice(CamHandle);
delete m_Timer;
}
catch (cv::Exception& e) {
const char* err_msg = e.what();
std::cout << "exception caught: " << err_msg << std::endl;
}
}
//-----------------------------------------------------------------------------

60
Cigarette/CaptureThreadHIK.h
Unescape Escape View File

@ -17,21 +17,21 @@
class CaptureThreadHIK_Func
{
public:
void *CamHandle_;
ASyncQueue<bool> *p_result_queue_;
ASyncQueue<bool> *p_double_queue_;
void* CamHandle_;
ASyncQueue<bool>* p_result_queue_;
ASyncQueue<bool>* p_double_queue_;
void SendFeedBack(int OpID)
{
bool send_ng=false;
bool send_ok=false;
if(OpID == EdgeEvent)
bool send_ng = false;
bool send_ok = false;
if (OpID == EdgeEvent)
{
#if defined DOUBLE_FEED_BACK
if(p_double_queue_->count() > 0)
if (p_double_queue_->count() > 0)
{
bool temp;
p_double_queue_->take(temp);
send_ng=true;
send_ng = true;
}
#endif
}
@ -44,10 +44,10 @@ public:
#if defined DOUBLE_FEED_BACK
p_double_queue_->put(true);
#endif
send_ng=true;
send_ng = true;
}
}
if(send_ng)
if (send_ng)
{
MV_CC_SetEnumValue(CamHandle_, "LineSelector", 1);
MV_CC_SetCommandValue(CamHandle_, "LineTriggerSoftware");
@ -57,50 +57,50 @@ public:
//-----------------------------------------------------------------------------
class CaptureThreadHIK : public QObject
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
{
Q_OBJECT
public:
explicit CaptureThreadHIK(void *camhandle, bool boTerminated,int Num);
explicit CaptureThreadHIK(void* camhandle, bool boTerminated, int Num);
CaptureThreadHIK::~CaptureThreadHIK(void);
void terminate( void )
void terminate(void)
{
boTerminated_ = true;
}
signals:
void error( QString err );
void finished( void );
void requestReady( void );
void updateStatistics( const QString& data ,int Num);
void error(QString err);
void finished(void);
void requestReady(void);
void updateStatistics(const QString& data, int Num);
private slots:
void process( void );
void fpsTimeout(void);
void process(void);
void fpsTimeout(void);
public:
int Local_Num;
#ifdef SYNC_CAMERA
ImageSyncArr *p_image_sync_arr;
ImageSyncArr* p_image_sync_arr;
SyncQueue<std::vector<std::pair<int, cv::Mat>>>* p_image_sync_queue;
#else
SyncQueue<std::pair<int, cv::Mat> >* p_image_queue;
#endif
ASyncQueue<cv::Mat> *p_unit_queue;
ASyncQueue<bool> *p_result_queue;
ASyncQueue<bool> *p_result_wait_queue;
ASyncQueue<bool> *p_double_queue;
ASyncQueue<bool> *p_shooted_queue;
SyncQueue<cv::Mat> *p_debug_queue;
ASyncQueue<cv::Mat>* p_unit_queue;
ASyncQueue<bool>* p_result_queue;
ASyncQueue<bool>* p_result_wait_queue;
ASyncQueue<bool>* p_double_queue;
ASyncQueue<bool>* p_shooted_queue;
SyncQueue<cv::Mat>* p_debug_queue;
void* CamHandle;
QTimer* m_Timer;
uint64_t m_cntGrabbedImages = 0;
uint64_t m_cntLastGrabbedImages = 0;
QTimer* m_Timer;
uint64_t m_cntGrabbedImages = 0;
uint64_t m_cntLastGrabbedImages = 0;
bool Ready = false;
CaptureThreadHIK_Func m_threadFunc;
private:
MV_FRAME_OUT_INFO_EX stFrameInfo;
unsigned char* g_pImage_buf;
unsigned char* g_pImage_buf;
volatile bool boTerminated_;
QMutex lock_;
};

4
Cigarette/Cigarette.vcxproj
Unescape Escape View File

@ -249,10 +249,6 @@
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="GeneratedFiles\Debug\moc_SyncWorkThread.cpp">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="GeneratedFiles\qrc_cigarette.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
</PrecompiledHeader>

3
Cigarette/Cigarette.vcxproj.filters
Unescape Escape View File

@ -263,9 +263,6 @@
<ClCompile Include="SyncWorkThread.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="GeneratedFiles\Debug\moc_SyncWorkThread.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="GeneratedFiles\Release\moc_SyncWorkThread.cpp">
<Filter>Source Files</Filter>
</ClCompile>

236
Cigarette/Cleanthread.cpp
Unescape Escape View File

@ -17,142 +17,142 @@ CleanWorkThread::~CleanWorkThread()
{
}
void CleanWorkThread::setSelAuto() {
delSelection = 1;
delSelection = 1;
}
void CleanWorkThread::setSel() {
delSelection = 2;
delSelection = 2;
}
void CleanWorkThread::startWork()
{
emit workStart();
doWork();
emit workStart();
doWork();
}
void CleanWorkThread::startWorkAuto()
{
emit workStartAuto();
doWork();
emit workStartAuto();
doWork();
}
void CleanWorkThread::doWork()
{
qint64 spaceSize;
qint64 dirSize;
QString dirPath = g_conf_path.save_pics_path;
//QString iDriver = "D:/";
char drive[_MAX_DRIVE];
char dir_1[_MAX_DIR];
char fname[_MAX_FNAME];
char ext[_MAX_EXT];
qint64 spaceSize;
qint64 dirSize;
QString dirPath = g_conf_path.save_pics_path;
//QString iDriver = "D:/";
char drive[_MAX_DRIVE];
char dir_1[_MAX_DIR];
char fname[_MAX_FNAME];
char ext[_MAX_EXT];
_splitpath(dirPath.toStdString().c_str(), drive, dir_1, fname, ext);
QString iDriver = drive + QString("/");
LPCWSTR strDriver = (LPCWSTR)iDriver.utf16();
ULARGE_INTEGER freeDiskSpaceAvailable, totalDiskSpace, totalFreeDiskSpace;
qint64 gb = (1024 * 1024 * 1024);
//QString dir("D:/image");
QString dir(g_conf_path.save_pics_path + "/ALL");
_splitpath(dirPath.toStdString().c_str(), drive, dir_1, fname, ext);
QString iDriver = drive + QString("/");
LPCWSTR strDriver = (LPCWSTR)iDriver.utf16();
ULARGE_INTEGER freeDiskSpaceAvailable, totalDiskSpace, totalFreeDiskSpace;
qint64 gb = (1024 * 1024 * 1024);
//QString dir("D:/image");
QString dir(g_conf_path.save_pics_path + "/ALL");
if (delSelection == 2)
{
CleanImageFile(dir, 1);
}
else
{
qint64 delDays = g_sys_conf.save_days;///
qint64 freeSize = g_sys_conf.freesize;
CleanImageFile(dir, delDays--);
//调用函数获取磁盘参数(单位为字节Byte),转化为GB，需要除以(1024*1024*1024)
GetDiskFreeSpaceEx(strDriver, &freeDiskSpaceAvailable, &totalDiskSpace, &totalFreeDiskSpace);
spaceSize = ((qint64)totalFreeDiskSpace.QuadPart * (100/freeSize)) / (qint64)totalDiskSpace.QuadPart;
dirSize = DirFileSize(dir) / gb;
//delDays = g_sys_conf.save_days;
while ((spaceSize < 1) && (delDays > 1)) { //磁盘剩余空间小于百分之十
CleanImageFile(dir, delDays--);
GetDiskFreeSpaceEx(strDriver, &freeDiskSpaceAvailable, &totalDiskSpace, &totalFreeDiskSpace);
spaceSize = ((qint64)totalFreeDiskSpace.QuadPart * (100 / freeSize)) / (qint64)totalDiskSpace.QuadPart;
}
}
emit workFinished();
if (delSelection == 2)
{
CleanImageFile(dir, 1);
}
else
{
qint64 delDays = g_sys_conf.save_days;///
qint64 freeSize = g_sys_conf.freesize;
CleanImageFile(dir, delDays--);
//调用函数获取磁盘参数(单位为字节Byte),转化为GB，需要除以(1024*1024*1024)
GetDiskFreeSpaceEx(strDriver, &freeDiskSpaceAvailable, &totalDiskSpace, &totalFreeDiskSpace);
spaceSize = ((qint64)totalFreeDiskSpace.QuadPart * (100 / freeSize)) / (qint64)totalDiskSpace.QuadPart;
dirSize = DirFileSize(dir) / gb;
//delDays = g_sys_conf.save_days;
while ((spaceSize < 1) && (delDays > 1)) { //磁盘剩余空间小于百分之十
CleanImageFile(dir, delDays--);
GetDiskFreeSpaceEx(strDriver, &freeDiskSpaceAvailable, &totalDiskSpace, &totalFreeDiskSpace);
spaceSize = ((qint64)totalFreeDiskSpace.QuadPart * (100 / freeSize)) / (qint64)totalDiskSpace.QuadPart;
}
}
emit workFinished();
}
void CleanWorkThread::CleanImageFile(const QString& path, const qint64& delDays)
{
QDir dir(path);
QFileInfoList list;
QFileInfo curFile;
if (!dir.exists()) { return; }//文件不存，则返回false
dir.setFilter(QDir::Dirs | QDir::Files);
list = dir.entryInfoList(QDir::Dirs | QDir::Files
| QDir::Readable | QDir::Writable
| QDir::Hidden | QDir::NoDotAndDotDot
, QDir::Time);
if (list.isEmpty()) { return; }//文件夹为空，则返回false
int i = list.size() - 1;
do {
QFileInfo fileInfo = list.at(i);
// dir.removeRecursively();
while (fileInfo.fileName() == "." || fileInfo.fileName() == ".." && i >= 0)
{
i--;
}
if (i < 0) {
break;
}
bool bisDir = fileInfo.isDir();
if (bisDir)
{
QRegExp rx("\\d{4}-\\d{2}-\\d{2}");
QRegExpValidator v(rx, 0);
int pos = 0;
int match;
QString name = fileInfo.fileName();
match = v.validate(name, pos);
if (match == 2)
{
QDate delDate = QDate::currentDate();
QDate dirDate;
QString name = fileInfo.fileName();
dirDate = QDate::fromString(fileInfo.fileName(), "yyyy-MM-dd");
qint64 nDays = dirDate.daysTo(delDate);
if (nDays >= delDays)
{
if (fileInfo.isDir()) {
QString n = fileInfo.absoluteFilePath();
QDir subPath(fileInfo.absoluteFilePath());
subPath.removeRecursively();
}
else
{
fileInfo.dir().remove(fileInfo.fileName());
}
}
}
else
{
CleanImageFile(fileInfo.filePath(), delDays);
}
}
else
{
fileInfo.dir().remove(fileInfo.fileName());
}
i--;
} while (i >= 0);
QDir dir(path);
QFileInfoList list;
QFileInfo curFile;
if (!dir.exists()) { return; }//文件不存，则返回false
dir.setFilter(QDir::Dirs | QDir::Files);
list = dir.entryInfoList(QDir::Dirs | QDir::Files
| QDir::Readable | QDir::Writable
| QDir::Hidden | QDir::NoDotAndDotDot
, QDir::Time);
if (list.isEmpty()) { return; }//文件夹为空，则返回false
int i = list.size() - 1;
do {
QFileInfo fileInfo = list.at(i);
// dir.removeRecursively();
while (fileInfo.fileName() == "." || fileInfo.fileName() == ".." && i >= 0)
{
i--;
}
if (i < 0) {
break;
}
bool bisDir = fileInfo.isDir();
if (bisDir)
{
QRegExp rx("\\d{4}-\\d{2}-\\d{2}");
QRegExpValidator v(rx, 0);
int pos = 0;
int match;
QString name = fileInfo.fileName();
match = v.validate(name, pos);
if (match == 2)
{
QDate delDate = QDate::currentDate();
QDate dirDate;
QString name = fileInfo.fileName();
dirDate = QDate::fromString(fileInfo.fileName(), "yyyy-MM-dd");
qint64 nDays = dirDate.daysTo(delDate);
if (nDays >= delDays)
{
if (fileInfo.isDir()) {
QString n = fileInfo.absoluteFilePath();
QDir subPath(fileInfo.absoluteFilePath());
subPath.removeRecursively();
}
else
{
fileInfo.dir().remove(fileInfo.fileName());
}
}
}
else
{
CleanImageFile(fileInfo.filePath(), delDays);
}
}
else
{
fileInfo.dir().remove(fileInfo.fileName());
}
i--;
} while (i >= 0);
}
qint64 CleanWorkThread::DirFileSize(const QString& path)
{
QDir dir(path);
quint64 size = 0;
//dir.entryInfoList(QDir::Files)返回文件信息
foreach(QFileInfo fileInfo, dir.entryInfoList(QDir::Files))
{
//计算文件大小
size += fileInfo.size();
}
//dir.entryList(QDir::Dirs|QDir::NoDotAndDotDot)返回所有子目录，并进行过滤
foreach(QString subDir, dir.entryList(QDir::Dirs | QDir::NoDotAndDotDot))
{
//若存在子目录，则递归调用dirFileSize()函数
size += DirFileSize(path + QDir::separator() + subDir);
}
return size;
QDir dir(path);
quint64 size = 0;
//dir.entryInfoList(QDir::Files)返回文件信息
foreach(QFileInfo fileInfo, dir.entryInfoList(QDir::Files))
{
//计算文件大小
size += fileInfo.size();
}
//dir.entryList(QDir::Dirs|QDir::NoDotAndDotDot)返回所有子目录，并进行过滤
foreach(QString subDir, dir.entryList(QDir::Dirs | QDir::NoDotAndDotDot))
{
//若存在子目录，则递归调用dirFileSize()函数
size += DirFileSize(path + QDir::separator() + subDir);
}
return size;
}

28
Cigarette/Cleanthread.h
Unescape Escape View File

@ -2,23 +2,23 @@
#include <QObject>
class CleanWorkThread : public QObject
{
Q_OBJECT
Q_OBJECT
public:
CleanWorkThread(QObject* parent = nullptr);
~CleanWorkThread();
CleanWorkThread(QObject* parent = nullptr);
~CleanWorkThread();
public slots:
void startWork();
void startWorkAuto();
void doWork();
void setSelAuto();
void setSel();
void startWork();
void startWorkAuto();
void doWork();
void setSelAuto();
void setSel();
signals:
void workFinished();
void workStart();
void workStartAuto();
void workFinished();
void workStart();
void workStartAuto();
public:
qint64 DirFileSize(const QString& path);
void CleanImageFile(const QString& path, const qint64& delDays);
qint64 DirFileSize(const QString& path);
void CleanImageFile(const QString& path, const qint64& delDays);
private:
int delSelection;
int delSelection;
};

100
Cigarette/FtpManager.h
Unescape Escape View File

@ -13,63 +13,63 @@
class FtpManager
{
private:
QUrl url;
QNetworkAccessManager manager;
QUrl url;
QNetworkAccessManager manager;
public:
FtpManager() {
/* 设置通讯协议 */
url.setScheme("ftp");
/* 设置用户名 */
url.setUserName("FTP2");
/* 设置密码 */
url.setPassword("123");
/* 设置主机，也可以是域名 */
url.setHost("192.168.1.170");
/* 设置端口号，一般为21 */
url.setPort(666);
}
FtpManager() {
/* 设置通讯协议 */
url.setScheme("ftp");
/* 设置用户名 */
url.setUserName("FTP2");
/* 设置密码 */
url.setPassword("123");
/* 设置主机，也可以是域名 */
url.setHost("192.168.1.170");
/* 设置端口号，一般为21 */
url.setPort(666);
}
void uploadSingleFile(QString filePath, QString remotePath) {
void uploadSingleFile(QString filePath, QString remotePath) {
// 设置路径
url.setPath(remotePath);
qDebug() << "uploadSingleFile path " << url.path();
// 设置路径
url.setPath(remotePath);
qDebug() << "uploadSingleFile path " << url.path();
// 装载本地文件
QFile file(filePath);
bool isopen = false;
isopen = file.open(QIODevice::ReadOnly);
qDebug() << "Open file " << isopen;
if (isopen) {
// 读取本地文件数据
QByteArray data = file.readAll();
file.close();
// 装载本地文件
QFile file(filePath);
bool isopen = false;
isopen = file.open(QIODevice::ReadOnly);
qDebug() << "Open file " << isopen;
if (isopen) {
// 读取本地文件数据
QByteArray data = file.readAll();
file.close();
// 上传数据，上传成功后会在远端创建文件
manager.setNetworkAccessible(QNetworkAccessManager::Accessible);
QNetworkReply* reply = manager.put(QNetworkRequest(url), data);
// 上传数据，上传成功后会在远端创建文件
manager.setNetworkAccessible(QNetworkAccessManager::Accessible);
QNetworkReply* reply = manager.put(QNetworkRequest(url), data);
QEventLoop eventLoop;
//QObject::connect(reply, SIGNAL(finished()), &eventLoop, SLOT(quit()));
//// 进入等待，但事件循环依然进行 */
//eventLoop.exec();
QEventLoop eventLoop;
//QObject::connect(reply, SIGNAL(finished()), &eventLoop, SLOT(quit()));
//// 进入等待，但事件循环依然进行 */
//eventLoop.exec();
//QObject::connect(reply, &QNetworkReply::finished, [&]() {
// if (reply->error() == QNetworkReply::NoError) {
// // 读取响应数据
// QByteArray responseData = reply->readAll();
// // 处理响应数据
// qDebug() << "Received response:" << responseData;
// }
// else {
// // 处理错误
// qDebug() << "Error occurred:" << reply->errorString();
// }
//QObject::connect(reply, &QNetworkReply::finished, [&]() {
// if (reply->error() == QNetworkReply::NoError) {
// // 读取响应数据
// QByteArray responseData = reply->readAll();
// // 处理响应数据
// qDebug() << "Received response:" << responseData;
// }
// else {
// // 处理错误
// qDebug() << "Error occurred:" << reply->errorString();
// }
// // 清理资源
// reply->deleteLater();
// });
}
}
// // 清理资源
// reply->deleteLater();
// });
}
}
};

218
Cigarette/Logthread.cpp
Unescape Escape View File

@ -20,145 +20,145 @@ void CLog::setLogType(const CLog::CLOG_TYPE& level)
bool CLog::init(LogConfig& logConfig)
{
isRecord2File = logConfig.isRecord2File;
QString logDir = QString(PATH_LogPath);
if (createDir(logDir))
{
QString fileName = logDir + QDir::separator() + QDate::currentDate().toString("yyyy-MM-dd") + QString(Suffix);
QFileInfo fi(fileName);
if (fi.exists())
{
if (!localFile.exists())
{
localFile.setFileName(fileName);
if (localFile.open(QFile::WriteOnly | QFile::Append | QFile::Text))
{
isFileReady = true;
}
}
else
{
isFileReady = true;
}
}
else
{
localFile.setFileName(fileName);
if (localFile.open(QFile::WriteOnly | QFile::Append | QFile::Text))
{
isFileReady = true;
}
}
}
return isFileReady;
isRecord2File = logConfig.isRecord2File;
QString logDir = QString(PATH_LogPath);
if (createDir(logDir))
{
QString fileName = logDir + QDir::separator() + QDate::currentDate().toString("yyyy-MM-dd") + QString(Suffix);
QFileInfo fi(fileName);
if (fi.exists())
{
if (!localFile.exists())
{
localFile.setFileName(fileName);
if (localFile.open(QFile::WriteOnly | QFile::Append | QFile::Text))
{
isFileReady = true;
}
}
else
{
isFileReady = true;
}
}
else
{
localFile.setFileName(fileName);
if (localFile.open(QFile::WriteOnly | QFile::Append | QFile::Text))
{
isFileReady = true;
}
}
}
return isFileReady;
}
bool CLog::createDir(QString dirPath)
{
QFileInfo fileInfo(dirPath);
if (!fileInfo.exists())
{
QDir tmpDir;
return tmpDir.mkpath(dirPath);
}
return true;
QFileInfo fileInfo(dirPath);
if (!fileInfo.exists())
{
QDir tmpDir;
return tmpDir.mkpath(dirPath);
}
return true;
}
void CLog::log(CLOG_TYPE nType, const char* fileDesc, const char* functionDesc, int lineNum, const char* data, ...)
{
QMutexLocker locker(&mutexLog);
if (isFileReady)
{
QString recordInfo = QString("[%1]").arg(QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss:zzz"));
recordInfo.append(getTypeDesc(nType));
QMutexLocker locker(&mutexLog);
if (isFileReady)
{
QString recordInfo = QString("[%1]").arg(QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss:zzz"));
recordInfo.append(getTypeDesc(nType));
#ifndef QT_NO_DEBUG
recordInfo.append(QString("[%1:%2:%3]").arg(fileDesc).arg(functionDesc).arg(lineNum));
recordInfo.append(QString("[%1:%2:%3]").arg(fileDesc).arg(functionDesc).arg(lineNum));
#endif
va_list vlist;
va_start(vlist, data);
va_list vlist;
va_start(vlist, data);
QByteArray byteArray;
QByteArray byteArray;
#if defined(Q_OS_WIN)
int recordLen = _vscprintf(data, vlist);
byteArray.resize(recordLen);
int recordLen = _vscprintf(data, vlist);
byteArray.resize(recordLen);
#else
byteArray.resize(1024);
byteArray.resize(1024);
#endif
vsprintf(byteArray.data(), data, vlist);
recordInfo.append(byteArray);
va_end(vlist);
recordInfo.append("\n");
if (isRecord2File) {
localFile.write(recordInfo.toLocal8Bit().data(), recordInfo.toLocal8Bit().length());
localFile.flush();
}
else {
// qDebug()<<recordInfo;
}
}
vsprintf(byteArray.data(), data, vlist);
recordInfo.append(byteArray);
va_end(vlist);
recordInfo.append("\n");
if (isRecord2File) {
localFile.write(recordInfo.toLocal8Bit().data(), recordInfo.toLocal8Bit().length());
localFile.flush();
}
else {
// qDebug()<<recordInfo;
}
}
}
void CLog::log(CLOG_TYPE nType, const char* data, ...)
{
QMutexLocker locker(&mutexLog);
if (isFileReady)
{
QString recordInfo = QString("[%1]").arg(QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss:zzz"));
recordInfo.append(getTypeDesc(nType));
recordInfo.append(" ");
QMutexLocker locker(&mutexLog);
if (isFileReady)
{
QString recordInfo = QString("[%1]").arg(QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss:zzz"));
recordInfo.append(getTypeDesc(nType));
recordInfo.append(" ");
va_list vlist;
va_start(vlist, data);
va_list vlist;
va_start(vlist, data);
QByteArray byteArray;
QByteArray byteArray;
#if defined(Q_OS_WIN)
int recordLen = _vscprintf(data, vlist);
byteArray.resize(recordLen);
int recordLen = _vscprintf(data, vlist);
byteArray.resize(recordLen);
#else
byteArray.resize(1024);
byteArray.resize(1024);
#endif
vsprintf(byteArray.data(), data, vlist);
recordInfo.append(byteArray);
va_end(vlist);
recordInfo.append("\n");
if (isRecord2File) {
localFile.write(recordInfo.toLocal8Bit().data(), recordInfo.toLocal8Bit().length());
localFile.flush();
}
else {
// qDebug()<<recordInfo;
}
}
vsprintf(byteArray.data(), data, vlist);
recordInfo.append(byteArray);
va_end(vlist);
recordInfo.append("\n");
if (isRecord2File) {
localFile.write(recordInfo.toLocal8Bit().data(), recordInfo.toLocal8Bit().length());
localFile.flush();
}
else {
// qDebug()<<recordInfo;
}
}
}
QString CLog::getTypeDesc(CLog::CLOG_TYPE type)
{
/*
switch (type)
{
case CLOG_TYPE::STARTAPP:
return "[INFO]";
case CLOG_TYPE::STARTWORK:
return "[WARNING]";
case CLOG_TYPE::PAUSEWORK:
return "[ERROR]";
}
*/
return "[INFO]";
/*
switch (type)
{
case CLOG_TYPE::STARTAPP:
return "[INFO]";
case CLOG_TYPE::STARTWORK:
return "[WARNING]";
case CLOG_TYPE::PAUSEWORK:
return "[ERROR]";
}
*/
return "[INFO]";
}
void CLog::recMegFromCigarette(QString str)
{
CLog::LogConfig logConfig;
logConfig.isRecord2File = true;
logConfig.level = 0;
CLog::init(logConfig);
//qDebug() << GetCurrentThreadId() << "WinAPI";
CLOG_INFO(str.toStdString().c_str());
CLog::LogConfig logConfig;
logConfig.isRecord2File = true;
logConfig.level = 0;
CLog::init(logConfig);
//qDebug() << GetCurrentThreadId() << "WinAPI";
CLOG_INFO(str.toStdString().c_str());
}

72
Cigarette/Logthread.h
Unescape Escape View File

@ -2,54 +2,54 @@
#include <QDialog>
class CLog : public QObject
{
Q_OBJECT
Q_OBJECT
public:
enum CLOG_TYPE
{
enum CLOG_TYPE
{
STARTAPP,
STARTWORK,
PAUSEWORK,
UNLOCK,
DEBUGMODE,
UNKICKMODE,
SETTING,
CLEANPIC,
DOUBLECLICK,
ROTATEPIC,
PLCSETTING,
ALARM
};
//Q_DECLARE_FLAGS(CLOG_TYPE_Flags, CLOG_TYPE)
Q_ENUM(CLOG_TYPE)
STARTAPP,
STARTWORK,
PAUSEWORK,
UNLOCK,
DEBUGMODE,
UNKICKMODE,
SETTING,
CLEANPIC,
DOUBLECLICK,
ROTATEPIC,
PLCSETTING,
ALARM
};
//Q_DECLARE_FLAGS(CLOG_TYPE_Flags, CLOG_TYPE)
Q_ENUM(CLOG_TYPE)
struct LogConfig
{
bool isRecord2File;
int level;
};
struct LogConfig
{
bool isRecord2File;
int level;
};
CLog();
CLog();
void setLogType(const CLog::CLOG_TYPE& type);
// CLog::CLOG_TYPE getLogType() { return logType; }
void setLogType(const CLog::CLOG_TYPE& type);
// CLog::CLOG_TYPE getLogType() { return logType; }
//void startClog();
//void doWork();
static bool init(CLog::LogConfig& logConfig);
static bool createDir(QString dirPath);
static void log(CLOG_TYPE nType, const char* fileDesc, const char* functionDesc, int lineNum, const char* data, ...);
static void log(CLOG_TYPE nType, const char* data, ...);
//void startClog();
//void doWork();
static bool init(CLog::LogConfig& logConfig);
static bool createDir(QString dirPath);
static void log(CLOG_TYPE nType, const char* fileDesc, const char* functionDesc, int lineNum, const char* data, ...);
static void log(CLOG_TYPE nType, const char* data, ...);
public slots:
void recMegFromCigarette(QString);
void recMegFromCigarette(QString);
private:
static QString getTypeDesc(CLOG_TYPE type);
static QString getTypeDesc(CLOG_TYPE type);
private:
static bool isRecord2File;
static bool isFileReady;
static bool isRecord2File;
static bool isFileReady;
};
#ifdef Q_OS_WIN

154
Cigarette/PLC/PLCDevice.cpp
Unescape Escape View File

@ -7,104 +7,104 @@
extern SysConf g_sys_conf;
modbus_t * g_modbus = NULL; //Modbus TCP
modbus_t* g_modbus = NULL; //Modbus TCP
bool PLCDevice::init_plc(PLCDevice* PLCptr)
{
// modbus_connect() 建立连接，成功返回0，错误返回-1
// modbus_new_rtu 生成RTU的连接，建立成功则返回指向modbus_t结构的指针，否则将返回NULL/0
// modbus_connect() 建立连接，成功返回0，错误返回-1
// modbus_new_rtu 生成RTU的连接，建立成功则返回指向modbus_t结构的指针，否则将返回NULL/0
const char* comport = g_sys_conf.ComPort.data();
qDebug() << "COM:" << comport;
//连接PLC
g_modbus = modbus_new_rtu(comport, 9600, 'N', 8, 1);
modbus_set_debug(g_modbus, 0); // 用flag设置debug调试标志位，flag=1时显示modbus消息的字节
modbus_set_response_timeout(g_modbus, 1, 0); // 设置响应超时
modbus_connect(g_modbus);
modbus_set_slave(g_modbus, 1); // 设置从站id
const char* comport = g_sys_conf.ComPort.data();
qDebug() << "COM:" << comport;
//连接PLC
g_modbus = modbus_new_rtu(comport, 9600, 'N', 8, 1);
modbus_set_debug(g_modbus, 0); // 用flag设置debug调试标志位，flag=1时显示modbus消息的字节
modbus_set_response_timeout(g_modbus, 1, 0); // 设置响应超时
modbus_connect(g_modbus);
modbus_set_slave(g_modbus, 1); // 设置从站id
uint8_t data;
int ret = modbus_read_bits(g_modbus, 30000, 1, &data);
if (g_modbus && ret == -1) {
PLCptr->g_plc_ok = false;
}
else {
uint8_t data;
int ret = modbus_read_bits(g_modbus, 30000, 1, &data);
if (g_modbus && ret == -1) {
PLCptr->g_plc_ok = false;
}
else {
PLCptr->g_plc_ok = true;
}
return true;
PLCptr->g_plc_ok = true;
}
return true;
}
bool PLCDevice::disconnect_plc(void)
{
if(g_modbus)
{
modbus_close(g_modbus);
modbus_free(g_modbus);
}
return true;
if (g_modbus)
{
modbus_close(g_modbus);
modbus_free(g_modbus);
}
return true;
}
int PLCDevice::write_bit_2_plc(int addr, int value)
{
if (g_plc_ok)
{
g_mutex.lock();
int ret = modbus_write_bit(g_modbus, addr, value);
g_mutex.unlock();
//printf("modbus_write_bit:addr=%d,value=%d,ret=%d\n", addr, value, ret);
return ret;
}
else {
//std::cout << "PLC no ok" << std::endl;
return false;
}
if (g_plc_ok)
{
g_mutex.lock();
int ret = modbus_write_bit(g_modbus, addr, value);
g_mutex.unlock();
//printf("modbus_write_bit:addr=%d,value=%d,ret=%d\n", addr, value, ret);
return ret;
}
else {
//std::cout << "PLC no ok" << std::endl;
return false;
}
}
int PLCDevice::read_bits_from_plc(int addr, int nb,uint8_t* value)
int PLCDevice::read_bits_from_plc(int addr, int nb, uint8_t* value)
{
if (g_plc_ok)
{
g_mutex.lock();
int ret = modbus_read_bits(g_modbus, addr, nb ,value);
g_mutex.unlock();
//printf("modbus_read_bits:addr=%d,nb=%d,value=%d,ret=%d\n", addr, nb, *value, ret);
return ret;
}
else {
//std::cout << "PLC no ok" << std::endl;
return false;
}
if (g_plc_ok)
{
g_mutex.lock();
int ret = modbus_read_bits(g_modbus, addr, nb, value);
g_mutex.unlock();
//printf("modbus_read_bits:addr=%d,nb=%d,value=%d,ret=%d\n", addr, nb, *value, ret);
return ret;
}
else {
//std::cout << "PLC no ok" << std::endl;
return false;
}
}
int PLCDevice::write_short_2_plc(int addr, int nb, uint16_t *value)
int PLCDevice::write_short_2_plc(int addr, int nb, uint16_t* value)
{
if (g_plc_ok)
{
g_mutex.lock();
int ret = modbus_write_registers(g_modbus, addr, nb, value);
g_mutex.unlock();
//printf("modbus_write_registers:addr=%d,nb=%d,value=%d,ret=%d\n", addr, nb, *value, ret);
return ret;
}
else {
//std::cout << "PLC no ok" << std::endl;
return false;
}
if (g_plc_ok)
{
g_mutex.lock();
int ret = modbus_write_registers(g_modbus, addr, nb, value);
g_mutex.unlock();
//printf("modbus_write_registers:addr=%d,nb=%d,value=%d,ret=%d\n", addr, nb, *value, ret);
return ret;
}
else {
//std::cout << "PLC no ok" << std::endl;
return false;
}
}
int PLCDevice::read_short_from_plc(int addr, int nb, uint16_t *value)
int PLCDevice::read_short_from_plc(int addr, int nb, uint16_t* value)
{
if (g_plc_ok)
{
g_mutex.lock();
int ret = modbus_read_registers(g_modbus, addr, nb, value);
g_mutex.unlock();
//printf("modbus_read_registers:addr=%d,nb=%d,value=%d,ret=%d\n", addr, nb, *value ,ret);
return ret;
}
else {
//std::cout << "PLC no ok" << std::endl;
return false;
}
if (g_plc_ok)
{
g_mutex.lock();
int ret = modbus_read_registers(g_modbus, addr, nb, value);
g_mutex.unlock();
//printf("modbus_read_registers:addr=%d,nb=%d,value=%d,ret=%d\n", addr, nb, *value ,ret);
return ret;
}
else {
//std::cout << "PLC no ok" << std::endl;
return false;
}
}

12
Cigarette/PLC/PLCDevice.h
Unescape Escape View File

@ -3,18 +3,18 @@
class PLCDevice
{
public:
QMutex g_mutex; //访问Modbus的互斥锁
QMutex g_mutex; //访问Modbus的互斥锁
bool g_plc_ok;
//[0]:1=连接,0=断开
uint8_t g_plc_status;
static bool init_plc(PLCDevice *PLCptr);
static bool init_plc(PLCDevice* PLCptr);
int write_bit_2_plc(int addr, int value);
int read_bits_from_plc(int addr, int nb, uint8_t* value);
int write_short_2_plc(int addr, int nb, uint16_t *value);
int read_short_from_plc(int addr, int nb, uint16_t *value);
int write_bit_2_plc(int addr, int value);
int read_bits_from_plc(int addr, int nb, uint8_t* value);
int write_short_2_plc(int addr, int nb, uint16_t* value);
int read_short_from_plc(int addr, int nb, uint16_t* value);
bool disconnect_plc(void);
};

78
Cigarette/SyncQueue.h
Unescape Escape View File

@ -9,22 +9,22 @@ using namespace std;
template<class T> class SyncQueue
{
public:
SyncQueue(int max_size);
~SyncQueue();
void put(const T& val);
void take(T& val);
void clear();
bool isEmpty();
bool isFull();
int count();
SyncQueue(int max_size);
~SyncQueue();
void put(const T& val);
void take(T& val);
void clear();
bool isEmpty();
bool isFull();
int count();
public:
string name;
string name;
private:
mutex lock;
condition_variable_any cv_full, cv_empty;
list<T> q;
int size;
int max_size;
mutex lock;
condition_variable_any cv_full, cv_empty;
list<T> q;
int size;
int max_size;
};
using namespace std;
@ -42,54 +42,54 @@ SyncQueue<T>::~SyncQueue()
template<class T>
void SyncQueue<T>::put(const T& val)
{
lock_guard<mutex> locker(lock);
while (isFull())
{
//cout << "\nQueue " << name << " is full now, wait a minute!" << endl;
cv_full.wait(lock);
}
q.emplace_back(val);
cv_empty.notify_one();
//cout << " Put image success " << endl;
lock_guard<mutex> locker(lock);
while (isFull())
{
//cout << "\nQueue " << name << " is full now, wait a minute!" << endl;
cv_full.wait(lock);
}
q.emplace_back(val);
cv_empty.notify_one();
//cout << " Put image success " << endl;
}
template<class T>
void SyncQueue<T>::take(T& val)
{
lock_guard<mutex> locker(lock);
while (isEmpty())
{
//cout << "\nQueue "<< name << " is empty now, wait a minute!" << endl;
cv_empty.wait(lock);
}
val = q.front();
q.pop_front();
cv_full.notify_one();
//cout << " Take image success "<< endl;
lock_guard<mutex> locker(lock);
while (isEmpty())
{
//cout << "\nQueue "<< name << " is empty now, wait a minute!" << endl;
cv_empty.wait(lock);
}
val = q.front();
q.pop_front();
cv_full.notify_one();
//cout << " Take image success "<< endl;
}
template<class T>
void SyncQueue<T>::clear()
{
lock_guard<mutex> locker(lock);
q.clear();
lock_guard<mutex> locker(lock);
q.clear();
}
template<class T>
bool SyncQueue<T>::isEmpty()
{
return q.size() == 0;
return q.size() == 0;
}
template<class T>
bool SyncQueue<T>::isFull()
{
return q.size() == max_size;
return q.size() == max_size;
}
template<class T>
int SyncQueue<T>::count()
{
lock_guard<mutex> locker(lock);
return q.size();
lock_guard<mutex> locker(lock);
return q.size();
}

54
Cigarette/alarmdialog.cpp
Unescape Escape View File

@ -3,26 +3,26 @@
extern std::vector<AlarmInfo> g_vec_alarm;
AlarmDialog::AlarmDialog(QWidget * parent) : QDialog(parent) {
ui.setupUi(this);
this->setWindowFlags(Qt::FramelessWindowHint);
ui.tableWidget->setColumnCount(4);
ui.tableWidget->setRowCount(g_vec_alarm.size());
QStringList header_list;
header_list << QStringLiteral("报警开始时间") << QStringLiteral("报警处理时间")
<< QStringLiteral("报警信息") << QStringLiteral("报警代码");
ui.tableWidget->setHorizontalHeaderLabels(header_list);
ui.tableWidget->setColumnWidth(0, 140);
ui.tableWidget->setColumnWidth(1, 140);
ui.tableWidget->setColumnWidth(2, 380);
ui.tableWidget->setColumnWidth(3, 120);
for (int i = 0; i < g_vec_alarm.size(); i++)
{
ui.tableWidget->setItem(i, 0, new QTableWidgetItem(QString(g_vec_alarm[i].alarm_start.c_str())));
ui.tableWidget->setItem(i, 1, new QTableWidgetItem(QString(g_vec_alarm[i].alarm_handle.c_str())));
ui.tableWidget->setItem(i, 2, new QTableWidgetItem(QString(g_vec_alarm[i].alarm_msg.c_str())));
ui.tableWidget->setItem(i, 3, new QTableWidgetItem(QString::number(g_vec_alarm[i].alarm_code)));
}
AlarmDialog::AlarmDialog(QWidget* parent) : QDialog(parent) {
ui.setupUi(this);
this->setWindowFlags(Qt::FramelessWindowHint);
ui.tableWidget->setColumnCount(4);
ui.tableWidget->setRowCount(g_vec_alarm.size());
QStringList header_list;
header_list << QStringLiteral("报警开始时间") << QStringLiteral("报警处理时间")
<< QStringLiteral("报警信息") << QStringLiteral("报警代码");
ui.tableWidget->setHorizontalHeaderLabels(header_list);
ui.tableWidget->setColumnWidth(0, 140);
ui.tableWidget->setColumnWidth(1, 140);
ui.tableWidget->setColumnWidth(2, 380);
ui.tableWidget->setColumnWidth(3, 120);
for (int i = 0; i < g_vec_alarm.size(); i++)
{
ui.tableWidget->setItem(i, 0, new QTableWidgetItem(QString(g_vec_alarm[i].alarm_start.c_str())));
ui.tableWidget->setItem(i, 1, new QTableWidgetItem(QString(g_vec_alarm[i].alarm_handle.c_str())));
ui.tableWidget->setItem(i, 2, new QTableWidgetItem(QString(g_vec_alarm[i].alarm_msg.c_str())));
ui.tableWidget->setItem(i, 3, new QTableWidgetItem(QString::number(g_vec_alarm[i].alarm_code)));
}
}
AlarmDialog::~AlarmDialog() {
@ -31,15 +31,15 @@ AlarmDialog::~AlarmDialog() {
void AlarmDialog::on_pushButton_close_released()
{
this->close();
this->close();
}
void AlarmDialog::on_pushButton_clear_released()
{
int rowNum = ui.tableWidget->rowCount();
for (int i = rowNum - 1; i >= 0; i--)
{
ui.tableWidget->removeRow(i);
}
g_vec_alarm.clear();
int rowNum = ui.tableWidget->rowCount();
for (int i = rowNum - 1; i >= 0; i--)
{
ui.tableWidget->removeRow(i);
}
g_vec_alarm.clear();
}

14
Cigarette/alarmdialog.hpp
Unescape Escape View File

@ -1,18 +1,18 @@
#pragma once
#pragma once
#include <QDialog>
#include "ui_alarmdialog.h"
class AlarmDialog : public QDialog {
Q_OBJECT
Q_OBJECT
public:
AlarmDialog(QWidget * parent = Q_NULLPTR);
~AlarmDialog();
AlarmDialog(QWidget* parent = Q_NULLPTR);
~AlarmDialog();
private slots:
void on_pushButton_close_released();
void on_pushButton_clear_released();
void on_pushButton_close_released();
void on_pushButton_clear_released();
private:
Ui::AlarmDialog ui;
Ui::AlarmDialog ui;
};

230
Cigarette/alg_jd.cpp
Unescape Escape View File

@ -1,10 +1,10 @@
#include "alg_jd.h"
#include <direct.h> //所需的库文件
#include <direct.h> //所需的库文件
extern SysConf g_sys_conf;
// Initialize the parameters
static float confThreshold = g_sys_conf.ConfThreshold*0.01; // Confidence threshold
static float confThreshold = g_sys_conf.ConfThreshold * 0.01; // Confidence threshold
static float nmsThreshold = 0.4; // Non-maximum suppression threshold
static int inpWidth = 416; // Width of network's input image
static int inpHeight = 416; // Height of network's input image
@ -20,7 +20,7 @@ bool AlgJd::init(QString model_path, QString model_name)
QString image_path;
if (model_path.length() > 0 && model_name.length() > 0) {
// 拼凑的模型文件路径
// 拼凑的模型文件路径
modelWeights = model_path.toStdString() + "/" + model_name.toStdString();
modelConfiguration = model_path.toStdString() + "/jd.cfg";
classesFile = model_path.toStdString() + "/jd.names";
@ -41,8 +41,8 @@ bool AlgJd::init(QString model_path, QString model_name)
while (std::getline(classNamesFile, className))
classes.push_back(className);
}
else{
return false;
else {
return false;
}
// Load the network
@ -51,7 +51,7 @@ bool AlgJd::init(QString model_path, QString model_name)
net.setPreferableBackend(cv::dnn::DNN_BACKEND_CUDA);
net.setPreferableTarget(cv::dnn::DNN_TARGET_CUDA);
//cv::Mat image = cv::imread("alg_jd.bmp");
//cv::Mat image = cv::imread("alg_jd.bmp");
cv::Mat image = cv::imread(image_path.toStdString());
/*if (g_sys_conf.model_jpg_path.length() > 0) {
image = cv::imread(g_sys_conf.model_jpg_path.toStdString());
@ -60,23 +60,23 @@ bool AlgJd::init(QString model_path, QString model_name)
image = cv::imread("D:/Release/alg_jd.bmp");
}*/
//识别一张图，测试模型是否正确，并且完成GPU数据加载
if (!image.data) return false; //判断测试图片是否正常读取
std::vector<std::pair<int, cv::Rect> > results;
detect(image, image, results);
if (results.size() > 0)
return true; //检测到目标，则初始化成功
else
return false; //否则初始化失败
//识别一张图，测试模型是否正确，并且完成GPU数据加载
if (!image.data) return false; //判断测试图片是否正常读取
std::vector<std::pair<int, cv::Rect> > results;
detect(image, image, results);
if (results.size() > 0)
return true; //检测到目标，则初始化成功
else
return false; //否则初始化失败
}
bool AlgJd::test_detect()
{
cv::Mat m1;
m1 = cv::Mat(544, 728, CV_8UC3, cv::Scalar(0, 0, 0));
std::vector<std::pair<int, cv::Rect> > results;
std::vector<std::pair<int, cv::Rect> > results;
double t = (double)cv::getTickCount();
detect(m1, m1, results);
detect(m1, m1, results);
t = ((double)cv::getTickCount() - t) / cv::getTickFrequency();
DEBUG(" test_detect time process:%f\n", t);
return true;
@ -95,33 +95,33 @@ bool AlgJd::test_detect_batcht(int shoot)
m4 = cv::Mat(544, 728, CV_8UC3, cv::Scalar(0, 0, 0));
double t = (double)cv::getTickCount();
switch(shoot){
case 1:{
std::vector<std::pair<int, cv::Rect> > results;
detect(m1, m1, results);
break;
}
case 3:vec_in.push_back(m3);
case 2:vec_in.push_back(m2);
case 4:vec_in.push_back(m4);
default:{
vec_in.push_back(m1);
detect_batch(vec_in, vec_out, vec_results);
}
switch (shoot) {
case 1: {
std::vector<std::pair<int, cv::Rect> > results;
detect(m1, m1, results);
break;
}
case 3:vec_in.push_back(m3);
case 2:vec_in.push_back(m2);
case 4:vec_in.push_back(m4);
default: {
vec_in.push_back(m1);
detect_batch(vec_in, vec_out, vec_results);
}
}
t = ((double)cv::getTickCount() - t) / cv::getTickFrequency();
DEBUG(" test_detect_batcht time process:%f\n", t);
return true;
}
int AlgJd::detect(cv::Mat& _frame, cv::Mat &out, std::vector<std::pair<int, cv::Rect> > &results)
int AlgJd::detect(cv::Mat& _frame, cv::Mat& out, std::vector<std::pair<int, cv::Rect> >& results)
{
cv::Mat frame = _frame.clone();
cv::Mat image_clone=frame.clone();
cv::Mat image_clone = frame.clone();
// Process frames.
// Create a 4D blob from a frame.
cv::Mat blob;
cv::dnn::blobFromImage(frame, blob, 1/255.0, cv::Size(inpWidth, inpHeight), cv::Scalar(0,0,0), true, false);
cv::dnn::blobFromImage(frame, blob, 1 / 255.0, cv::Size(inpWidth, inpHeight), cv::Scalar(0, 0, 0), true, false);
//Sets the input to the network
net.setInput(blob);
@ -140,8 +140,8 @@ int AlgJd::detect(cv::Mat& _frame, cv::Mat &out, std::vector<std::pair<int, cv::
cv::Mat detectedFrame;
frame.convertTo(detectedFrame, CV_8U);
//show detectedFrame
out=detectedFrame.clone();
return results.size();
out = detectedFrame.clone();
return results.size();
}
void AlgJd::analyse(cv::Mat vec_in, std::vector<std::pair<int, cv::Rect> >& vec_results)
@ -173,12 +173,12 @@ std::vector<cv::String> AlgJd::getOutputsNames(const cv::dnn::Net& net)
// Get the names of the output layers in names
names.resize(outLayers.size());
for (size_t i = 0; i < outLayers.size(); ++i)
names[i] = layersNames[outLayers[i] - 1];
names[i] = layersNames[outLayers[i] - 1];
}
return names;
}
void AlgJd::post_process(cv::Mat& frame, std::vector<cv::Mat>& outs, std::vector<std::pair<int, cv::Rect> > &results)
void AlgJd::post_process(cv::Mat& frame, std::vector<cv::Mat>& outs, std::vector<std::pair<int, cv::Rect> >& results)
{
std::vector < std::vector<int>> classIds(classes.size());
std::vector < std::vector<float>> confidences(classes.size());
@ -235,18 +235,18 @@ void AlgJd::post_process(cv::Mat& frame, std::vector<cv::Mat>& outs, std::vector
// Draw the predicted bounding box
void AlgJd::drawPred(int classId, float conf, int left, int top, int right, int bottom, cv::Mat& frame)
{
cv::Scalar color;
if(classId==0)
color = cv::Scalar(0,255,0);
else if(classId == 1)
color = cv::Scalar(255,0,0);
else
color = cv::Scalar(0, 255, 0);
cv::Scalar color;
if (classId == 0)
color = cv::Scalar(0, 255, 0);
else if (classId == 1)
color = cv::Scalar(255, 0, 0);
else
color = cv::Scalar(0, 255, 0);
//Draw a rectangle displaying the bounding box
cv::rectangle(frame, cv::Point(left, top), cv::Point(right, bottom), color, 4);
//Get the label for the class name and its confidence
std::string label = cv::format("%.2f%%", (conf*100));///
std::string label = cv::format("%.2f%%", (conf * 100));///
if (!classes.empty())
{
CV_Assert(classId < (int)classes.size());
@ -254,98 +254,98 @@ void AlgJd::drawPred(int classId, float conf, int left, int top, int right, int
}
else
{
std::cout<<"classes is empty..."<<std::endl;
std::cout << "classes is empty..." << std::endl;
}
//Display the label at the top of the bounding box
int baseLine;
cv::Size labelSize = cv::getTextSize(label, cv::FONT_HERSHEY_SIMPLEX, 1, 1, &baseLine);
top = std::max(top, labelSize.height);
cv::putText(frame, label, cv::Point(left, top-5), cv::FONT_HERSHEY_SIMPLEX, 0.8, color, 1);
cv::putText(frame, label, cv::Point(left, top - 5), cv::FONT_HERSHEY_SIMPLEX, 0.8, color, 1);
}
void AlgJd::detect_batch(std::vector<cv::Mat>& vec_in, std::vector<cv::Mat> &vec_out, std::vector<std::vector<std::pair<int, cv::Rect> > > &vec_results)
void AlgJd::detect_batch(std::vector<cv::Mat>& vec_in, std::vector<cv::Mat>& vec_out, std::vector<std::vector<std::pair<int, cv::Rect> > >& vec_results)
{
cv::Mat blobs;
cv::Mat blobs;
std::vector<cv::Mat> image;
cv::dnn::blobFromImages(vec_in, blobs, 1 / 255.0, cv::Size(inpWidth, inpHeight), cv::Scalar(0, 0, 0), true, false);
cv::dnn::blobFromImages(vec_in, blobs, 1 / 255.0, cv::Size(inpWidth, inpHeight), cv::Scalar(0, 0, 0), true, false);
//Sets the input to the network
net.setInput(blobs);
//Sets the input to the network
net.setInput(blobs);
// Runs the forward pass to get output of the output layers
std::vector<cv::Mat> outs;
net.forward(outs, getOutputsNames(net));
// Runs the forward pass to get output of the output layers
std::vector<cv::Mat> outs;
net.forward(outs, getOutputsNames(net));
for (int i = 0; i < vec_in.size(); i++)
{
image.push_back(vec_in[i].clone());
}
for (int i = 0; i < vec_in.size(); i++)
{
image.push_back(vec_in[i].clone());
}
// Remove the bounding boxes with low confidence
post_process_batch(image, outs, vec_results);
// Remove the bounding boxes with low confidence
post_process_batch(image, outs, vec_results);
// Write the frame with the detection boxes
for (int i = 0; i < vec_in.size(); i++)
{
cv::Mat detectedFrame, out;
image[i].convertTo(detectedFrame, CV_8U);
out = detectedFrame.clone();
vec_out.push_back(out);
}
// Write the frame with the detection boxes
for (int i = 0; i < vec_in.size(); i++)
{
cv::Mat detectedFrame, out;
image[i].convertTo(detectedFrame, CV_8U);
out = detectedFrame.clone();
vec_out.push_back(out);
}
}
void AlgJd::post_process_batch(std::vector<cv::Mat>& vec_frame, std::vector<cv::Mat>& outs, std::vector<std::vector<std::pair<int, cv::Rect> > > &vec_results)
void AlgJd::post_process_batch(std::vector<cv::Mat>& vec_frame, std::vector<cv::Mat>& outs, std::vector<std::vector<std::pair<int, cv::Rect> > >& vec_results)
{
int batch = vec_frame.size();
int batch = vec_frame.size();
double confidence;///
for (int k = 0; k < batch; k++)
{
for (int k = 0; k < batch; k++)
{
std::vector < std::vector<int>> classIds(classes.size());
std::vector < std::vector<float>> confidences(classes.size());
std::vector < std::vector<cv::Rect>> boxes(classes.size());
//std::cout << "outs.size()\t" << outs.size() << std::endl;
//std::cout << "Type\t" << outs[0].type() << std::endl;
for (size_t i = 0; i < outs.size(); ++i)
{
//std::cout << "outs.dims\t" << outs[i].dims << std::endl;
//std::cout << "outs[" << i << "].rows\t" << outs[i].size[0] << std::endl;
//std::cout << "outs[" << i << "].cols\t" << outs[i].size[1] << std::endl;
//std::cout << "outs[" << i << "].cols\t" << outs[i].size[2] << std::endl;
// Scan through all the bounding boxes output from the network and keep only the
// ones with high confidence scores. Assign the box's class label as the class
//
cv::Mat m0(outs[i].size[1], outs[i].size[2], CV_32F, outs[i].data + outs[i].step[0] * k);
// with the highest score for the box.
float* data = (float*)m0.data;
for (int j = 0; j < m0.rows; ++j, data += m0.cols)
{
cv::Mat scores = m0.row(j).colRange(5, m0.cols);
cv::Point classIdPoint;
//double confidence;
// Get the value and location of the maximum score
cv::minMaxLoc(scores, 0, &confidence, 0, &classIdPoint);
if (confidence > confThreshold)
{
int centerX = (int)(data[0] * vec_frame[k].cols);
int centerY = (int)(data[1] * vec_frame[k].rows);
int width = (int)(data[2] * vec_frame[k].cols);
int height = (int)(data[3] * vec_frame[k].rows);
int left = centerX - width / 2;
int top = centerY - height / 2;
classIds[classIdPoint.x].push_back(classIdPoint.x);
confidences[classIdPoint.x].push_back((float)confidence);
boxes[classIdPoint.x].push_back(cv::Rect(left, top, width, height));
}
}
}
std::vector<std::pair<int, cv::Rect> > results;
//std::cout << "Type\t" << outs[0].type() << std::endl;
for (size_t i = 0; i < outs.size(); ++i)
{
//std::cout << "outs.dims\t" << outs[i].dims << std::endl;
//std::cout << "outs[" << i << "].rows\t" << outs[i].size[0] << std::endl;
//std::cout << "outs[" << i << "].cols\t" << outs[i].size[1] << std::endl;
//std::cout << "outs[" << i << "].cols\t" << outs[i].size[2] << std::endl;
// Scan through all the bounding boxes output from the network and keep only the
// ones with high confidence scores. Assign the box's class label as the class
//
cv::Mat m0(outs[i].size[1], outs[i].size[2], CV_32F, outs[i].data + outs[i].step[0] * k);
// with the highest score for the box.
float* data = (float*)m0.data;
for (int j = 0; j < m0.rows; ++j, data += m0.cols)
{
cv::Mat scores = m0.row(j).colRange(5, m0.cols);
cv::Point classIdPoint;
//double confidence;
// Get the value and location of the maximum score
cv::minMaxLoc(scores, 0, &confidence, 0, &classIdPoint);
if (confidence > confThreshold)
{
int centerX = (int)(data[0] * vec_frame[k].cols);
int centerY = (int)(data[1] * vec_frame[k].rows);
int width = (int)(data[2] * vec_frame[k].cols);
int height = (int)(data[3] * vec_frame[k].rows);
int left = centerX - width / 2;
int top = centerY - height / 2;
classIds[classIdPoint.x].push_back(classIdPoint.x);
confidences[classIdPoint.x].push_back((float)confidence);
boxes[classIdPoint.x].push_back(cv::Rect(left, top, width, height));
}
}
}
std::vector<std::pair<int, cv::Rect> > results;
// Perform non maximum suppression to eliminate redundant overlapping boxes with
// lower confidences
for (size_t i = 0; i < classes.size(); ++i)
@ -356,17 +356,17 @@ void AlgJd::post_process_batch(std::vector<cv::Mat>& vec_frame, std::vector<cv::
{
int idx = indices[j];
cv::Rect box = boxes[i][idx];
if (confidences[i][idx] > g_sys_conf.ConfThreshold * 0.01)///识别度低于阈值NG处理
if (confidences[i][idx] > g_sys_conf.ConfThreshold * 0.01)///识别度低于阈值NG处理
{
if (box.width > 15)
{//识别框宽度大于15显示识别，小于认为无胶点，NG处理
{//识别框宽度大于15显示识别，小于认为无胶点，NG处理
drawPred(classIds[i][idx], confidences[i][idx], box.x, box.y,
box.x + box.width, box.y + box.height, vec_frame[k]);
results.push_back(std::make_pair(classIds[i][idx], box));
}
}
}
}
vec_results.push_back(results);
}
}
vec_results.push_back(results);
}
}

38
Cigarette/alg_jd.h
Unescape Escape View File

@ -11,25 +11,25 @@
#include "common.h"
class AlgJd
{
public:
bool init(QString model_path, QString model_name);
bool test_detect();
bool test_detect_batcht(int shoot);
int detect(cv::Mat& in, cv::Mat &out, std::vector<std::pair<int, cv::Rect> > &results);
// Remove the bounding boxes with low confidence using non-maxima suppression
void post_process(cv::Mat& frame, std::vector<cv::Mat>& outs, std::vector<std::pair<int, cv::Rect> > &results);
void CircleImagePro(cv::Mat src, cv::Mat dst, std::vector<float> radius);
void detect_batch(std::vector<cv::Mat>& vec_in, std::vector<cv::Mat> &vec_out, std::vector<std::vector<std::pair<int, cv::Rect> > > &vec_results);
// Remove the bounding boxes with low confidence using non-maxima suppression
void post_process_batch(std::vector<cv::Mat>& vec_frame, std::vector<cv::Mat>& outs, std::vector<std::vector<std::pair<int, cv::Rect> > > &vec_results);
void analyse(cv::Mat vec_in, std::vector<std::pair<int, cv::Rect> > & vec_results);
// Get the names of the output layers
std::vector<cv::String> getOutputsNames(const cv::dnn::Net& net);
// Draw the predicted bounding box
void drawPred(int classId, float conf, int left, int top, int right, int bottom, cv::Mat& frame);
private:
cv::dnn::Net net;
std::vector<std::string> classes;
public:
bool init(QString model_path, QString model_name);
bool test_detect();
bool test_detect_batcht(int shoot);
int detect(cv::Mat& in, cv::Mat& out, std::vector<std::pair<int, cv::Rect> >& results);
// Remove the bounding boxes with low confidence using non-maxima suppression
void post_process(cv::Mat& frame, std::vector<cv::Mat>& outs, std::vector<std::pair<int, cv::Rect> >& results);
void CircleImagePro(cv::Mat src, cv::Mat dst, std::vector<float> radius);
void detect_batch(std::vector<cv::Mat>& vec_in, std::vector<cv::Mat>& vec_out, std::vector<std::vector<std::pair<int, cv::Rect> > >& vec_results);
// Remove the bounding boxes with low confidence using non-maxima suppression
void post_process_batch(std::vector<cv::Mat>& vec_frame, std::vector<cv::Mat>& outs, std::vector<std::vector<std::pair<int, cv::Rect> > >& vec_results);
void analyse(cv::Mat vec_in, std::vector<std::pair<int, cv::Rect> >& vec_results);
// Get the names of the output layers
std::vector<cv::String> getOutputsNames(const cv::dnn::Net& net);
// Draw the predicted bounding box
void drawPred(int classId, float conf, int left, int top, int right, int bottom, cv::Mat& frame);
private:
cv::dnn::Net net;
std::vector<std::string> classes;
};
#endif //end of _CIGARETTE_JD

4
Cigarette/balluffcamera.cpp
Unescape Escape View File

@ -3,7 +3,7 @@
#include <iostream>
#include <thread>
mvIMPACT::acquire::DeviceManager BalluffCamera:: devMgr;
mvIMPACT::acquire::DeviceManager BalluffCamera::devMgr;
bool BalluffCamera::license_pass = false;
BalluffCamera::BalluffCamera()
{
@ -18,5 +18,5 @@ BalluffCamera::~BalluffCamera()
int BalluffCamera::Enumerate()
{
return devMgr.deviceCount();
return devMgr.deviceCount();
}

12
Cigarette/balluffcamera.h
Unescape Escape View File

@ -6,15 +6,15 @@
#define BalluffClassID 0x01
class BalluffCamera: public BaseCamera
class BalluffCamera : public BaseCamera
{
public:
BalluffCamera();
~BalluffCamera();
BalluffCamera();
~BalluffCamera();
static int Enumerate();
static int Enumerate();
public:
static mvIMPACT::acquire::DeviceManager devMgr;
static bool license_pass;
static mvIMPACT::acquire::DeviceManager devMgr;
static bool license_pass;
};

18
Cigarette/basecamera.h
Unescape Escape View File

@ -8,20 +8,20 @@
#define ImageCap 2
typedef struct _SingleCamInfoStruct {
int unfiltered_num;
int filtered_num;
int CamClass;
int UserID;
bool Detect;
bool IsOpen;
bool OffLine;
int unfiltered_num;
int filtered_num;
int CamClass;
int UserID;
bool Detect;
bool IsOpen;
bool OffLine;
}SingleCamInfoStruct;
class BaseCamera
{
public:
BaseCamera();
~BaseCamera();
BaseCamera();
~BaseCamera();
public:
};

48
Cigarette/baslercamera.cpp
Unescape Escape View File

@ -13,33 +13,33 @@ BaslerCamera::BaslerCamera()
BaslerCamera::~BaslerCamera()
{
Pylon::PylonTerminate();
Pylon::PylonTerminate();
}
int BaslerCamera::Enumerate()
{
int n_basler_cam = 0;
// Before using any pylon methods, the pylon runtime must be initialized.
Pylon::PylonInitialize();
try
{
// Get the transport layer factory.
Pylon::CTlFactory& tlFactory = Pylon::CTlFactory::GetInstance();
// Get all attached devices and exit application if no device is found.
if (tlFactory.EnumerateDevices(devices) == 0)
{
return 0;
}
n_basler_cam = min(devices.size(), c_maxCamerasToUse);
}
catch (const Pylon::GenericException& e)
{
// Error handling
cerr << "An exception occurred." << endl
<< e.GetDescription() << endl;
}
return n_basler_cam;
int n_basler_cam = 0;
// Before using any pylon methods, the pylon runtime must be initialized.
Pylon::PylonInitialize();
try
{
// Get the transport layer factory.
Pylon::CTlFactory& tlFactory = Pylon::CTlFactory::GetInstance();
// Get all attached devices and exit application if no device is found.
if (tlFactory.EnumerateDevices(devices) == 0)
{
return 0;
}
n_basler_cam = min(devices.size(), c_maxCamerasToUse);
}
catch (const Pylon::GenericException& e)
{
// Error handling
cerr << "An exception occurred." << endl
<< e.GetDescription() << endl;
}
return n_basler_cam;
}

22
Cigarette/baslercamera.h
Unescape Escape View File

@ -12,21 +12,21 @@
#define BaslerClassID 0x02
#define c_maxCamerasToUse (size_t)2
//5:»ÒÉ«
//6:ºÚÉ«
//1:ºìÉ«
//2:»ÆÉ«
//3:°×É«
//4:ÂÌÉ«
//5:灰色
//6:黑色
//1:红色
//2:黄色
//3:白色
//4:绿色
class BaslerCamera: public BaseCamera
class BaslerCamera : public BaseCamera
{
public:
BaslerCamera();
~BaslerCamera();
BaslerCamera();
~BaslerCamera();
static int Enumerate();
static int Enumerate();
public:
static Pylon::DeviceInfoList_t devices;
static Pylon::DeviceInfoList_t devices;
};

42
Cigarette/camera_glue.cpp
Unescape Escape View File

@ -5,34 +5,34 @@
spinBox[a][1] = ui.spinBox_##b##2;\
spinBox[a][2] = ui.spinBox_##b##3;
camera_glue::camera_glue(QDialog *parent)
: QDialog(parent)
camera_glue::camera_glue(QDialog* parent)
: QDialog(parent)
{
ui.setupUi(this);
this->setWindowFlags(windowFlags()&~Qt::WindowContextHelpButtonHint);
ui.setupUi(this);
this->setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>0)
camera_glue_init(0,1)
camera_glue_init(0, 1)
#endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>1)
camera_glue_init(1,2)
camera_glue_init(1, 2)
#endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>2)
camera_glue_init(2,3)
camera_glue_init(2, 3)
#endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>3)
camera_glue_init(3,4)
camera_glue_init(3, 4)
#endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>4)
camera_glue_init(4,5)
camera_glue_init(4, 5)
#endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>5)
camera_glue_init(5,6)
camera_glue_init(5, 6)
#endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>6)
camera_glue_init(6,7)
camera_glue_init(6, 7)
#endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>7)
camera_glue_init(7,8)
camera_glue_init(7, 8)
#endif
}
@ -43,17 +43,17 @@ camera_glue::~camera_glue()
void camera_glue::recMsgFromDialogSetup(int ptr[][3])
{
for(int i=0;i<NumberOfSupportedCameras;i++)
for(int j=0;j<3;j++)
spinBox[i][j]->setValue(ptr[i][j]);
for (int i = 0; i < NumberOfSupportedCameras; i++)
for (int j = 0; j < 3; j++)
spinBox[i][j]->setValue(ptr[i][j]);
}
void camera_glue::on_pushButton_take_released(void)
{
int mat[NumberOfSupportedCameras][3];
for(int i=0;i<NumberOfSupportedCameras;i++)
for(int j=0;j<3;j++)
mat[i][j]=spinBox[i][j]->value();
emit sendMsgToDialogSetup(mat);
this->close();
int mat[NumberOfSupportedCameras][3];
for (int i = 0; i < NumberOfSupportedCameras; i++)
for (int j = 0; j < 3; j++)
mat[i][j] = spinBox[i][j]->value();
emit sendMsgToDialogSetup(mat);
this->close();
}

18
Cigarette/camera_glue.h
Unescape Escape View File

@ -6,20 +6,20 @@
#include "common.h"
class camera_glue : public QDialog
{
Q_OBJECT
Q_OBJECT
public:
camera_glue(QDialog *parent = Q_NULLPTR);
~camera_glue();
camera_glue(QDialog* parent = Q_NULLPTR);
~camera_glue();
signals:
void sendMsgToDialogSetup(int ptr[][3]);
void sendMsgToDialogSetup(int ptr[][3]);
public slots:
void recMsgFromDialogSetup(int ptr[][3]);
void on_pushButton_take_released(void);
void recMsgFromDialogSetup(int ptr[][3]);
void on_pushButton_take_released(void);
private:
Ui::camera_glue ui;
QSpinBox *spinBox[NumberOfSupportedCameras][3];
SysConf local_SysConf;
Ui::camera_glue ui;
QSpinBox* spinBox[NumberOfSupportedCameras][3];
SysConf local_SysConf;
};

126
Cigarette/change_shift.cpp
Unescape Escape View File

@ -3,30 +3,30 @@
#include <dialogsetup.hpp>
extern SysConf g_sys_conf;
change_shift::change_shift(QDialog *parent)
: QDialog(parent)
change_shift::change_shift(QDialog* parent)
: QDialog(parent)
{
ui.setupUi(this);
this->setWindowFlags(windowFlags()&~Qt::WindowContextHelpButtonHint);
ui.setupUi(this);
this->setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
if (g_sys_conf.auto_shift == 1) {
ui.radioButton_auto->setChecked(true);
}
else {
ui.radioButton_auto->setChecked(false);
}
if (g_sys_conf.shift_byhand == 1) {
ui.radioButton_byhand->setChecked(true);
}
else {
ui.radioButton_byhand->setChecked(false);
}
if (g_sys_conf.timing_shift == 1) {
ui.radioButton_time->setChecked(true);
}
else {
ui.radioButton_time->setChecked(false);
}
if (g_sys_conf.auto_shift == 1) {
ui.radioButton_auto->setChecked(true);
}
else {
ui.radioButton_auto->setChecked(false);
}
if (g_sys_conf.shift_byhand == 1) {
ui.radioButton_byhand->setChecked(true);
}
else {
ui.radioButton_byhand->setChecked(false);
}
if (g_sys_conf.timing_shift == 1) {
ui.radioButton_time->setChecked(true);
}
else {
ui.radioButton_time->setChecked(false);
}
}
change_shift::~change_shift()
@ -35,56 +35,56 @@ change_shift::~change_shift()
void change_shift::on_pushButton_apply_released()
{
QTime timeA;
QTime timeB;
QTime timeC;
if (ui.radioButton_auto->isChecked()) { /// ÒÑÒþ²Ø
g_sys_conf.auto_shift = 1;
g_sys_conf.timing_shift = 0;
g_sys_conf.shift_byhand = 0;
QTime timeA;
QTime timeB;
QTime timeC;
if (ui.radioButton_auto->isChecked()) { /// 已隐藏
g_sys_conf.auto_shift = 1;
g_sys_conf.timing_shift = 0;
g_sys_conf.shift_byhand = 0;
timeA.setHMS(ui.A_hour->minimum(), ui.A_minute->minimum(), 0);
timeB.setHMS(ui.B_hour->minimum(), ui.B_minute->minimum(), 0);
timeC.setHMS(ui.C_hour->minimum(), ui.C_minute->minimum(), 0);
//emit sendMsgToDialogSetup(timeA, timeB, timeC);
//this->close();
}
else if (ui.radioButton_time->isChecked()) {
g_sys_conf.auto_shift = 0;
g_sys_conf.timing_shift = 1;
g_sys_conf.shift_byhand = 0;
timeA.setHMS(ui.A_hour->minimum(), ui.A_minute->minimum(), 0);
timeB.setHMS(ui.B_hour->minimum(), ui.B_minute->minimum(), 0);
timeC.setHMS(ui.C_hour->minimum(), ui.C_minute->minimum(), 0);
//emit sendMsgToDialogSetup(timeA, timeB, timeC);
//this->close();
}
else if (ui.radioButton_time->isChecked()) {
g_sys_conf.auto_shift = 0;
g_sys_conf.timing_shift = 1;
g_sys_conf.shift_byhand = 0;
timeA.setHMS(ui.A_hour->text().toInt(), ui.A_minute->text().toInt(), 0);
timeB.setHMS(ui.B_hour->text().toInt(), ui.B_minute->text().toInt(), 0);
timeC.setHMS(ui.C_hour->text().toInt(), ui.C_minute->text().toInt(), 0);
//emit sendMsgToDialogSetup(timeA, timeB, timeC);
//this->close();
}
else if (ui.radioButton_byhand->isChecked()) {
g_sys_conf.auto_shift = 0;
g_sys_conf.timing_shift = 0;
g_sys_conf.shift_byhand = 1;
timeA.setHMS(ui.A_hour->text().toInt(), ui.A_minute->text().toInt(), 0);
timeB.setHMS(ui.B_hour->text().toInt(), ui.B_minute->text().toInt(), 0);
timeC.setHMS(ui.C_hour->text().toInt(), ui.C_minute->text().toInt(), 0);
//emit sendMsgToDialogSetup(timeA, timeB, timeC);
//this->close();
}
else if (ui.radioButton_byhand->isChecked()) {
g_sys_conf.auto_shift = 0;
g_sys_conf.timing_shift = 0;
g_sys_conf.shift_byhand = 1;
timeA.setHMS(ui.A_hour->minimum(), ui.A_minute->minimum(), 0);
timeB.setHMS(ui.B_hour->minimum(), ui.B_minute->minimum(), 0);
timeC.setHMS(ui.C_hour->minimum(), ui.C_minute->minimum(), 0);
timeA.setHMS(ui.A_hour->minimum(), ui.A_minute->minimum(), 0);
timeB.setHMS(ui.B_hour->minimum(), ui.B_minute->minimum(), 0);
timeC.setHMS(ui.C_hour->minimum(), ui.C_minute->minimum(), 0);
}
emit sendMsgToDialogSetup(timeA, timeB, timeC);
this->close();
DialogSetup::write_config();
}
emit sendMsgToDialogSetup(timeA, timeB, timeC);
this->close();
DialogSetup::write_config();
}
void change_shift::recMsgFromDialogSetup(QTime timeA, QTime timeB, QTime timeC)
{
ui.A_hour->setValue(timeA.hour());
ui.A_minute->setValue(timeA.minute());
ui.A_hour->setValue(timeA.hour());
ui.A_minute->setValue(timeA.minute());
ui.B_hour->setValue(timeB.hour());
ui.B_minute->setValue(timeB.minute());
ui.B_hour->setValue(timeB.hour());
ui.B_minute->setValue(timeB.minute());
ui.C_hour->setValue(timeC.hour());
ui.C_minute->setValue(timeC.minute());
ui.C_hour->setValue(timeC.hour());
ui.C_minute->setValue(timeC.minute());
this->show();
this->show();
}

14
Cigarette/change_shift.h
Unescape Escape View File

@ -6,22 +6,22 @@
class change_shift : public QDialog
{
Q_OBJECT
Q_OBJECT
public:
change_shift(QDialog *parent = Q_NULLPTR);
~change_shift();
change_shift(QDialog* parent = Q_NULLPTR);
~change_shift();
private:
Ui::change_shift ui;
Ui::change_shift ui;
private slots:
void on_pushButton_apply_released();
void on_pushButton_apply_released();
public slots:
void recMsgFromDialogSetup(QTime timeA, QTime timeB, QTime timeC);
void recMsgFromDialogSetup(QTime timeA, QTime timeB, QTime timeC);
signals:
void sendMsgToDialogSetup(QTime timeA, QTime timeB, QTime timeC);
void sendMsgToDialogSetup(QTime timeA, QTime timeB, QTime timeC);
};

7044
Cigarette/cigarette.cpp
View File

File diff suppressed because it is too large Load Diff

304
Cigarette/cigarette.h
Unescape Escape View File

@ -56,179 +56,179 @@ class QTimer;
#define CLOSE false
class Cigarette : public QMainWindow
{
Q_OBJECT
Q_OBJECT
public:
Cigarette(QWidget *parent = 0);
~Cigarette();
static QImage cvMatToQImage(const cv::Mat& mat);
QString read_pswd();
QString read_op_pswd();
bool read_conf(ConfPath &conf_path);
bool read_sys_config(SysConf &conf, QString conf_path);
bool read_modbus_config(ModbusConf &conf);
void read_plc_items();
bool save_rotate_message();
bool read_rotate_message();
bool save_alarm_message(std::vector<AlarmInfo> &AlarmInfo_vect);
void init_plc_value();
void CreatWorkThread(int classid,int Num,Cigarette* classptr);
void InitPtrMat();
bool ControlCamOpenOrClose(int Num,bool OpenOrClose);
void EnumerateCameras(SingleCamInfoStruct *TempSingleCamInfo,bool showinfo,SysConf &conf);
void start_work();
void pause_work();
void CleanThreadStart();
void Exit();
private slots :
void on_btn_start_released();
void on_btn_pause_released();
//void on_btn_pause_clicked(bool checked);
void on_btn_lock_released();
void on_btn_setup_released();
void on_checkBox_debug_clicked(bool checked);
void on_checkBox_unkick_clicked(bool checked);
void on_pushButton_wintab_clicked(bool checked);
void on_toolButton_plc_released();
void on_toolButton_alarm_released();
void on_pushButton_clear_released();
void enable_shift();
Cigarette(QWidget* parent = 0);
~Cigarette();
static QImage cvMatToQImage(const cv::Mat& mat);
QString read_pswd();
QString read_op_pswd();
bool read_conf(ConfPath& conf_path);
bool read_sys_config(SysConf& conf, QString conf_path);
bool read_modbus_config(ModbusConf& conf);
void read_plc_items();
bool save_rotate_message();
bool read_rotate_message();
bool save_alarm_message(std::vector<AlarmInfo>& AlarmInfo_vect);
void init_plc_value();
void CreatWorkThread(int classid, int Num, Cigarette* classptr);
void InitPtrMat();
bool ControlCamOpenOrClose(int Num, bool OpenOrClose);
void EnumerateCameras(SingleCamInfoStruct* TempSingleCamInfo, bool showinfo, SysConf& conf);
void start_work();
void pause_work();
void CleanThreadStart();
void Exit();
private slots:
void on_btn_start_released();
void on_btn_pause_released();
//void on_btn_pause_clicked(bool checked);
void on_btn_lock_released();
void on_btn_setup_released();
void on_checkBox_debug_clicked(bool checked);
void on_checkBox_unkick_clicked(bool checked);
void on_pushButton_wintab_clicked(bool checked);
void on_toolButton_plc_released();
void on_toolButton_alarm_released();
void on_pushButton_clear_released();
void enable_shift();
#ifdef __UDPSend
void sendLatestData();
void sendLatestData();
#endif
void OnNotifyHub(int Num, int Cnt, cv::Mat m);
void OnDisplayTimeCostHub(int Num, int ms);
void OnDisplayCheckNumberHub(int Num, long no);
void OnDisplayJdNoHub(int Num, QString jd_no);
void OnOKHub(int Num);
void OnNGHub(int Num);
void updateStatisticsHub(const QString& statisticalData, int Num);
void OnRotateReleasedHub(int Num);
void OnToolButtonCamReleasedHub(int Num);
void OpenCamTimeoutHub(int Num);
void OnDBClickHub(int Num_Cnt);
void DrawRect_init(int Num_Cnt);
void OnTPClickHub(int Num_Cnt);
void OnDBClickNGHub(int Num);
void ReconnectCamHub(int Num);
void OnMouse(QMouseEvent* event);
void OnKey(QKeyEvent* event);
void handleTimeout(); //定时任务，每秒运行一次
void op_timeout(); //操作员剩余时间
void admin_timeout(); //管理员权限剩余时间
void EnableDebugMode();
void DisableDebugMode();
void OnCancelAlarm(); //双击消警
void on_pushButton_reset_released();//复位
void OnOp();
void OnExit();
void OnRestart();
void OnAdmin();
void OnNotifyHub(int Num, int Cnt, cv::Mat m);
void OnDisplayTimeCostHub(int Num, int ms);
void OnDisplayCheckNumberHub(int Num, long no);
void OnDisplayJdNoHub(int Num, QString jd_no);
void OnOKHub(int Num);
void OnNGHub(int Num);
void updateStatisticsHub(const QString& statisticalData, int Num);
void OnRotateReleasedHub(int Num);
void OnToolButtonCamReleasedHub(int Num);
void OpenCamTimeoutHub(int Num);
void OnDBClickHub(int Num_Cnt);
void DrawRect_init(int Num_Cnt);
void OnTPClickHub(int Num_Cnt);
void OnDBClickNGHub(int Num);
void ReconnectCamHub(int Num);
void OnMouse(QMouseEvent* event);
void OnKey(QKeyEvent* event);
void handleTimeout(); //定时任务，每秒运行一次
void op_timeout(); //操作员剩余时间
void admin_timeout(); //管理员权限剩余时间
void EnableDebugMode();
void DisableDebugMode();
void OnCancelAlarm(); //双击消警
void on_pushButton_reset_released();//复位
void OnOp();
void OnExit();
void OnRestart();
void OnAdmin();
#ifdef __DEBUG
void TestImg();
void TestImgs();
void TestImg();
void TestImgs();
#endif
private:
Ui::CigaretteClass ui;
DialogSetupPasswd *dialog_setup_passwd;
Dialogin *dialogin;
DialogSetup *dialog_setup;
PlcSetup * dialog_plc_setup;
std::vector<PlcItem> m_plc_items;
Ui::CigaretteClass ui;
DialogSetupPasswd* dialog_setup_passwd;
Dialogin* dialogin;
DialogSetup* dialog_setup;
PlcSetup* dialog_plc_setup;
std::vector<PlcItem> m_plc_items;
public:
QTimer *m_pTimer_Cam_mat[NumberOfSupportedCameras]; //相机重启定时器
QLabel *label_cap_speed_mat[NumberOfSupportedCameras];
QLabel *cam_status_mat[NumberOfSupportedCameras];
QLabel *cam_work_mat[NumberOfSupportedCameras];
QToolButton *cam_toolButton_mat[NumberOfSupportedCameras];
db_label * display_lable_mat[NumberOfSupportedCameras][2];
QLabel *label_timecost_mat[NumberOfSupportedCameras];
QLCDNumber *lcdNumber_total_mat[NumberOfSupportedCameras];
QLabel *label_jd_no_mat[NumberOfSupportedCameras];
QLCDNumber *lcdNumber_ok_mat[NumberOfSupportedCameras];
QLCDNumber *lcdNumber_ng_mat[NumberOfSupportedCameras];
QLCDNumber* lcdNumber_kick_mat[NumberOfSupportedCameras];
QLabel *label_reslut_mat[NumberOfSupportedCameras];
QToolButton *rotate_mat[NumberOfSupportedCameras];
QLabel *label_ng_mat[NumberOfSupportedCameras];
struct widget_info
{
UINT32 x;
UINT32 y;
UINT32 width;
UINT32 height;
};
widget_info display_lable_info[NumberOfSupportedCameras][2];
widget_info rotate_info[NumberOfSupportedCameras];
QTimer* m_pTimer_Cam_mat[NumberOfSupportedCameras]; //相机重启定时器
QLabel* label_cap_speed_mat[NumberOfSupportedCameras];
QLabel* cam_status_mat[NumberOfSupportedCameras];
QLabel* cam_work_mat[NumberOfSupportedCameras];
QToolButton* cam_toolButton_mat[NumberOfSupportedCameras];
db_label* display_lable_mat[NumberOfSupportedCameras][2];
QLabel* label_timecost_mat[NumberOfSupportedCameras];
QLCDNumber* lcdNumber_total_mat[NumberOfSupportedCameras];
QLabel* label_jd_no_mat[NumberOfSupportedCameras];
QLCDNumber* lcdNumber_ok_mat[NumberOfSupportedCameras];
QLCDNumber* lcdNumber_ng_mat[NumberOfSupportedCameras];
QLCDNumber* lcdNumber_kick_mat[NumberOfSupportedCameras];
QLabel* label_reslut_mat[NumberOfSupportedCameras];
QToolButton* rotate_mat[NumberOfSupportedCameras];
QLabel* label_ng_mat[NumberOfSupportedCameras];
struct widget_info
{
UINT32 x;
UINT32 y;
UINT32 width;
UINT32 height;
};
widget_info display_lable_info[NumberOfSupportedCameras][2];
widget_info rotate_info[NumberOfSupportedCameras];
#ifdef SYNC_CAMERA
SyncWorkThread sync_work_thread;
SyncWorkThread sync_work_thread;
#else
WorkThread work_thread[NumberOfSupportedCameras];
WorkThread work_thread[NumberOfSupportedCameras];
#endif
DebugThread debug_thread[NumberOfSupportedCameras];
struct export_info {
int cameraId = -1;
int totalCheckNum = 0;
int totalKickNum = 0;
int kick = 0;
int checkNum = 0;
QString detectTime = "0";
QString acquisitionTime = "0";
QString jdNum = QString("0,0,0");
int okNum = 0;
int ngNum = 0;
};
export_info exportData[NumberOfSupportedCameras];
SaveThread saveThread;
void record_output_statistic(qint64 cur_quantity, int Kick[NumberOfSupportedCameras], int shift);
QTimer *m_pTimer;
QTimer *m_delay; //换班防止连击
QTimer* m_sendMsg_delay; // 停止工作后发送最新数据给远程端
QTimer *m_op_delay; //操作员权限剩余时间
QTimer *m_admin_delay; //操作员权限剩余时间
QTimer *clean_pTimer; //定时清理任务
QSignalMapper *image_lable_DBsignalMapper0;
QSignalMapper *image_lable_DBsignalMapper1;
QSignalMapper *image_lable_TPsignalMapper0;
QSignalMapper *image_lable_TPsignalMapper1;
QSignalMapper *label_ng_signalMapper;
QSignalMapper *pTimer_Cam_signalMapper;
QSignalMapper *toolButton_cam_signalMapper;
QSignalMapper *RotateReleased_signalMapper;
int total_production_number;
int production_number[NumberOfSupportedCameras];
int OpenWithUserID[NumberOfSupportedCameras];
int ok[NumberOfSupportedCameras], ng[NumberOfSupportedCameras];
DebugThread debug_thread[NumberOfSupportedCameras];
struct export_info {
int cameraId = -1;
int totalCheckNum = 0;
int totalKickNum = 0;
int kick = 0;
int checkNum = 0;
QString detectTime = "0";
QString acquisitionTime = "0";
QString jdNum = QString("0,0,0");
int okNum = 0;
int ngNum = 0;
};
export_info exportData[NumberOfSupportedCameras];
SaveThread saveThread;
void record_output_statistic(qint64 cur_quantity, int Kick[NumberOfSupportedCameras], int shift);
QTimer* m_pTimer;
QTimer* m_delay; //换班防止连击
QTimer* m_sendMsg_delay; // 停止工作后发送最新数据给远程端
QTimer* m_op_delay; //操作员权限剩余时间
QTimer* m_admin_delay; //操作员权限剩余时间
QTimer* clean_pTimer; //定时清理任务
QSignalMapper* image_lable_DBsignalMapper0;
QSignalMapper* image_lable_DBsignalMapper1;
QSignalMapper* image_lable_TPsignalMapper0;
QSignalMapper* image_lable_TPsignalMapper1;
QSignalMapper* label_ng_signalMapper;
QSignalMapper* pTimer_Cam_signalMapper;
QSignalMapper* toolButton_cam_signalMapper;
QSignalMapper* RotateReleased_signalMapper;
int total_production_number;
int production_number[NumberOfSupportedCameras];
int OpenWithUserID[NumberOfSupportedCameras];
int ok[NumberOfSupportedCameras], ng[NumberOfSupportedCameras];
#ifdef __UDPSend
private:
threadSend sThread;
threadReceive *rThread;
private:
threadSend sThread;
threadReceive* rThread;
#endif
#ifdef __TCPSend
private:
threadSendTCP tcpSendThread;
private:
threadSendTCP tcpSendThread;
#endif
public slots:
void CleanThreadStartAuto();
void CleanThreadStartAuto();
#ifdef __UDPSend
void recMsgFromUdp(QString data);
void recMsgFromUdp(QString data);
#endif
//void ClogThreadStart();
//void ClogThreadStart();
signals:
void sengMsgToClog(QString);
void sendMsgToExportData();
void sengMsgToClog(QString);
void sendMsgToExportData();
};
#endif // CIGARETTE_H

640
Cigarette/common.cpp
Unescape Escape View File

@ -7,28 +7,28 @@
#include <Commdlg.h>
#include <tchar.h>
int string_split(std::string str, std::string pattern,std::vector<std::string> &out)
int string_split(std::string str, std::string pattern, std::vector<std::string>& out)
{
std::string::size_type pos;
int cnt = 0;
str += pattern;
int size = str.size();
for (int i = 0; i<size; i++)
{
pos = str.find(pattern, i);
if (pos<size)
{
cnt++;
std::string s = str.substr(i, pos - i);
out.push_back(s);
i = pos + pattern.size() - 1;
}
}
return cnt;
std::string::size_type pos;
int cnt = 0;
str += pattern;
int size = str.size();
for (int i = 0; i < size; i++)
{
pos = str.find(pattern, i);
if (pos < size)
{
cnt++;
std::string s = str.substr(i, pos - i);
out.push_back(s);
i = pos + pattern.size() - 1;
}
}
return cnt;
}
std::string format(const char *pszFmt, ...)
std::string format(const char* pszFmt, ...)
{
std::string str;
va_list args;
@ -44,110 +44,110 @@ std::string format(const char *pszFmt, ...)
return str;
}
void DrawSelectRects(cv::Mat input,DisplayLabelConf &t_DisplayLabelConf,int Cnt)
void DrawSelectRects(cv::Mat input, DisplayLabelConf& t_DisplayLabelConf, int Cnt)
{
if (t_DisplayLabelConf.Flag[Cnt] & DisplayLabel_Type_Bit) {
if (t_DisplayLabelConf.leftButtonDownFlag) {
cv::rectangle(
input,
cv::Point(
t_DisplayLabelConf.originalPoint.x * input.cols,
t_DisplayLabelConf.originalPoint.y * input.rows),
cv::Point(
t_DisplayLabelConf.processPoint.x * input.cols,
t_DisplayLabelConf.processPoint.y * input.rows),
cv::Scalar(0, 0, 255),
4);
}
for (int i = 0; i < t_DisplayLabelConf.RectVet[Cnt].size(); i++) {
cv::rectangle(
input,
cv::Point(
t_DisplayLabelConf.RectVet[Cnt][i].TL.x * input.cols,
t_DisplayLabelConf.RectVet[Cnt][i].TL.y * input.rows),
cv::Point(
t_DisplayLabelConf.RectVet[Cnt][i].BR.x * input.cols,
t_DisplayLabelConf.RectVet[Cnt][i].BR.y * input.rows),
cv::Scalar(0, 0, 255),
4);
}
}
if (t_DisplayLabelConf.Flag[Cnt] & DisplayLabel_Type_Bit) {
if (t_DisplayLabelConf.leftButtonDownFlag) {
cv::rectangle(
input,
cv::Point(
t_DisplayLabelConf.originalPoint.x * input.cols,
t_DisplayLabelConf.originalPoint.y * input.rows),
cv::Point(
t_DisplayLabelConf.processPoint.x * input.cols,
t_DisplayLabelConf.processPoint.y * input.rows),
cv::Scalar(0, 0, 255),
4);
}
for (int i = 0; i < t_DisplayLabelConf.RectVet[Cnt].size(); i++) {
cv::rectangle(
input,
cv::Point(
t_DisplayLabelConf.RectVet[Cnt][i].TL.x * input.cols,
t_DisplayLabelConf.RectVet[Cnt][i].TL.y * input.rows),
cv::Point(
t_DisplayLabelConf.RectVet[Cnt][i].BR.x * input.cols,
t_DisplayLabelConf.RectVet[Cnt][i].BR.y * input.rows),
cv::Scalar(0, 0, 255),
4);
}
}
}
bool CheckSelectRects(
cv::Mat input,
std::vector<std::vector<std::pair<int, cv::Rect> > > &VecRects,
int VecCnt,
DisplayLabelConf &t_DisplayLabelConf,
int LabelCnt
cv::Mat input,
std::vector<std::vector<std::pair<int, cv::Rect> > >& VecRects,
int VecCnt,
DisplayLabelConf& t_DisplayLabelConf,
int LabelCnt
)
{
bool find;
if (!(t_DisplayLabelConf.Flag[LabelCnt] & DisplayLabel_Type_Bit))
{
return false;
}
if (VecCnt < VecRects.size())
{
for (int i = 0; i < VecRects[VecCnt].size(); i++)
{
find = false;
for(int j = 0; j < t_DisplayLabelConf.RectVet[LabelCnt].size(); j++)
{
cv::Rect LocalRect = VecRects[VecCnt][i].second;
cv::Rect CheckRect = cv::Rect(
cv::Point(
t_DisplayLabelConf.RectVet[LabelCnt][j].TL.x* input.cols,
t_DisplayLabelConf.RectVet[LabelCnt][j].TL.y* input.rows
),
cv::Point(
t_DisplayLabelConf.RectVet[LabelCnt][j].BR.x* input.cols,
t_DisplayLabelConf.RectVet[LabelCnt][j].BR.y* input.rows
)
);
cv::Rect tempRect = (LocalRect & CheckRect);
if(LocalRect == tempRect)
{
find = true;
}
}
if(!find)
{
return true;
}
}
}
return false;
bool find;
if (!(t_DisplayLabelConf.Flag[LabelCnt] & DisplayLabel_Type_Bit))
{
return false;
}
if (VecCnt < VecRects.size())
{
for (int i = 0; i < VecRects[VecCnt].size(); i++)
{
find = false;
for (int j = 0; j < t_DisplayLabelConf.RectVet[LabelCnt].size(); j++)
{
cv::Rect LocalRect = VecRects[VecCnt][i].second;
cv::Rect CheckRect = cv::Rect(
cv::Point(
t_DisplayLabelConf.RectVet[LabelCnt][j].TL.x * input.cols,
t_DisplayLabelConf.RectVet[LabelCnt][j].TL.y * input.rows
),
cv::Point(
t_DisplayLabelConf.RectVet[LabelCnt][j].BR.x * input.cols,
t_DisplayLabelConf.RectVet[LabelCnt][j].BR.y * input.rows
)
);
cv::Rect tempRect = (LocalRect & CheckRect);
if (LocalRect == tempRect)
{
find = true;
}
}
if (!find)
{
return true;
}
}
}
return false;
}
void getFiles(std::string path, std::vector<std::string>& files)
{
//文件句柄
intptr_t hFile = 0;
//文件信息
struct _finddata_t fileinfo;
std::string p;
if ((hFile = _findfirst(p.assign(path).c_str(), &fileinfo)) != -1)
{
do
{
if (!(fileinfo.attrib & _A_SUBDIR))
{
files.push_back(fileinfo.name);
}
} while (_findnext(hFile, &fileinfo) == 0);
_findclose(hFile);
}
//文件句柄
intptr_t hFile = 0;
//文件信息
struct _finddata_t fileinfo;
std::string p;
if ((hFile = _findfirst(p.assign(path).c_str(), &fileinfo)) != -1)
{
do
{
if (!(fileinfo.attrib & _A_SUBDIR))
{
files.push_back(fileinfo.name);
}
} while (_findnext(hFile, &fileinfo) == 0);
_findclose(hFile);
}
}
std::string WstringToString(std::wstring wstr)
{
int nLen = wcslen(wstr.c_str());
std::string str;
str.resize(nLen * 2, ' ');
int nResult = WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)wstr.c_str(), -1, (LPSTR)str.c_str(), nLen * 2, NULL, NULL);
return str;
int nLen = wcslen(wstr.c_str());
std::string str;
str.resize(nLen * 2, ' ');
int nResult = WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)wstr.c_str(), -1, (LPSTR)str.c_str(), nLen * 2, NULL, NULL);
return str;
}
/*
@ -171,255 +171,255 @@ char* LPWSTR2LPSTR(LPWSTR lpwszStrIn)
//从string s的位置pos开始，向后找，找到第一个等于x的位置返回其位置
//找到，返回找到的位置，找不到返回-1
int __find(const std::string s, const int start, const char x) {
if (start >= s.length())return -1;
for (int i = start; i < s.length(); ++i) {
if (s[i] == x) return i;
}
return -1;
if (start >= s.length())return -1;
for (int i = start; i < s.length(); ++i) {
if (s[i] == x) return i;
}
return -1;
}
//双斜杠转单斜杠
void pathConvert_Double2Single(std::string& s) {
int start = 0;
while (start < s.length()) {
int pos = s.find('\\', start);
if (pos == -1)break;
s.replace(pos, 1,"/");
start = pos + 1;
}
int start = 0;
while (start < s.length()) {
int pos = s.find('\\', start);
if (pos == -1)break;
s.replace(pos, 1, "/");
start = pos + 1;
}
}
int CALLBACK BrowseCallbackProc(
HWND hwnd, UINT uMsg, LPARAM /*lParam*/, LPARAM lpData)
HWND hwnd, UINT uMsg, LPARAM /*lParam*/, LPARAM lpData)
{
LPWSTR buf[1000];
GetCurrentDirectory(1000, (LPWSTR)buf);
if (uMsg == BFFM_INITIALIZED)
{
SendMessage(hwnd, BFFM_SETSELECTION, (WPARAM)TRUE, (LPARAM)buf);
}
return 0;
LPWSTR buf[1000];
GetCurrentDirectory(1000, (LPWSTR)buf);
if (uMsg == BFFM_INITIALIZED)
{
SendMessage(hwnd, BFFM_SETSELECTION, (WPARAM)TRUE, (LPARAM)buf);
}
return 0;
}
std::string SelectDirBRI()
{
BROWSEINFO bi;
bi.hwndOwner = NULL;
bi.pidlRoot = CSIDL_DESKTOP;
bi.pszDisplayName = NULL;
bi.lpszTitle = NULL;//显?位于对话框左上部的提?信息
bi.ulFlags = BIF_DONTGOBELOWDOMAIN | BIF_RETURNONLYFSDIRS | BIF_NEWDIALOGSTYLE;//有新建?件夹按钮
bi.lpfn = BrowseCallbackProc;
bi.iImage = 0;
LPITEMIDLIST pidl = SHBrowseForFolder(&bi);//调?选择对话框
if (pidl == NULL)
{
std::cout << "没有选择目录" << std::endl;
return "";
}
TCHAR strFolder[MAX_PATH];
SHGetPathFromIDList(pidl, strFolder);
std::string sFolder = "";
sFolder = WstringToString(strFolder);
int pos = sFolder.find('\0');
if (pos)
{
sFolder = sFolder.substr(0, pos);
}
return sFolder;
BROWSEINFO bi;
bi.hwndOwner = NULL;
bi.pidlRoot = CSIDL_DESKTOP;
bi.pszDisplayName = NULL;
bi.lpszTitle = NULL;//显?位于对话框左上部的提?信息
bi.ulFlags = BIF_DONTGOBELOWDOMAIN | BIF_RETURNONLYFSDIRS | BIF_NEWDIALOGSTYLE;//有新建?件夹按钮
bi.lpfn = BrowseCallbackProc;
bi.iImage = 0;
LPITEMIDLIST pidl = SHBrowseForFolder(&bi);//调?选择对话框
if (pidl == NULL)
{
std::cout << "没有选择目录" << std::endl;
return "";
}
TCHAR strFolder[MAX_PATH];
SHGetPathFromIDList(pidl, strFolder);
std::string sFolder = "";
sFolder = WstringToString(strFolder);
int pos = sFolder.find('\0');
if (pos)
{
sFolder = sFolder.substr(0, pos);
}
return sFolder;
}
std::string SelectFileOFN()
{
OPENFILENAME ofn;//#include <Commdlg.h>
TCHAR szOpenFileNames[80 * MAX_PATH] = { 0 };
TCHAR szPath[MAX_PATH];
TCHAR szFileName[80 * MAX_PATH];
int nLen = 0;
TCHAR* p = NULL;
ZeroMemory(&ofn, sizeof(ofn));
// 结构体大小
ofn.lStructSize = sizeof(ofn);
// 拥有着窗口句柄
ofn.hwndOwner = NULL;
// 接收返回的文件名，注意第一个字符需要为NULL
ofn.lpstrFile = szOpenFileNames;
// 缓冲区长度
ofn.nMaxFile = sizeof(szOpenFileNames);
// _T可替换为TEXT，使用_T需要引tchar.h
ofn.lpstrFile[0] = _T('\0');
// 设置过滤
ofn.lpstrFilter = _T("All\0*.*\0.mp4\0*.mp4\0.avi\0*.avi\0.mkv\0*.mkv\0.rmvb\0*.rmvb\0.f4v\0*.f4v\0.flv\0*.flv\0.m4v\0*.m4v\0.mpg\0*.mpg\0\0");
// 过滤器索引
ofn.nFilterIndex = 1;
// 窗口标题
ofn.lpstrTitle = _T("请选择图片");
// 文件必须存在、允许多选、隐藏只读选项、对话框使用资源管理器风格的用户界面
// 官方文档：https://docs.microsoft.com/en-us/windows/win32/api/commdlg/ns-commdlg-openfilenamea
ofn.Flags = OFN_FILEMUSTEXIST | OFN_ALLOWMULTISELECT | OFN_HIDEREADONLY | OFN_EXPLORER;
// 如果打开文件失败，则不操作
if (!::GetOpenFileName(&ofn)) {
return "";
}
// 把第一个文件名前的复制到szPath,即:
// 如果只选了一个文件,就复制到最后一个'/'
// 如果选了多个文件,就复制到第一个NULL字符
lstrcpyn(szPath, szOpenFileNames, ofn.nFileOffset);
// 当只选了一个文件时,下面这个NULL字符是必需的.
// 这里不区别对待选了一个和多个文件的情况
szPath[ofn.nFileOffset] = '\0';
nLen = lstrlen(szPath);
// 如果选了多个文件,则必须加上'//'
if (szPath[nLen - 1] != '\\') {
lstrcat(szPath, _T("\\"));
}
// 把指针移到第一个文件
p = szOpenFileNames + ofn.nFileOffset;
// 对szFileName进行清零
ZeroMemory(szFileName, sizeof(szFileName));
// 定义字符串，用于拼接所选的所有文件的完整路径
std::string str = "";
while (*p) {
// 读取文件名
std::string fileName = LPWSTR2LPSTR(p);
// 读取文件所在文件夹路径
std::string filePath = LPWSTR2LPSTR(szPath);
// 拼接文件完整路径
std::string completePath = filePath + fileName;
// 拼接字符串
str += completePath;
//移至下一个文件
p += lstrlen(p) + 1;
}
return str;
// 将string转为char*
//char* strc = new char[strlen(str.c_str()) + 1];
//const char* cc = str.c_str();
//strcpy_s(strc, str.size() + 1, cc);
OPENFILENAME ofn;//#include <Commdlg.h>
TCHAR szOpenFileNames[80 * MAX_PATH] = { 0 };
TCHAR szPath[MAX_PATH];
TCHAR szFileName[80 * MAX_PATH];
int nLen = 0;
TCHAR* p = NULL;
ZeroMemory(&ofn, sizeof(ofn));
// 结构体大小
ofn.lStructSize = sizeof(ofn);
// 拥有着窗口句柄
ofn.hwndOwner = NULL;
// 接收返回的文件名，注意第一个字符需要为NULL
ofn.lpstrFile = szOpenFileNames;
// 缓冲区长度
ofn.nMaxFile = sizeof(szOpenFileNames);
// _T可替换为TEXT，使用_T需要引tchar.h
ofn.lpstrFile[0] = _T('\0');
// 设置过滤
ofn.lpstrFilter = _T("All\0*.*\0.mp4\0*.mp4\0.avi\0*.avi\0.mkv\0*.mkv\0.rmvb\0*.rmvb\0.f4v\0*.f4v\0.flv\0*.flv\0.m4v\0*.m4v\0.mpg\0*.mpg\0\0");
// 过滤器索引
ofn.nFilterIndex = 1;
// 窗口标题
ofn.lpstrTitle = _T("请选择图片");
// 文件必须存在、允许多选、隐藏只读选项、对话框使用资源管理器风格的用户界面
// 官方文档：https://docs.microsoft.com/en-us/windows/win32/api/commdlg/ns-commdlg-openfilenamea
ofn.Flags = OFN_FILEMUSTEXIST | OFN_ALLOWMULTISELECT | OFN_HIDEREADONLY | OFN_EXPLORER;
// 如果打开文件失败，则不操作
if (!::GetOpenFileName(&ofn)) {
return "";
}
// 把第一个文件名前的复制到szPath,即:
// 如果只选了一个文件,就复制到最后一个'/'
// 如果选了多个文件,就复制到第一个NULL字符
lstrcpyn(szPath, szOpenFileNames, ofn.nFileOffset);
// 当只选了一个文件时,下面这个NULL字符是必需的.
// 这里不区别对待选了一个和多个文件的情况
szPath[ofn.nFileOffset] = '\0';
nLen = lstrlen(szPath);
// 如果选了多个文件,则必须加上'//'
if (szPath[nLen - 1] != '\\') {
lstrcat(szPath, _T("\\"));
}
// 把指针移到第一个文件
p = szOpenFileNames + ofn.nFileOffset;
// 对szFileName进行清零
ZeroMemory(szFileName, sizeof(szFileName));
// 定义字符串，用于拼接所选的所有文件的完整路径
std::string str = "";
while (*p) {
// 读取文件名
std::string fileName = LPWSTR2LPSTR(p);
// 读取文件所在文件夹路径
std::string filePath = LPWSTR2LPSTR(szPath);
// 拼接文件完整路径
std::string completePath = filePath + fileName;
// 拼接字符串
str += completePath;
//移至下一个文件
p += lstrlen(p) + 1;
}
return str;
// 将string转为char*
//char* strc = new char[strlen(str.c_str()) + 1];
//const char* cc = str.c_str();
//strcpy_s(strc, str.size() + 1, cc);
}
//https://learn.microsoft.com/en-us/windows/win32/shell/common-file-dialog?redirectedfrom=MSDN
std::string SelectDirIFD()
{
std::string folderpath = "";
// CoCreate the File Open Dialog object.
IFileDialog* pfd = NULL;
HRESULT hr = CoCreateInstance(CLSID_FileOpenDialog,
NULL,
CLSCTX_INPROC_SERVER,
IID_PPV_ARGS(&pfd));
if (SUCCEEDED(hr))
{
// Set the options on the dialog.
DWORD dwFlags;
// Before setting, always get the options first in order
// not to override existing options.
hr = pfd->GetOptions(&dwFlags);
if (SUCCEEDED(hr))
{
// In this case, get shell items only for file system items.
hr = pfd->SetOptions(dwFlags | FOS_PICKFOLDERS);
if (SUCCEEDED(hr))
{
// Show the dialog
hr = pfd->Show(NULL);
if (SUCCEEDED(hr))
{
// Obtain the result once the user clicks
// the 'Open' button.
// The result is an IShellItem object.
IShellItem* psiResult;
hr = pfd->GetResult(&psiResult);
if (SUCCEEDED(hr))
{
// We are just going to print out the
// name of the file for sample sake.
PWSTR pszFilePath = NULL;
hr = psiResult->GetDisplayName(SIGDN_FILESYSPATH,&pszFilePath);
if (SUCCEEDED(hr))
{
folderpath = LPWSTR2LPSTR(pszFilePath);
CoTaskMemFree(pszFilePath);
}
psiResult->Release();
}
}
}
}
pfd->Release();
}
return folderpath;
std::string folderpath = "";
// CoCreate the File Open Dialog object.
IFileDialog* pfd = NULL;
HRESULT hr = CoCreateInstance(CLSID_FileOpenDialog,
NULL,
CLSCTX_INPROC_SERVER,
IID_PPV_ARGS(&pfd));
if (SUCCEEDED(hr))
{
// Set the options on the dialog.
DWORD dwFlags;
// Before setting, always get the options first in order
// not to override existing options.
hr = pfd->GetOptions(&dwFlags);
if (SUCCEEDED(hr))
{
// In this case, get shell items only for file system items.
hr = pfd->SetOptions(dwFlags | FOS_PICKFOLDERS);
if (SUCCEEDED(hr))
{
// Show the dialog
hr = pfd->Show(NULL);
if (SUCCEEDED(hr))
{
// Obtain the result once the user clicks
// the 'Open' button.
// The result is an IShellItem object.
IShellItem* psiResult;
hr = pfd->GetResult(&psiResult);
if (SUCCEEDED(hr))
{
// We are just going to print out the
// name of the file for sample sake.
PWSTR pszFilePath = NULL;
hr = psiResult->GetDisplayName(SIGDN_FILESYSPATH, &pszFilePath);
if (SUCCEEDED(hr))
{
folderpath = LPWSTR2LPSTR(pszFilePath);
CoTaskMemFree(pszFilePath);
}
psiResult->Release();
}
}
}
}
pfd->Release();
}
return folderpath;
}
std::string UTF8ToGBK(std::string utf8_str) {
// 获得临时变量的大小
int wchar_len = MultiByteToWideChar(CP_UTF8, 0, utf8_str.c_str(), -1, NULL, 0);
wchar_t *wchar_buf = new wchar_t[wchar_len];
MultiByteToWideChar(CP_UTF8, 0, utf8_str.c_str(), -1, wchar_buf, wchar_len);
// 获得临时变量的大小
int wchar_len = MultiByteToWideChar(CP_UTF8, 0, utf8_str.c_str(), -1, NULL, 0);
wchar_t* wchar_buf = new wchar_t[wchar_len];
MultiByteToWideChar(CP_UTF8, 0, utf8_str.c_str(), -1, wchar_buf, wchar_len);
// 获得临时变量的大小
int char_len = WideCharToMultiByte(CP_ACP, 0, wchar_buf, -1, NULL, 0, NULL, NULL);
char* char_buf = new char[char_len];
WideCharToMultiByte(CP_ACP, 0, wchar_buf, -1, char_buf, char_len, NULL, NULL);
// 获得临时变量的大小
int char_len = WideCharToMultiByte(CP_ACP, 0, wchar_buf, -1, NULL, 0, NULL, NULL);
char* char_buf = new char[char_len];
WideCharToMultiByte(CP_ACP, 0, wchar_buf, -1, char_buf, char_len, NULL, NULL);
std::string gbk_str(char_buf);
delete[] wchar_buf;
delete[] char_buf;
std::string gbk_str(char_buf);
delete[] wchar_buf;
delete[] char_buf;
return gbk_str;
return gbk_str;
}
void stdString2QString(std::string str, QString& qs) {
qs = QString::fromLocal8Bit(QByteArray::fromRawData(str.c_str(), str.size()));
qs = QString::fromLocal8Bit(QByteArray::fromRawData(str.c_str(), str.size()));
}
void QString2stdString(QString qs, std::string& str) {
str = qs.toLocal8Bit().constData();
str = qs.toLocal8Bit().constData();
}
std::string WString2String(const std::wstring& ws) {
// 进行地域设置，"" 表示当前OS默认的地域设置，成功则返回当前地域设置的名称
std::string strLocate = setlocale(LC_ALL, "");
const wchar_t* wchSrc = ws.c_str();
size_t nDestSize = wcstombs(NULL, wchSrc, 0) + 1;
char* chDest = new char[nDestSize];
memset(chDest, 0, nDestSize);
wcstombs(chDest, wchSrc, nDestSize);
std::string strResult = chDest;
delete[] chDest;
setlocale(LC_ALL, strLocate.c_str());
return strResult;
// 进行地域设置，"" 表示当前OS默认的地域设置，成功则返回当前地域设置的名称
std::string strLocate = setlocale(LC_ALL, "");
const wchar_t* wchSrc = ws.c_str();
size_t nDestSize = wcstombs(NULL, wchSrc, 0) + 1;
char* chDest = new char[nDestSize];
memset(chDest, 0, nDestSize);
wcstombs(chDest, wchSrc, nDestSize);
std::string strResult = chDest;
delete[] chDest;
setlocale(LC_ALL, strLocate.c_str());
return strResult;
}
std::wstring String2WString(const std::string& str) {
std::wstring wContext = L"";
int len = MultiByteToWideChar(CP_ACP, 0, str.c_str(), str.size(), NULL, 0);
WCHAR* buffer = new WCHAR[len + 1];
MultiByteToWideChar(CP_ACP, 0, str.c_str(), str.size(), buffer, len);
buffer[len] = '\0';
wContext.append(buffer);
delete[] buffer;
return wContext;
std::wstring wContext = L"";
int len = MultiByteToWideChar(CP_ACP, 0, str.c_str(), str.size(), NULL, 0);
WCHAR* buffer = new WCHAR[len + 1];
MultiByteToWideChar(CP_ACP, 0, str.c_str(), str.size(), buffer, len);
buffer[len] = '\0';
wContext.append(buffer);
delete[] buffer;
return wContext;
}
std::vector<std::string> SpiteStringCharacter(std::string context) {
std::vector<std::string> res;
std::wstring wContext = String2WString(context);
for (int i = 0; i < wContext.length(); i++) {
std::wstring tmp = wContext.substr(i, 1);
res.push_back(WString2String(tmp));
}
return res;
std::vector<std::string> res;
std::wstring wContext = String2WString(context);
for (int i = 0; i < wContext.length(); i++) {
std::wstring tmp = wContext.substr(i, 1);
res.push_back(WString2String(tmp));
}
return res;
}

292
Cigarette/common.h
Unescape Escape View File

@ -5,24 +5,24 @@
#include "basecamera.h"
#include "QtCore\qdatetime.h"
//#define __DEBUG //debug信息输出功能
//#define __UDPSend //网络发送功能
#define __TCPSend // TCP发送
#define USB_BASLER_NEW_FW //使用basler定制固件
//#define IMM_PROCESS //拍照后立马处理，不等校验信号
//#define IMM_FEED_BACK //处理完后立马反馈，不等校验信号
#define ONE_TIME_SHIFT //错开一拍发送反馈(默认错开两次)
#define AI_WARM_UP //AI识别开始前的热身动作
//#define LICENSE_VERIFY //开启license文件校验
//CAP_FEED_BACK和DOUBLE_FEED_BACK不要一起开
//#define __DEBUG //debug信息输出功能
//#define __UDPSend //网络发送功能
#define __TCPSend // TCP发送
#define USB_BASLER_NEW_FW //使用basler定制固件
//#define IMM_PROCESS //拍照后立马处理，不等校验信号
//#define IMM_FEED_BACK //处理完后立马反馈，不等校验信号
#define ONE_TIME_SHIFT //错开一拍发送反馈(默认错开两次)
#define AI_WARM_UP //AI识别开始前的热身动作
//#define LICENSE_VERIFY //开启license文件校验
//CAP_FEED_BACK和DOUBLE_FEED_BACK不要一起开
#if defined (ONE_TIME_SHIFT)
//#define CAP_FEED_BACK //拍照时也检测有没有测试结果，有的话就反馈
//#define DOUBLE_FEED_BACK //一次ng，两次反馈ng信号
//#define CAP_FEED_BACK //拍照时也检测有没有测试结果，有的话就反馈
//#define DOUBLE_FEED_BACK //一次ng，两次反馈ng信号
#endif
//#define identify_Hik_YSXID//识别海康相机YSXID
//#define __ExportData // 输出检测数据到XML文档
#define DRAW_RECT // 鼠标画框功能
#define SYNC_CAMERA //相机同步处理图片
//#define identify_Hik_YSXID//识别海康相机YSXID
//#define __ExportData // 输出检测数据到XML文档
#define DRAW_RECT // 鼠标画框功能
#define SYNC_CAMERA //相机同步处理图片
#define Queue_Size 15
#define Unit_Queue_Size Queue_Size*3
@ -34,24 +34,24 @@
#define DEBUG(format, ...)
#endif
// 主界面基本参数配置文件
// 主界面基本参数配置文件
#define CONFPATH "D:/conf/conf_path.txt"
//#define CONFIGURE_FILE "D:/conf/conf.txt"
// 相机旋转角度配置文件
// 相机旋转角度配置文件
#define ROTATE_FILE "rotate.txt"
#define MODBUS_CONFIGURE_FILE "modbus.txt"
#define PLC_CONFIG_FILE "plc.txt"
#define SELECT_RECTS_FILE "SelectRects%d%d.txt"
#define STATISTIC_FILE "camera%1_statistic.txt"
#define ALARM_RECORD_FILE "alarm.txt"
#define OUTPUT_HIGH_WIDTH 20000 //输出信号的脉冲宽度，微秒
#define OUTPUT_HIGH_WIDTH 20000 //输出信号的脉冲宽度，微秒
#define OP_TIME 300 //OP权限时长（默认300秒）
#define ADMIN_TIME 600 //ADMIN权限时长（默认300秒）
#define STOP_SECONDS 3 //检查多少次不变触发自动换班
#define OP_TIME 300 //OP权限时长（默认300秒）
#define ADMIN_TIME 600 //ADMIN权限时长（默认300秒）
#define STOP_SECONDS 3 //检查多少次不变触发自动换班
int string_split(std::string str, std::string pattern,std::vector<std::string> &out);
std::string format(const char *pszFmt, ...);
int string_split(std::string str, std::string pattern, std::vector<std::string>& out);
std::string format(const char* pszFmt, ...);
void getFiles(std::string path, std::vector<std::string>& files);
std::string SelectDirBRI();
std::string SelectFileOFN();
@ -63,156 +63,156 @@ std::vector<std::string> SpiteStringCharacter(std::string context);
class ConfPath {
public:
QString config_path; // 配置文件路径
//QString config_name; // 配置文件名
QString save_pics_path; // 保存图片存储路径
ConfPath(){
config_path = "";
//config_name = "";
save_pics_path = "";
}
QString config_path; // 配置文件路径
//QString config_name; // 配置文件名
QString save_pics_path; // 保存图片存储路径
ConfPath() {
config_path = "";
//config_name = "";
save_pics_path = "";
}
};
class SysConf
{
public:
std::mutex lock;
int save; //图片是否保存，0不保存，1保存NG, 2全部保存
int MisMatchAct; //错位行为，1：NG,0：ok
int save_days; ///照片保存天数
int freesize; /// 设定清理图片最小空间
std::string ComPort; ///COM口
int ConfThreshold; //识别率
int auto_open; //是否自动打开相机，0否，1是
int auto_work; //是否自动开始工作，0否，1是
int auto_shift; //是否自动换班，0否，1是
int shift_byhand; // 是否手动换班，0否，1是
QTime shiftA; //A换班时间
QTime shiftB; //B换班时间
QTime shiftC; //C换班时间
QString location; // 所在地
QString model_path; // 模型文件夹路径
QString model_name; // 模型名
QString model_jpg_path; // 模型图片路径
int timing_shift; //是否定时换班，0否，1是
int expo[NumberOfSupportedCameras]; //相机曝光时间，单位微秒
int gain[NumberOfSupportedCameras]; //相机模拟增益，范围0~64
int filter[NumberOfSupportedCameras];//相机滤波时间
int UserID[NumberOfSupportedCameras];
int no[NumberOfSupportedCameras][3];//拍摄图片最少合格胶点数
int shoot[NumberOfSupportedCameras];//拍摄次数
std::string MonitorIP; //远程监控端的IP
int MonitorPort;
int FeedbackPort;
int FilePort;
//MonitorPort为数据端口
//MonitorPort+NumberOfSupportedCameras为图像端口
//MonitorPort+NumberOfSupportedCameras*2为发送命令端口,也就是FeedbackPort
//MonitorPort+NumberOfSupportedCameras*2+1为接受命令端口
SysConf()
{
save=0; //图片是否保存，0不保存，1保存NG, 2全部保存
MisMatchAct=1; //错位行为，1：NG,0：ok
save_days = 1; ///照片保存天数
freesize = 10; /// 设定清理图片最小空间
ComPort = "COM1"; ///COM口
ConfThreshold = 1; ///百分比识别率
auto_open=1; //是否自动打开相机，0否，1是
auto_work=1; //是否自动开始工作，0否，1是
auto_shift=0; //是否自动换班，0否，1是
shift_byhand = 1; //是否手动换班，0否，1是
timing_shift = 0; //是否定时换班，0否，1是
location = "";
model_path = "";
model_name = "";
model_jpg_path = "";
shiftA.setHMS(0, 0, 0);
shiftB.setHMS(0, 0, 0);
shiftC.setHMS(0, 0, 0);
for(int i=0;i<NumberOfSupportedCameras;i++)
{
expo[i]=2000;
gain[i]=0;
filter[i]=500;
UserID[i]=0xff;
no[i][0]=0;
no[i][1]=0;
no[i][2]=0;
shoot[i]=4;
}
MonitorIP = "192.168.10.1";
FeedbackPort = MonitorPort + NumberOfSupportedCameras*2;
}
std::mutex lock;
int save; //图片是否保存，0不保存，1保存NG, 2全部保存
int MisMatchAct; //错位行为，1：NG,0：ok
int save_days; ///照片保存天数
int freesize; /// 设定清理图片最小空间
std::string ComPort; ///COM口
int ConfThreshold; //识别率
int auto_open; //是否自动打开相机，0否，1是
int auto_work; //是否自动开始工作，0否，1是
int auto_shift; //是否自动换班，0否，1是
int shift_byhand; // 是否手动换班，0否，1是
QTime shiftA; //A换班时间
QTime shiftB; //B换班时间
QTime shiftC; //C换班时间
QString location; // 所在地
QString model_path; // 模型文件夹路径
QString model_name; // 模型名
QString model_jpg_path; // 模型图片路径
int timing_shift; //是否定时换班，0否，1是
int expo[NumberOfSupportedCameras]; //相机曝光时间，单位微秒
int gain[NumberOfSupportedCameras]; //相机模拟增益，范围0~64
int filter[NumberOfSupportedCameras];//相机滤波时间
int UserID[NumberOfSupportedCameras];
int no[NumberOfSupportedCameras][3];//拍摄图片最少合格胶点数
int shoot[NumberOfSupportedCameras];//拍摄次数
std::string MonitorIP; //远程监控端的IP
int MonitorPort;
int FeedbackPort;
int FilePort;
//MonitorPort为数据端口
//MonitorPort+NumberOfSupportedCameras为图像端口
//MonitorPort+NumberOfSupportedCameras*2为发送命令端口,也就是FeedbackPort
//MonitorPort+NumberOfSupportedCameras*2+1为接受命令端口
SysConf()
{
save = 0; //图片是否保存，0不保存，1保存NG, 2全部保存
MisMatchAct = 1; //错位行为，1：NG,0：ok
save_days = 1; ///照片保存天数
freesize = 10; /// 设定清理图片最小空间
ComPort = "COM1"; ///COM口
ConfThreshold = 1; ///百分比识别率
auto_open = 1; //是否自动打开相机，0否，1是
auto_work = 1; //是否自动开始工作，0否，1是
auto_shift = 0; //是否自动换班，0否，1是
shift_byhand = 1; //是否手动换班，0否，1是
timing_shift = 0; //是否定时换班，0否，1是
location = "";
model_path = "";
model_name = "";
model_jpg_path = "";
shiftA.setHMS(0, 0, 0);
shiftB.setHMS(0, 0, 0);
shiftC.setHMS(0, 0, 0);
for (int i = 0; i < NumberOfSupportedCameras; i++)
{
expo[i] = 2000;
gain[i] = 0;
filter[i] = 500;
UserID[i] = 0xff;
no[i][0] = 0;
no[i][1] = 0;
no[i][2] = 0;
shoot[i] = 4;
}
MonitorIP = "192.168.10.1";
FeedbackPort = MonitorPort + NumberOfSupportedCameras * 2;
}
};
#ifdef SYNC_CAMERA
class ImageSyncArr
{
public:
std::mutex lock;
std::vector<std::pair<int, cv::Mat>> image_sync_arr = std::vector<std::pair<int, cv::Mat>>(NumberOfSupportedCameras);
uint8_t collect_cnt;
ImageSyncArr()
{
collect_cnt = 0;
}
std::mutex lock;
std::vector<std::pair<int, cv::Mat>> image_sync_arr = std::vector<std::pair<int, cv::Mat>>(NumberOfSupportedCameras);
uint8_t collect_cnt;
ImageSyncArr()
{
collect_cnt = 0;
}
};
#endif
//Modbus地址设置
//Modbus地址设置
class ModbusConf
{
public:
int kick[NumberOfSupportedCameras];
int quantity; //当班产量地址
int shift; //换班地址
int work; //开始/停止
int no_kick; //只拍照不剔除模式
int debug; //调试模式，PLC产生模拟的line4信号
int reset; //复位
int alarm; //报警
ModbusConf()
{
for (int i = 0; i < NumberOfSupportedCameras; i++) {
int kick[NumberOfSupportedCameras];
int quantity; //当班产量地址
int shift; //换班地址
int work; //开始/停止
int no_kick; //只拍照不剔除模式
int debug; //调试模式，PLC产生模拟的line4信号
int reset; //复位
int alarm; //报警
ModbusConf()
{
for (int i = 0; i < NumberOfSupportedCameras; i++) {
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras > i)
kick[i] = 0;
kick[i] = 0;
#endif
}
quantity=0; //当班产量地址
shift=0; //换班地址
work=0; //开始/停止
no_kick=0; //只拍照不剔除模式
debug=0; //调试模式，PLC产生模拟的line4信号
reset=0; //复位
alarm=0; //报警
}
}
quantity = 0; //当班产量地址
shift = 0; //换班地址
work = 0; //开始/停止
no_kick = 0; //只拍照不剔除模式
debug = 0; //调试模式，PLC产生模拟的line4信号
reset = 0; //复位
alarm = 0; //报警
}
};
#define DisplayLabel_Type_Bit 0x01 //1:打开范围识别功能，0:关闭范围识别功能
#define DisplayLabel_Conf_Bit 0x02 //1:可以绘制矩形框，0:不能绘制矩形框
#define DisplayLabel_Type_Bit 0x01 //1:打开范围识别功能，0:关闭范围识别功能
#define DisplayLabel_Conf_Bit 0x02 //1:可以绘制矩形框，0:不能绘制矩形框
class RectRatio
{
public:
RectRatio(cv::Point2f tl, cv::Point2f br) :TL(tl), BR(br) {};
cv::Point2f TL;
cv::Point2f BR;
RectRatio(cv::Point2f tl, cv::Point2f br) :TL(tl), BR(br) {};
cv::Point2f TL;
cv::Point2f BR;
};
class DisplayLabelConf
{
public:
std::mutex lock;
bool leftButtonDownFlag = false; //左键单击后视频暂停播放的标志位
cv::Point2f originalPoint; //矩形框起点
cv::Point2f processPoint; //矩形框终点
cv::Mat g_last_mat[2];
bool g_max[2] = {false}; //视图是否最大化
uint8_t Flag[2] = {0};
std::vector<RectRatio> RectVet[2];
std::mutex lock;
bool leftButtonDownFlag = false; //左键单击后视频暂停播放的标志位
cv::Point2f originalPoint; //矩形框起点
cv::Point2f processPoint; //矩形框终点
cv::Mat g_last_mat[2];
bool g_max[2] = { false }; //视图是否最大化
uint8_t Flag[2] = { 0 };
std::vector<RectRatio> RectVet[2];
};
void DrawSelectRects(cv::Mat input, DisplayLabelConf& t_DisplayLabelConf, int Cnt);
bool CheckSelectRects(cv::Mat input, std::vector<std::vector<std::pair<int, cv::Rect> > >& VecRects, int VecCnt, DisplayLabelConf& t_DisplayLabelConf, int LabelCnt);

14
Cigarette/db_label.cpp
Unescape Escape View File

@ -1,12 +1,12 @@
//qlabel_doubleclick.cpp
#include "db_label.h"
#include <QDebug>
db_label::db_label(QWidget *parent) : QLabel(parent){
db_label::db_label(QWidget* parent) : QLabel(parent) {
setFocusPolicy(Qt::StrongFocus);
connect(&timer, SIGNAL(timeout()), this, SLOT(TimeOutNotify()));
}
db_label::~db_label(){}
db_label::~db_label() {}
void db_label::mouseDoubleClickEvent(QMouseEvent* event) {
emit SignalmouseDoubleClickEvent(event);
@ -34,11 +34,11 @@ void db_label::keyReleaseEvent(QKeyEvent* event)
void db_label::TimeOutNotify(void) {
timer.stop();
switch(cnt) {
case 1:emit QlabelClick(); break;
case 2:emit QlabelDoubleClick(); break;
case 3:emit QlabelTripleClick(); break;
default:break;
switch (cnt) {
case 1:emit QlabelClick(); break;
case 2:emit QlabelDoubleClick(); break;
case 3:emit QlabelTripleClick(); break;
default:break;
}
cnt = 0;
}

4
Cigarette/db_label.h
Unescape Escape View File

@ -12,10 +12,10 @@ class db_label : public QLabel
Q_OBJECT
public:
db_label(QWidget *parent = 0);
db_label(QWidget* parent = 0);
~db_label();
void mouseDoubleClickEvent(QMouseEvent *event);
void mouseDoubleClickEvent(QMouseEvent* event);
void mousePressEvent(QMouseEvent* event);
void mouseReleaseEvent(QMouseEvent* event);
void mouseMoveEvent(QMouseEvent* event);

111
Cigarette/debugthread.h
Unescape Escape View File

@ -11,85 +11,84 @@
#include "balluffcamera.h"
#include "hikcamera.h"
extern SyncQueue<cv::Mat> *g_debug_queue[NumberOfSupportedCameras]; //相机调试模式图像队列
extern SyncQueue<cv::Mat>* g_debug_queue[NumberOfSupportedCameras]; //相机调试模式图像队列
extern DisplayLabelConf g_display_label_conf[NumberOfSupportedCameras];
extern SingleCamInfoStruct SingleCamInfo[NumberOfSupportedCameras];
extern int rotationAngle[NumberOfSupportedCameras]; //图片旋转角度
extern bool isNeedRotate[NumberOfSupportedCameras];
class DebugThread : public QThread
{
Q_OBJECT
Q_OBJECT
signals:
void notify(int Num,int Cnt,cv::Mat);
void notify(int Num, int Cnt, cv::Mat);
public:
DebugThread(QObject *parent = 0): QThread(parent)
{
DebugThread(QObject* parent = 0) : QThread(parent)
{
}
~DebugThread()
{
stop();
p_debug_queue->put(cv::Mat());
quit();
wait();
}
void init(SyncQueue<cv::Mat> *ptr,int Num)
{
local_camera_number = Num;
b_quit = false;
p_debug_queue = ptr;
}
void start_work()
{
start(HighestPriority);
}
void stop()
{
b_quit = true;
}
}
~DebugThread()
{
stop();
p_debug_queue->put(cv::Mat());
quit();
wait();
}
void init(SyncQueue<cv::Mat>* ptr, int Num)
{
local_camera_number = Num;
b_quit = false;
p_debug_queue = ptr;
}
void start_work()
{
start(HighestPriority);
}
void stop()
{
b_quit = true;
}
protected:
void run()
{
while (!b_quit) {
cv::Mat image;
p_debug_queue->take(image);
if (image.data)
{
while (!b_quit) {
cv::Mat image;
p_debug_queue->take(image);
if (image.data)
{
//cv::cvtColor(image, image, CV_BGR2RGB); //灰度图像转为彩色图像
// 解决进入调试模式海康彩色相机变色，关闭色彩调整巴鲁夫相机变黑的问题
if (image.channels() == 1)
{
//cv::cvtColor(image, image, CV_BGR2RGB); //灰度图像转为彩色图像
// 解决进入调试模式海康彩色相机变色，关闭色彩调整巴鲁夫相机变黑的问题
if (image.channels() == 1)
cv::cvtColor(image, image, CV_BGR2RGB); //灰度图像转为彩色图像
}
if (isNeedRotate[local_camera_number]) {
if (rotationAngle[local_camera_number] != (cv::ROTATE_90_COUNTERCLOCKWISE + 1))
{
cv::cvtColor(image, image, CV_BGR2RGB); //灰度图像转为彩色图像
}
if (isNeedRotate[local_camera_number]) {
if(rotationAngle[local_camera_number] != (cv::ROTATE_90_COUNTERCLOCKWISE + 1))
{
cv::rotate(image, image, rotationAngle[local_camera_number]);
}
cv::rotate(image, image, rotationAngle[local_camera_number]);
}
//sleep(100);
emit notify(local_camera_number,0,image);
}
//sleep(100);
emit notify(local_camera_number, 0, image);
}
#ifdef DRAW_RECT
std::lock_guard<std::mutex> locker2(g_display_label_conf[local_camera_number].lock);
local_DisplayLabelConf.leftButtonDownFlag = g_display_label_conf[local_camera_number].leftButtonDownFlag;
local_DisplayLabelConf.Flag[0] = g_display_label_conf[local_camera_number].Flag[0];
local_DisplayLabelConf.Flag[1] = g_display_label_conf[local_camera_number].Flag[1];
local_DisplayLabelConf.originalPoint = g_display_label_conf[local_camera_number].originalPoint;
local_DisplayLabelConf.processPoint = g_display_label_conf[local_camera_number].processPoint;
local_DisplayLabelConf.RectVet[0] = g_display_label_conf[local_camera_number].RectVet[0];
local_DisplayLabelConf.RectVet[1] = g_display_label_conf[local_camera_number].RectVet[1];
std::lock_guard<std::mutex> locker2(g_display_label_conf[local_camera_number].lock);
local_DisplayLabelConf.leftButtonDownFlag = g_display_label_conf[local_camera_number].leftButtonDownFlag;
local_DisplayLabelConf.Flag[0] = g_display_label_conf[local_camera_number].Flag[0];
local_DisplayLabelConf.Flag[1] = g_display_label_conf[local_camera_number].Flag[1];
local_DisplayLabelConf.originalPoint = g_display_label_conf[local_camera_number].originalPoint;
local_DisplayLabelConf.processPoint = g_display_label_conf[local_camera_number].processPoint;
local_DisplayLabelConf.RectVet[0] = g_display_label_conf[local_camera_number].RectVet[0];
local_DisplayLabelConf.RectVet[1] = g_display_label_conf[local_camera_number].RectVet[1];
DrawSelectRects(image, local_DisplayLabelConf, 0);
DrawSelectRects(image, local_DisplayLabelConf, 0);
#endif
}
}
}
public:
int local_camera_number;
int local_classid;
bool b_quit;
SyncQueue<cv::Mat> *p_debug_queue;
SyncQueue<cv::Mat>* p_debug_queue;
DisplayLabelConf local_DisplayLabelConf;
};

89
Cigarette/dialogin.cpp
Unescape Escape View File

@ -1,19 +1,16 @@
#include "dialogin.hpp"
#include "dialogin.hpp"
#include <QCryptographicHash>
#include <qdebug.h>
#include <qmessagebox.h>
extern bool g_op_mode; //是否操作员模式
extern QString g_op_pswd; //操作员密码
Dialogin::Dialogin(QWidget * parent) : QDialog(parent) {
ui.setupUi(this);
m_pswd = "";
this->setWindowFlags(Qt::FramelessWindowHint);
Dialogin::Dialogin(QWidget* parent) : QDialog(parent) {
ui.setupUi(this);
m_pswd = "";
this->setWindowFlags(Qt::FramelessWindowHint);
}
Dialogin::~Dialogin() {
@ -22,78 +19,78 @@ Dialogin::~Dialogin() {
void Dialogin::on_pushButton_close_released()
{
this->close();
this->close();
}
void Dialogin::on_pushButton_clr_released()
{
m_pswd = "";
ui.lineEdit->setText("");
m_pswd = "";
ui.lineEdit->setText("");
}
void Dialogin::on_pushButton_ok_released()
{
QString md5Str = QCryptographicHash::hash(m_pswd.toLatin1(), QCryptographicHash::Md5).toHex();
qDebug() << "m_pswd_op:" << m_pswd;
qDebug() << "m_pswd_op md5:" << md5Str;
qDebug() << "g_admin_pswd_op md5:" << g_op_pswd;
if (md5Str.compare(g_op_pswd, Qt::CaseInsensitive) == 0)
{
g_op_mode = true;
//QMessageBox::information(NULL, QStringLiteral("提示消息"), QStringLiteral("验证通过，进入管理员模式"), QMessageBox::Ok);
emit enter_op();
this->close();
}
else {
QMessageBox::information(NULL, QStringLiteral("提示消息"), QStringLiteral("密码错误，请重新输入"), QMessageBox::Ok);
on_pushButton_clr_released();
}
QString md5Str = QCryptographicHash::hash(m_pswd.toLatin1(), QCryptographicHash::Md5).toHex();
qDebug() << "m_pswd_op:" << m_pswd;
qDebug() << "m_pswd_op md5:" << md5Str;
qDebug() << "g_admin_pswd_op md5:" << g_op_pswd;
if (md5Str.compare(g_op_pswd, Qt::CaseInsensitive) == 0)
{
g_op_mode = true;
//QMessageBox::information(NULL, QStringLiteral("提示消息"), QStringLiteral("验证通过，进入管理员模式"), QMessageBox::Ok);
emit enter_op();
this->close();
}
else {
QMessageBox::information(NULL, QStringLiteral("提示消息"), QStringLiteral("密码错误，请重新输入"), QMessageBox::Ok);
on_pushButton_clr_released();
}
}
void Dialogin::on_pushButton_0_released()
{
m_pswd += "0";
ui.lineEdit->setText(ui.lineEdit->text() + "*");
m_pswd += "0";
ui.lineEdit->setText(ui.lineEdit->text() + "*");
}
void Dialogin::on_pushButton_1_released()
{
m_pswd += "1";
ui.lineEdit->setText(ui.lineEdit->text() + "*");
m_pswd += "1";
ui.lineEdit->setText(ui.lineEdit->text() + "*");
}
void Dialogin::on_pushButton_2_released()
{
m_pswd += "2";
ui.lineEdit->setText(ui.lineEdit->text() + "*");
m_pswd += "2";
ui.lineEdit->setText(ui.lineEdit->text() + "*");
}
void Dialogin::on_pushButton_3_released()
{
m_pswd += "3";
ui.lineEdit->setText(ui.lineEdit->text() + "*");
m_pswd += "3";
ui.lineEdit->setText(ui.lineEdit->text() + "*");
}
void Dialogin::on_pushButton_4_released()
{
m_pswd += "4";
ui.lineEdit->setText(ui.lineEdit->text() + "*");
m_pswd += "4";
ui.lineEdit->setText(ui.lineEdit->text() + "*");
}
void Dialogin::on_pushButton_5_released()
{
m_pswd += "5";
ui.lineEdit->setText(ui.lineEdit->text() + "*");
m_pswd += "5";
ui.lineEdit->setText(ui.lineEdit->text() + "*");
}
void Dialogin::on_pushButton_6_released()
{
m_pswd += "6";
ui.lineEdit->setText(ui.lineEdit->text() + "*");
m_pswd += "6";
ui.lineEdit->setText(ui.lineEdit->text() + "*");
}
void Dialogin::on_pushButton_7_released()
{
m_pswd += "7";
ui.lineEdit->setText(ui.lineEdit->text() + "*");
m_pswd += "7";
ui.lineEdit->setText(ui.lineEdit->text() + "*");
}
void Dialogin::on_pushButton_8_released()
{
m_pswd += "8";
ui.lineEdit->setText(ui.lineEdit->text() + "*");
m_pswd += "8";
ui.lineEdit->setText(ui.lineEdit->text() + "*");
}
void Dialogin::on_pushButton_9_released()
{
m_pswd += "9";
ui.lineEdit->setText(ui.lineEdit->text() + "*");
m_pswd += "9";
ui.lineEdit->setText(ui.lineEdit->text() + "*");
}

44
Cigarette/dialogin.hpp
Unescape Escape View File

@ -1,34 +1,34 @@
#pragma once
#pragma once
#include <QDialog>
#include "ui_dialogin.h"
class Dialogin : public QDialog {
Q_OBJECT
signals :
void enter_op();
Q_OBJECT
signals:
void enter_op();
public:
Dialogin(QWidget * parent = Q_NULLPTR);
~Dialogin();
Dialogin(QWidget* parent = Q_NULLPTR);
~Dialogin();
private slots :
void on_pushButton_close_released();
void on_pushButton_clr_released();
void on_pushButton_ok_released();
void on_pushButton_0_released();
void on_pushButton_1_released();
void on_pushButton_2_released();
void on_pushButton_3_released();
void on_pushButton_4_released();
void on_pushButton_5_released();
void on_pushButton_6_released();
void on_pushButton_7_released();
void on_pushButton_8_released();
void on_pushButton_9_released();
private slots:
void on_pushButton_close_released();
void on_pushButton_clr_released();
void on_pushButton_ok_released();
void on_pushButton_0_released();
void on_pushButton_1_released();
void on_pushButton_2_released();
void on_pushButton_3_released();
void on_pushButton_4_released();
void on_pushButton_5_released();
void on_pushButton_6_released();
void on_pushButton_7_released();
void on_pushButton_8_released();
void on_pushButton_9_released();
public:
QString m_pswd;
QString m_pswd;
private:
Ui::Dialogin ui;
Ui::Dialogin ui;
};

1324
Cigarette/dialogsetup.cpp
View File

File diff suppressed because it is too large Load Diff

110
Cigarette/dialogsetup.hpp
Unescape Escape View File

@ -1,73 +1,73 @@
#pragma once
#pragma once
#include <QDialog>
#include "ui_dialogsetup.h"
#include "basecamera.h"
#include <qdebug.h>
#include <common.h>
#include <camera_glue.h>
#include <output_statistic.h>
#include <change_shift.h>
#include "common.h"
#include "camera_glue.h"
#include "output_statistic.h"
#include "change_shift.h"
class DialogSetup : public QDialog {
Q_OBJECT
signals :
void system_exit();
void sendMsgToShift(QTime timeA, QTime timeB, QTime timeC);
void sendMsgToOutput();
void sendMsgToConfig(int ptr[][3]);
Q_OBJECT
signals:
void system_exit();
void sendMsgToShift(QTime timeA, QTime timeB, QTime timeC);
void sendMsgToOutput();
void sendMsgToConfig(int ptr[][3]);
#ifdef __DEBUG
void _testimg();
void _testimgs();
void _testimg();
void _testimgs();
#endif
private slots :
void on_toolButton_keyboard_released();
void on_pushButton_exit_released();
void on_pushButton_save_released();
void on_pushButton_close_released();
void on_toolButton_choose_config_path_released();
void on_toolButton_choose_model_path_released();
void on_toolButton_choose_path_jpg_released();
void on_toolButton_choose_save_pics_path_released();
void on_pushButton_desktop_released();
void on_pushButton_image_released();
void on_pushButton_pswd_released();
void on_pushButton_pswd_op_released();
void on_pushButton_expo_released();
void on_pushButton_filter_released();
void on_pushButton_clear_pic_released();
private slots:
void on_toolButton_keyboard_released();
void on_pushButton_exit_released();
void on_pushButton_save_released();
void on_pushButton_close_released();
void on_toolButton_choose_config_path_released();
void on_toolButton_choose_model_path_released();
void on_toolButton_choose_path_jpg_released();
void on_toolButton_choose_save_pics_path_released();
void on_pushButton_desktop_released();
void on_pushButton_image_released();
void on_pushButton_pswd_released();
void on_pushButton_pswd_op_released();
void on_pushButton_expo_released();
void on_pushButton_filter_released();
void on_pushButton_clear_pic_released();
void on_pushButton_config_released();
void on_pushButton_change_released();
void on_pushButton_statistic_released();
void on_pushButton_config_released();
void on_pushButton_change_released();
void on_pushButton_statistic_released();
void on_checkBox_auto_open_clicked(bool checked);
void on_checkBox_auto_work_clicked(bool checked);
void on_checkBox_auto_open_clicked(bool checked);
void on_checkBox_auto_work_clicked(bool checked);
void recMsgFromDialogConfig(int ptr[][3]);
void recMsgFromChangeShift(QTime timeA, QTime timeB, QTime timeC);
void onComboBoxSelect(int index);
void onComboBoxConfSelect(int index);
void onComboBoxPicsPathSelect(int index);
void recMsgFromDialogConfig(int ptr[][3]);
void recMsgFromChangeShift(QTime timeA, QTime timeB, QTime timeC);
void onComboBoxSelect(int index);
void onComboBoxConfSelect(int index);
void onComboBoxPicsPathSelect(int index);
#ifdef __DEBUG
void on_pushButton_testimg_released();
void on_pushButton_testimgs_released();
void on_pushButton_testimg_released();
void on_pushButton_testimgs_released();
#endif
public:
DialogSetup(QWidget * parent = Q_NULLPTR);
~DialogSetup();
QLineEdit *lineEdit_expo_mat[NumberOfSupportedCameras];
QLineEdit *lineEdit_gain_mat[NumberOfSupportedCameras];
QLineEdit *lineEdit_filter_mat[NumberOfSupportedCameras];
void InitPtrMat();
static void write_pswd();
static void write_pswd_op();
static void write_config();
static void write_conf_path();
DialogSetup(QWidget* parent = Q_NULLPTR);
~DialogSetup();
QLineEdit* lineEdit_expo_mat[NumberOfSupportedCameras];
QLineEdit* lineEdit_gain_mat[NumberOfSupportedCameras];
QLineEdit* lineEdit_filter_mat[NumberOfSupportedCameras];
void InitPtrMat();
static void write_pswd();
static void write_pswd_op();
static void write_config();
static void write_conf_path();
public:
camera_glue *m_camera_glue=NULL;
change_shift *m_change_shift=NULL;
output_statistic *m_output_statistic=NULL;
camera_glue* m_camera_glue = NULL;
change_shift* m_change_shift = NULL;
output_statistic* m_output_statistic = NULL;
private:
Ui::DialogSetup ui;
Ui::DialogSetup ui;
};

86
Cigarette/dialogsetuppasswd.cpp
Unescape Escape View File

@ -1,4 +1,4 @@
#include "dialogsetuppasswd.hpp"
#include "dialogsetuppasswd.hpp"
#include <QCryptographicHash>
@ -9,10 +9,10 @@
extern bool g_admin_mode; //是否管理员模式
extern QString g_admin_pswd; //管理员密码
DialogSetupPasswd::DialogSetupPasswd(QWidget * parent) : QDialog(parent) {
ui.setupUi(this);
m_pswd = "";
this->setWindowFlags(Qt::FramelessWindowHint);
DialogSetupPasswd::DialogSetupPasswd(QWidget* parent) : QDialog(parent) {
ui.setupUi(this);
m_pswd = "";
this->setWindowFlags(Qt::FramelessWindowHint);
}
DialogSetupPasswd::~DialogSetupPasswd() {
@ -21,78 +21,78 @@ DialogSetupPasswd::~DialogSetupPasswd() {
void DialogSetupPasswd::on_pushButton_close_released()
{
this->close();
this->close();
}
void DialogSetupPasswd::on_pushButton_clr_released()
{
m_pswd = "";
ui.lineEdit->setText("");
m_pswd = "";
ui.lineEdit->setText("");
}
void DialogSetupPasswd::on_pushButton_ok_released()
{
QString md5Str = QCryptographicHash::hash(m_pswd.toLatin1(), QCryptographicHash::Md5).toHex();
qDebug() << "m_pswd:" << m_pswd;
qDebug() << "m_pswd md5:" << md5Str;
qDebug() << "g_admin_pswd md5:" << g_admin_pswd;
if (md5Str.compare(g_admin_pswd, Qt::CaseInsensitive) == 0)
{
g_admin_mode = true;
//QMessageBox::information(NULL, QStringLiteral("提示消息"), QStringLiteral("验证通过，进入管理员模式"), QMessageBox::Ok);
emit enter_admin();
this->close();
}
else {
QMessageBox::information(NULL, QStringLiteral("提示消息"), QStringLiteral("密码错误，请重新输入"), QMessageBox::Ok);
on_pushButton_clr_released();
}
QString md5Str = QCryptographicHash::hash(m_pswd.toLatin1(), QCryptographicHash::Md5).toHex();
qDebug() << "m_pswd:" << m_pswd;
qDebug() << "m_pswd md5:" << md5Str;
qDebug() << "g_admin_pswd md5:" << g_admin_pswd;
if (md5Str.compare(g_admin_pswd, Qt::CaseInsensitive) == 0)
{
g_admin_mode = true;
//QMessageBox::information(NULL, QStringLiteral("提示消息"), QStringLiteral("验证通过，进入管理员模式"), QMessageBox::Ok);
emit enter_admin();
this->close();
}
else {
QMessageBox::information(NULL, QStringLiteral("提示消息"), QStringLiteral("密码错误，请重新输入"), QMessageBox::Ok);
on_pushButton_clr_released();
}
}
void DialogSetupPasswd::on_pushButton_0_released()
{
m_pswd += "0";
ui.lineEdit->setText(ui.lineEdit->text() + "*");
m_pswd += "0";
ui.lineEdit->setText(ui.lineEdit->text() + "*");
}
void DialogSetupPasswd::on_pushButton_1_released()
{
m_pswd += "1";
ui.lineEdit->setText(ui.lineEdit->text() + "*");
m_pswd += "1";
ui.lineEdit->setText(ui.lineEdit->text() + "*");
}
void DialogSetupPasswd::on_pushButton_2_released()
{
m_pswd += "2";
ui.lineEdit->setText(ui.lineEdit->text() + "*");
m_pswd += "2";
ui.lineEdit->setText(ui.lineEdit->text() + "*");
}
void DialogSetupPasswd::on_pushButton_3_released()
{
m_pswd += "3";
ui.lineEdit->setText(ui.lineEdit->text() + "*");
m_pswd += "3";
ui.lineEdit->setText(ui.lineEdit->text() + "*");
}
void DialogSetupPasswd::on_pushButton_4_released()
{
m_pswd += "4";
ui.lineEdit->setText(ui.lineEdit->text() + "*");
m_pswd += "4";
ui.lineEdit->setText(ui.lineEdit->text() + "*");
}
void DialogSetupPasswd::on_pushButton_5_released()
{
m_pswd += "5";
ui.lineEdit->setText(ui.lineEdit->text() + "*");
m_pswd += "5";
ui.lineEdit->setText(ui.lineEdit->text() + "*");
}
void DialogSetupPasswd::on_pushButton_6_released()
{
m_pswd += "6";
ui.lineEdit->setText(ui.lineEdit->text() + "*");
m_pswd += "6";
ui.lineEdit->setText(ui.lineEdit->text() + "*");
}
void DialogSetupPasswd::on_pushButton_7_released()
{
m_pswd += "7";
ui.lineEdit->setText(ui.lineEdit->text() + "*");
m_pswd += "7";
ui.lineEdit->setText(ui.lineEdit->text() + "*");
}
void DialogSetupPasswd::on_pushButton_8_released()
{
m_pswd += "8";
ui.lineEdit->setText(ui.lineEdit->text() + "*");
m_pswd += "8";
ui.lineEdit->setText(ui.lineEdit->text() + "*");
}
void DialogSetupPasswd::on_pushButton_9_released()
{
m_pswd += "9";
ui.lineEdit->setText(ui.lineEdit->text() + "*");
m_pswd += "9";
ui.lineEdit->setText(ui.lineEdit->text() + "*");
}

44
Cigarette/dialogsetuppasswd.hpp
Unescape Escape View File

@ -1,35 +1,35 @@
#pragma once
#pragma once
#include <QDialog>
#include "ui_dialogsetuppasswd.h"
class DialogSetupPasswd : public QDialog {
Q_OBJECT
signals :
void enter_admin();
Q_OBJECT
signals:
void enter_admin();
public:
DialogSetupPasswd(QWidget * parent = Q_NULLPTR);
~DialogSetupPasswd();
DialogSetupPasswd(QWidget* parent = Q_NULLPTR);
~DialogSetupPasswd();
private slots :
void on_pushButton_close_released();
void on_pushButton_clr_released();
void on_pushButton_ok_released();
void on_pushButton_0_released();
void on_pushButton_1_released();
void on_pushButton_2_released();
void on_pushButton_3_released();
void on_pushButton_4_released();
void on_pushButton_5_released();
void on_pushButton_6_released();
void on_pushButton_7_released();
void on_pushButton_8_released();
void on_pushButton_9_released();
private slots:
void on_pushButton_close_released();
void on_pushButton_clr_released();
void on_pushButton_ok_released();
void on_pushButton_0_released();
void on_pushButton_1_released();
void on_pushButton_2_released();
void on_pushButton_3_released();
void on_pushButton_4_released();
void on_pushButton_5_released();
void on_pushButton_6_released();
void on_pushButton_7_released();
void on_pushButton_8_released();
void on_pushButton_9_released();
public:
QString m_pswd;
QString m_pswd;
private:
Ui::DialogSetupPasswd ui;
Ui::DialogSetupPasswd ui;
};

604
Cigarette/exportData.cpp
Unescape Escape View File

@ -16,347 +16,347 @@ extern bool flag;
ExportDataThread::ExportDataThread(QObject* parent) : QThread(parent)
{
cg->read_conf(g_conf_path);
for (int index = 0; index < NumberOfSupportedCameras; index++)
{
XMLError error;
pDocument[index] = new tinyxml2::XMLDocument();
QString xmlPath = QString(EXPORTDATA_FILE).arg(index);
QString filePath = g_conf_path.config_path + "/" + xmlPath;
error = pDocument[index]->LoadFile(filePath.toLocal8Bit().constData());
if (error != XML_SUCCESS) {
XMLDeclaration* declaration = pDocument[index]->NewDeclaration();
pDocument[index]->InsertFirstChild(declaration);
}
}
hint = InternetOpen(0, INTERNET_OPEN_TYPE_PRECONFIG, 0, 0, 0);
if (hint == NULL) {
return;
}
if (!ConnectFtp())
qDebug() << "First connect FTP failed because " << GetLastError();
cg->read_conf(g_conf_path);
for (int index = 0; index < NumberOfSupportedCameras; index++)
{
XMLError error;
pDocument[index] = new tinyxml2::XMLDocument();
QString xmlPath = QString(EXPORTDATA_FILE).arg(index);
QString filePath = g_conf_path.config_path + "/" + xmlPath;
error = pDocument[index]->LoadFile(filePath.toLocal8Bit().constData());
if (error != XML_SUCCESS) {
XMLDeclaration* declaration = pDocument[index]->NewDeclaration();
pDocument[index]->InsertFirstChild(declaration);
}
}
hint = InternetOpen(0, INTERNET_OPEN_TYPE_PRECONFIG, 0, 0, 0);
if (hint == NULL) {
return;
}
if (!ConnectFtp())
qDebug() << "First connect FTP failed because " << GetLastError();
}
void ExportDataThread::init()
{
b_quit = false;
flag = false;
b_quit = false;
flag = false;
}
void ExportDataThread::start_work()
{
start(HighestPriority);
start(HighestPriority);
}
void ExportDataThread::stop()
{
b_quit = true;
_XMLExportDataInfo data;
export_XMLData_Info_queue->put(data);
InternetCloseHandle(hftp);
InternetCloseHandle(hint);
b_quit = true;
_XMLExportDataInfo data;
export_XMLData_Info_queue->put(data);
InternetCloseHandle(hftp);
InternetCloseHandle(hint);
}
bool ExportDataThread::ConnectFtp() {
// FTP地址
string ftpServer = "192.168.1.170";
/* 端口号，一般为21 */
int port = 666;
/* 用户名 */
string userName = "FTP2";
/* 密码 */
string pwd = "123";
if (hftp != NULL) {
InternetCloseHandle(hftp);
hftp = NULL;
}
// 创建ftp连接
hftp = InternetConnectA(hint, ftpServer.c_str(), port, userName.c_str(), pwd.c_str(), INTERNET_SERVICE_FTP, 0, 0);
if (hftp == NULL) {
qDebug() << "ftp connect failed because " << GetLastError();
return false;
}
else
qDebug() << "ftp reconnect success";
return true;
// FTP地址
string ftpServer = "192.168.1.170";
/* 端口号，一般为21 */
int port = 666;
/* 用户名 */
string userName = "FTP2";
/* 密码 */
string pwd = "123";
if (hftp != NULL) {
InternetCloseHandle(hftp);
hftp = NULL;
}
// 创建ftp连接
hftp = InternetConnectA(hint, ftpServer.c_str(), port, userName.c_str(), pwd.c_str(), INTERNET_SERVICE_FTP, 0, 0);
if (hftp == NULL) {
qDebug() << "ftp connect failed because " << GetLastError();
return false;
}
else
qDebug() << "ftp reconnect success";
return true;
}
bool _ExportDataInfo::getAverageData(map<string, float> &averageData, int index)
bool _ExportDataInfo::getAverageData(map<string, float>& averageData, int index)
{
tinyxml2::XMLDocument doc;
//char xmlPath[256];
XMLError error;
map<string, float> data;
//memset(xmlPath, 0, 256);
QString xmlPath = QString(EXPORTDATA_FILE).arg(index);
//sprintf(xmlPath, EXPORTDATA_FILE, index);
QString filePath = g_conf_path.config_path + "/" + xmlPath;
error = doc.LoadFile(filePath.toLocal8Bit().constData());
if (error != XML_SUCCESS)
if (doc.LoadFile(filePath.toLocal8Bit().constData()) != 0)
{
cout << "load xml file failed" << endl;
return false;
}
XMLElement* root = doc.RootElement();
XMLElement* userNode = root->FirstChildElement("Camera");
data["CameraId"] = index;
data["IsNG"] = 0;
data["IsJdExist"] = 0;
data["Total"] = 0;
while (userNode != NULL)
{
if (atoi(userNode->Attribute("Id")) == index) {
data["IsNG"]++;
data["IsJdExist"]++;
data["Total"]++;
XMLElement* IsNgNode = userNode->FirstChildElement("IsNG");
data["IsNg"] = strcmp(IsNgNode->GetText(), "TRUE");
XMLElement* IsJdExistNode = userNode->FirstChildElement("IsJdExist");
if (strcmp(IsJdExistNode->GetText(), "TRUE") == 0)
data["IsJdExist"]++;
XMLElement* TimeCostNode = userNode->FirstChildElement("TimeCost");
data["TimeCost"] += stof(TimeCostNode->GetText());
}
userNode = userNode->NextSiblingElement();//下一个兄弟节点
}
if (data["Total"] == 0)
return false;
data["TimeCost"] = data["TimeCost"] / data["Total"];
averageData = data;
return true;
tinyxml2::XMLDocument doc;
//char xmlPath[256];
XMLError error;
map<string, float> data;
//memset(xmlPath, 0, 256);
QString xmlPath = QString(EXPORTDATA_FILE).arg(index);
//sprintf(xmlPath, EXPORTDATA_FILE, index);
QString filePath = g_conf_path.config_path + "/" + xmlPath;
error = doc.LoadFile(filePath.toLocal8Bit().constData());
if (error != XML_SUCCESS)
if (doc.LoadFile(filePath.toLocal8Bit().constData()) != 0)
{
cout << "load xml file failed" << endl;
return false;
}
XMLElement* root = doc.RootElement();
XMLElement* userNode = root->FirstChildElement("Camera");
data["CameraId"] = index;
data["IsNG"] = 0;
data["IsJdExist"] = 0;
data["Total"] = 0;
while (userNode != NULL)
{
if (atoi(userNode->Attribute("Id")) == index) {
data["IsNG"]++;
data["IsJdExist"]++;
data["Total"]++;
XMLElement* IsNgNode = userNode->FirstChildElement("IsNG");
data["IsNg"] = strcmp(IsNgNode->GetText(), "TRUE");
XMLElement* IsJdExistNode = userNode->FirstChildElement("IsJdExist");
if (strcmp(IsJdExistNode->GetText(), "TRUE") == 0)
data["IsJdExist"]++;
XMLElement* TimeCostNode = userNode->FirstChildElement("TimeCost");
data["TimeCost"] += stof(TimeCostNode->GetText());
}
userNode = userNode->NextSiblingElement();//下一个兄弟节点
}
if (data["Total"] == 0)
return false;
data["TimeCost"] = data["TimeCost"] / data["Total"];
averageData = data;
return true;
}
int ExportDataThread::insertXMLNode(const char* xmlPath, _XMLExportDataInfo& data)
{
XMLElement* root = pDocument[data.cameraId]->RootElement();
if (root == NULL) {
root = pDocument[data.cameraId]->NewElement("Root");
pDocument[data.cameraId]->InsertEndChild(root);
pDocument[data.cameraId]->SaveFile(xmlPath);
//return 0;
}
/// 总统计数据
// 总检测数量
XMLElement* Total= pDocument[data.cameraId]->NewElement("TotalDatas");
XMLElement* time = pDocument[data.cameraId]->NewElement("CurrentTime");
QString currentTime = QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss");
time->InsertEndChild(pDocument[data.cameraId]->NewText(currentTime.toStdString().c_str()));
Total->InsertEndChild(time);
XMLElement* TotalCheckNum = pDocument[data.cameraId]->NewElement("TotalCheckNum");
char s[20];
TotalCheckNum->InsertEndChild(pDocument[data.cameraId]->NewText(itoa(data.TotalCheckNum, s, 10)));
Total->InsertEndChild(TotalCheckNum);
// 总剔除数量
XMLElement* TotalKickNum = pDocument[data.cameraId]->NewElement("TotalKickNum");
TotalKickNum->InsertEndChild(pDocument[data.cameraId]->NewText(itoa(data.TotalKickNum, s, 10)));
Total->InsertEndChild(TotalKickNum);
root->InsertEndChild(Total);
/// 各相机数据
// 相机id & 总数
XMLElement* CameraNode = pDocument[data.cameraId]->NewElement("Camera");
CameraNode->SetAttribute("Count ", data.cameraTotal);
CameraNode->SetAttribute("Id", data.cameraId);
XMLElement* JudgeNum = pDocument[data.cameraId]->NewElement("JudgeNum");
// 各相机检测数量
XMLElement* checkNum = pDocument[data.cameraId]->NewElement("CheckNum");
checkNum->InsertEndChild(pDocument[data.cameraId]->NewText(itoa(data.checkNum, s, 10)));
JudgeNum->InsertEndChild(checkNum);
// 各相机ok数量
XMLElement* okNum = pDocument[data.cameraId]->NewElement("OkNum");
okNum->InsertEndChild(pDocument[data.cameraId]->NewText(itoa(data.okNum, s, 10)));
JudgeNum->InsertEndChild(okNum);
// 各相机ng数量
XMLElement* ngNum = pDocument[data.cameraId]->NewElement("NgNum");
ngNum->InsertEndChild(pDocument[data.cameraId]->NewText(itoa(data.ngNum, s, 10)));
JudgeNum->InsertEndChild(ngNum);
// 各相机实际剔除数量（单通道剔除时为总剔除数量）
XMLElement* kickNum = pDocument[data.cameraId]->NewElement("KickNum");
kickNum->InsertEndChild(pDocument[data.cameraId]->NewText(itoa(data.kickNum, s, 10)));
JudgeNum->InsertEndChild(kickNum);
// 合格率
XMLElement* PassRate = pDocument[data.cameraId]->NewElement("PassRate");
std::string temp_str = std::to_string(data.PassRate * 100 ) + "%";
const char* temp_char = temp_str.c_str();
PassRate->InsertEndChild(pDocument[data.cameraId]->NewText(temp_char));
JudgeNum->InsertEndChild(PassRate);
// 剔除率
XMLElement* KickRate = pDocument[data.cameraId]->NewElement("KickRate");
temp_str = std::to_string(data.KickRate * 100) + "%";
temp_char = temp_str.c_str();
KickRate->InsertEndChild(pDocument[data.cameraId]->NewText(temp_char));
JudgeNum->InsertEndChild(KickRate);
// 各相机胶点识别个数
XMLElement* JdNum = pDocument[data.cameraId]->NewElement("JdNum");
JdNum->InsertEndChild(pDocument[data.cameraId]->NewText(data.jdNum.toStdString().c_str()));
JudgeNum->InsertEndChild(JdNum);
XMLElement* shotCounts = pDocument[data.cameraId]->NewElement("ShotCounts");
shotCounts->InsertEndChild(pDocument[data.cameraId]->NewText(itoa(data.shotCounts, s, 10)));
JudgeNum->InsertEndChild(shotCounts);
CameraNode->InsertEndChild(JudgeNum);
// 各相机采集速度
XMLElement* speed = pDocument[data.cameraId]->NewElement("Speed");
XMLElement* AcquisitionSpeed = pDocument[data.cameraId]->NewElement("AcquisitionSpeed");
AcquisitionSpeed->InsertEndChild(pDocument[data.cameraId]->NewText(data.AcquisitionSpeed.toStdString().c_str()));
speed->InsertEndChild(AcquisitionSpeed);
// 各相机检测速度
XMLElement* DetectSpeed = pDocument[data.cameraId]->NewElement("DetectSpeed");
DetectSpeed->InsertEndChild(pDocument[data.cameraId]->NewText(data.DetectSpeed.toStdString().c_str()));
speed->InsertEndChild(DetectSpeed);
CameraNode->InsertEndChild(speed);
root->InsertEndChild(CameraNode);
return pDocument[data.cameraId]->SaveFile(xmlPath);
XMLElement* root = pDocument[data.cameraId]->RootElement();
if (root == NULL) {
root = pDocument[data.cameraId]->NewElement("Root");
pDocument[data.cameraId]->InsertEndChild(root);
pDocument[data.cameraId]->SaveFile(xmlPath);
//return 0;
}
/// 总统计数据
// 总检测数量
XMLElement* Total = pDocument[data.cameraId]->NewElement("TotalDatas");
XMLElement* time = pDocument[data.cameraId]->NewElement("CurrentTime");
QString currentTime = QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss");
time->InsertEndChild(pDocument[data.cameraId]->NewText(currentTime.toStdString().c_str()));
Total->InsertEndChild(time);
XMLElement* TotalCheckNum = pDocument[data.cameraId]->NewElement("TotalCheckNum");
char s[20];
TotalCheckNum->InsertEndChild(pDocument[data.cameraId]->NewText(itoa(data.TotalCheckNum, s, 10)));
Total->InsertEndChild(TotalCheckNum);
// 总剔除数量
XMLElement* TotalKickNum = pDocument[data.cameraId]->NewElement("TotalKickNum");
TotalKickNum->InsertEndChild(pDocument[data.cameraId]->NewText(itoa(data.TotalKickNum, s, 10)));
Total->InsertEndChild(TotalKickNum);
root->InsertEndChild(Total);
/// 各相机数据
// 相机id & 总数
XMLElement* CameraNode = pDocument[data.cameraId]->NewElement("Camera");
CameraNode->SetAttribute("Count ", data.cameraTotal);
CameraNode->SetAttribute("Id", data.cameraId);
XMLElement* JudgeNum = pDocument[data.cameraId]->NewElement("JudgeNum");
// 各相机检测数量
XMLElement* checkNum = pDocument[data.cameraId]->NewElement("CheckNum");
checkNum->InsertEndChild(pDocument[data.cameraId]->NewText(itoa(data.checkNum, s, 10)));
JudgeNum->InsertEndChild(checkNum);
// 各相机ok数量
XMLElement* okNum = pDocument[data.cameraId]->NewElement("OkNum");
okNum->InsertEndChild(pDocument[data.cameraId]->NewText(itoa(data.okNum, s, 10)));
JudgeNum->InsertEndChild(okNum);
// 各相机ng数量
XMLElement* ngNum = pDocument[data.cameraId]->NewElement("NgNum");
ngNum->InsertEndChild(pDocument[data.cameraId]->NewText(itoa(data.ngNum, s, 10)));
JudgeNum->InsertEndChild(ngNum);
// 各相机实际剔除数量（单通道剔除时为总剔除数量）
XMLElement* kickNum = pDocument[data.cameraId]->NewElement("KickNum");
kickNum->InsertEndChild(pDocument[data.cameraId]->NewText(itoa(data.kickNum, s, 10)));
JudgeNum->InsertEndChild(kickNum);
// 合格率
XMLElement* PassRate = pDocument[data.cameraId]->NewElement("PassRate");
std::string temp_str = std::to_string(data.PassRate * 100) + "%";
const char* temp_char = temp_str.c_str();
PassRate->InsertEndChild(pDocument[data.cameraId]->NewText(temp_char));
JudgeNum->InsertEndChild(PassRate);
// 剔除率
XMLElement* KickRate = pDocument[data.cameraId]->NewElement("KickRate");
temp_str = std::to_string(data.KickRate * 100) + "%";
temp_char = temp_str.c_str();
KickRate->InsertEndChild(pDocument[data.cameraId]->NewText(temp_char));
JudgeNum->InsertEndChild(KickRate);
// 各相机胶点识别个数
XMLElement* JdNum = pDocument[data.cameraId]->NewElement("JdNum");
JdNum->InsertEndChild(pDocument[data.cameraId]->NewText(data.jdNum.toStdString().c_str()));
JudgeNum->InsertEndChild(JdNum);
XMLElement* shotCounts = pDocument[data.cameraId]->NewElement("ShotCounts");
shotCounts->InsertEndChild(pDocument[data.cameraId]->NewText(itoa(data.shotCounts, s, 10)));
JudgeNum->InsertEndChild(shotCounts);
CameraNode->InsertEndChild(JudgeNum);
// 各相机采集速度
XMLElement* speed = pDocument[data.cameraId]->NewElement("Speed");
XMLElement* AcquisitionSpeed = pDocument[data.cameraId]->NewElement("AcquisitionSpeed");
AcquisitionSpeed->InsertEndChild(pDocument[data.cameraId]->NewText(data.AcquisitionSpeed.toStdString().c_str()));
speed->InsertEndChild(AcquisitionSpeed);
// 各相机检测速度
XMLElement* DetectSpeed = pDocument[data.cameraId]->NewElement("DetectSpeed");
DetectSpeed->InsertEndChild(pDocument[data.cameraId]->NewText(data.DetectSpeed.toStdString().c_str()));
speed->InsertEndChild(DetectSpeed);
CameraNode->InsertEndChild(speed);
root->InsertEndChild(CameraNode);
return pDocument[data.cameraId]->SaveFile(xmlPath);
}
void ExportDataThread::run()
{
while (!b_quit) {
_XMLExportDataInfo element;
export_XMLData_Info_queue->take(element);
if (element.cameraId != -1 && flag) {
char buf[256];
memset(buf, 0, 256);
QString xmlPath = QString(EXPORTDATA_FILE).arg(element.cameraId);
QString filePath = g_conf_path.config_path + "/" + xmlPath;
sprintf(buf, filePath.toLocal8Bit().constData(), element.cameraId);
insertXMLNode(buf, element);
QString remotePath = "/tmp/" + xmlPath;
ConnectServer(filePath, remotePath);
}
}
flag = false;
for (int index = 0; index < NumberOfSupportedCameras; index++) {
pDocument[index]->~XMLDocument();
}
while (!b_quit) {
_XMLExportDataInfo element;
export_XMLData_Info_queue->take(element);
if (element.cameraId != -1 && flag) {
char buf[256];
memset(buf, 0, 256);
QString xmlPath = QString(EXPORTDATA_FILE).arg(element.cameraId);
QString filePath = g_conf_path.config_path + "/" + xmlPath;
sprintf(buf, filePath.toLocal8Bit().constData(), element.cameraId);
insertXMLNode(buf, element);
QString remotePath = "/tmp/" + xmlPath;
ConnectServer(filePath, remotePath);
}
}
flag = false;
for (int index = 0; index < NumberOfSupportedCameras; index++) {
pDocument[index]->~XMLDocument();
}
}
//*****************************************已经调试好，没有理清逻辑前不要动**********************
//*****************************************已经调试好，没有理清逻辑前不要动**********************
void ExportDataThread::check_save_dir(std::string dir_path)
{
// 如果目的路径不存在，一级一级创建
// 目的路径格式为:"./dir/dir1/.../"
if (FALSE == FtpSetCurrentDirectoryA(hftp, dir_path.c_str())) {
FtpSetCurrentDirectoryA(hftp, "/");
int pos = 1;
while (pos > 0) {
// 从第二个“/”开始依次找到目的路径中的“/”位置
pos = dir_path.find_first_of('/', pos + 1);
if (pos == -1)
break;
string tempPath = dir_path.substr(0, pos + 1);
FtpCreateDirectoryA(hftp, tempPath.c_str());
}
//FtpSetCurrentDirectoryA(hftp, dir_path.c_str());
}
// 如果目的路径不存在，一级一级创建
// 目的路径格式为:"./dir/dir1/.../"
if (FALSE == FtpSetCurrentDirectoryA(hftp, dir_path.c_str())) {
FtpSetCurrentDirectoryA(hftp, "/");
int pos = 1;
while (pos > 0) {
// 从第二个“/”开始依次找到目的路径中的“/”位置
pos = dir_path.find_first_of('/', pos + 1);
if (pos == -1)
break;
string tempPath = dir_path.substr(0, pos + 1);
FtpCreateDirectoryA(hftp, tempPath.c_str());
}
//FtpSetCurrentDirectoryA(hftp, dir_path.c_str());
}
}
void ExportDataThread::EDrecMsgFromCigarette(){
flag = true;
void ExportDataThread::EDrecMsgFromCigarette() {
flag = true;
}
void ExportDataThread::ConnectServer(QString srcPath, QString destPath) {
string filePath = srcPath.toLocal8Bit().constData();
string remotePath = destPath.toLocal8Bit().constData();
std::vector<string> files;
// 判断上传的是文件还是文件夹标识
int size = 0;
struct stat st;
stat(filePath.c_str(), &st);
if (st.st_mode & S_IFDIR) {
//qDebug() << "filePath is Directory";
// 获取文件夹下所有文件名
GetFiles(filePath, files);
size = files.size();
}
// 上传文件源为一个文件
if (size == 0) {
int pos = remotePath.find_last_of('/');
string destFileName = remotePath.substr(pos + 1);
string tempPath = remotePath.substr(0, pos + 1);
check_save_dir(tempPath);
if (!InternetGetConnectedState(NULL, 0)) {
qDebug() << "计算机未连接到互联网";
}
else {
while (!FtpPutFileA(hftp, filePath.c_str(), remotePath.c_str(), FTP_TRANSFER_TYPE_BINARY, 0)) {
qDebug() << "ftp put file "<< filePath.c_str() << "failed because" << GetLastError();
if (!ConnectFtp())
qDebug() << "connect FTP failed because " << GetLastError();
}
}
}
// 上传源为一个文件夹
else{
for (int i = 0; i < size; i++) {
string tempFilePath = (string(files[i]).erase(0, filePath.length() + 1)).c_str();
// 获取上传路径中的文件名
int pos = tempFilePath.find_last_of('/');
string destFileName = tempFilePath.substr(pos + 1);
check_save_dir(remotePath + tempFilePath.substr(0, pos + 1));
if(!FtpPutFileA(hftp, files[i].c_str(), destFileName.c_str(), FTP_TRANSFER_TYPE_BINARY, 0))
qDebug() << "ftp put files failed because " << GetLastError();
}
}
string filePath = srcPath.toLocal8Bit().constData();
string remotePath = destPath.toLocal8Bit().constData();
std::vector<string> files;
// 判断上传的是文件还是文件夹标识
int size = 0;
struct stat st;
stat(filePath.c_str(), &st);
if (st.st_mode & S_IFDIR) {
//qDebug() << "filePath is Directory";
// 获取文件夹下所有文件名
GetFiles(filePath, files);
size = files.size();
}
// 上传文件源为一个文件
if (size == 0) {
int pos = remotePath.find_last_of('/');
string destFileName = remotePath.substr(pos + 1);
string tempPath = remotePath.substr(0, pos + 1);
check_save_dir(tempPath);
if (!InternetGetConnectedState(NULL, 0)) {
qDebug() << "计算机未连接到互联网";
}
else {
while (!FtpPutFileA(hftp, filePath.c_str(), remotePath.c_str(), FTP_TRANSFER_TYPE_BINARY, 0)) {
qDebug() << "ftp put file " << filePath.c_str() << "failed because" << GetLastError();
if (!ConnectFtp())
qDebug() << "connect FTP failed because " << GetLastError();
}
}
}
// 上传源为一个文件夹
else {
for (int i = 0; i < size; i++) {
string tempFilePath = (string(files[i]).erase(0, filePath.length() + 1)).c_str();
// 获取上传路径中的文件名
int pos = tempFilePath.find_last_of('/');
string destFileName = tempFilePath.substr(pos + 1);
check_save_dir(remotePath + tempFilePath.substr(0, pos + 1));
if (!FtpPutFileA(hftp, files[i].c_str(), destFileName.c_str(), FTP_TRANSFER_TYPE_BINARY, 0))
qDebug() << "ftp put files failed because " << GetLastError();
}
}
}
void ExportDataThread::GetDataFromSaveThread(QString filePath) {
QString remotePath;
remotePath = filePath.mid(filePath.indexOf("image") - 1);
ConnectServer(filePath, remotePath);
QString remotePath;
remotePath = filePath.mid(filePath.indexOf("image") - 1);
ConnectServer(filePath, remotePath);
}
//*****************************************已经调试好，没有理清逻辑前不要动**********************
//*****************************************已经调试好，没有理清逻辑前不要动**********************
void ExportDataThread::GetFiles(string path, std::vector<string>& files) {
//文件句柄
intptr_t hFile = 0;
//文件信息的结构体
struct _finddata_t fileinfo;
string p;
if ((hFile = _findfirst(p.assign(path).append("\\*").c_str(), &fileinfo)) != -1)
{
// "\\*"是指读取文件夹下的所有类型的文件
do
{
//如果是目录,迭代之
//如果不是,加入列表
if ((fileinfo.attrib & _A_SUBDIR))
{
if (strcmp(fileinfo.name, ".") != 0 && strcmp(fileinfo.name, "..") != 0)
GetFiles(p.assign(path).append("/").append(fileinfo.name), files);
}
else
{
files.push_back(p.assign(path).append("/").append(fileinfo.name));
}
} while (_findnext(hFile, &fileinfo) == 0);
_findclose(hFile);
}
//文件句柄
intptr_t hFile = 0;
//文件信息的结构体
struct _finddata_t fileinfo;
string p;
if ((hFile = _findfirst(p.assign(path).append("\\*").c_str(), &fileinfo)) != -1)
{
// "\\*"是指读取文件夹下的所有类型的文件
do
{
//如果是目录,迭代之
//如果不是,加入列表
if ((fileinfo.attrib & _A_SUBDIR))
{
if (strcmp(fileinfo.name, ".") != 0 && strcmp(fileinfo.name, "..") != 0)
GetFiles(p.assign(path).append("/").append(fileinfo.name), files);
}
else
{
files.push_back(p.assign(path).append("/").append(fileinfo.name));
}
} while (_findnext(hFile, &fileinfo) == 0);
_findclose(hFile);
}
}

192
Cigarette/exportData.h
Unescape Escape View File

@ -18,81 +18,81 @@ using namespace tinyxml2;
class _XMLExportDataInfo {
public:
// 总的统计数据
long long cameraTotal;
int TotalCheckNum; // 总检测数量
int TotalKickNum; // 总剔除数量
double PassRate; // 合格率
double KickRate; // 剔除率
// 各相机数据
int cameraId;
int shotCounts; // 拍摄张数
int checkNum; // 各相机检测个数
int okNum; // 各相机ok数量
int ngNum; // 各相机ng数量
int kickNum; // 各相机实际剔除数量（单通道剔除时为总剔除数量）
QString AcquisitionSpeed; // 各相机采集速度
QString jdNum; // 各相机胶点识别个数
QString DetectSpeed; // 各相机检测速度(识别时间)
_XMLExportDataInfo() {
// 总的统计数据
TotalCheckNum = 0; // 总检测数量
TotalKickNum = 0; // 总剔除数量
PassRate = 0.0; // 合格率
KickRate = 0.0; // 剔除率
cameraId = -1;
jdNum = QString("0,0,0");
// 各相机数据
shotCounts = 0;
checkNum = 0;
okNum = 0;
ngNum = 0;
kickNum = 0; // 各相机实际剔除数量（单通道剔除时为总剔除数量）
AcquisitionSpeed = "0"; // 各相机采集速度
DetectSpeed = "0"; // 各相机检测速度
}
// 总的统计数据
long long cameraTotal;
int TotalCheckNum; // 总检测数量
int TotalKickNum; // 总剔除数量
double PassRate; // 合格率
double KickRate; // 剔除率
// 各相机数据
int cameraId;
int shotCounts; // 拍摄张数
int checkNum; // 各相机检测个数
int okNum; // 各相机ok数量
int ngNum; // 各相机ng数量
int kickNum; // 各相机实际剔除数量（单通道剔除时为总剔除数量）
QString AcquisitionSpeed; // 各相机采集速度
QString jdNum; // 各相机胶点识别个数
QString DetectSpeed; // 各相机检测速度(识别时间)
_XMLExportDataInfo() {
// 总的统计数据
TotalCheckNum = 0; // 总检测数量
TotalKickNum = 0; // 总剔除数量
PassRate = 0.0; // 合格率
KickRate = 0.0; // 剔除率
cameraId = -1;
jdNum = QString("0,0,0");
// 各相机数据
shotCounts = 0;
checkNum = 0;
okNum = 0;
ngNum = 0;
kickNum = 0; // 各相机实际剔除数量（单通道剔除时为总剔除数量）
AcquisitionSpeed = "0"; // 各相机采集速度
DetectSpeed = "0"; // 各相机检测速度
}
};
class _ExportDataInfo
{
struct JdPoint //创建点的数据
{
string x;
string y;
};
struct JdPoint //创建点的数据
{
string x;
string y;
};
public:
int cameraId;
int shotCounts;
int jd[20];
string timeCost;
float jdInterval;
bool isNg;
bool isJdExist[20];
long long cameraTotal;
std::vector<JdPoint> jdPointsLocation;
float jdSize[20];
bool getAverageData(map<string, float>& averageData, int index);
string getPoint(int index) {
string point = "(";
point += jdPointsLocation.at(index).x + ',' + jdPointsLocation.at(index).y + ')';
return point;
}
_ExportDataInfo()
{
cameraId = -1;
jdInterval = 0.0;
isNg = false;
for (int i = 0; i < 20; i++)isJdExist[i] = false;
for (int i = 0; i < 20; i++)jd[i] = 0;
timeCost = "0ms";
for (int i = 0; i < 20; i++)jdSize[i] = 0.0;
shotCounts = 0;
}
int cameraId;
int shotCounts;
int jd[20];
string timeCost;
float jdInterval;
bool isNg;
bool isJdExist[20];
long long cameraTotal;
std::vector<JdPoint> jdPointsLocation;
float jdSize[20];
bool getAverageData(map<string, float>& averageData, int index);
string getPoint(int index) {
string point = "(";
point += jdPointsLocation.at(index).x + ',' + jdPointsLocation.at(index).y + ')';
return point;
}
_ExportDataInfo()
{
cameraId = -1;
jdInterval = 0.0;
isNg = false;
for (int i = 0; i < 20; i++)isJdExist[i] = false;
for (int i = 0; i < 20; i++)jd[i] = 0;
timeCost = "0ms";
for (int i = 0; i < 20; i++)jdSize[i] = 0.0;
shotCounts = 0;
}
};
//extern SyncQueue<_ExportDataInfo>* export_Data_Info_queue;
@ -100,41 +100,41 @@ extern SyncQueue<_XMLExportDataInfo>* export_XMLData_Info_queue;
class ExportDataThread : public QThread
{
Q_OBJECT
Q_OBJECT
signals:
public:
ExportDataThread(QObject* parent = 0);
~ExportDataThread()
{
stop();
//export_Data_Info_queue->put(data);
quit();
wait();
}
void init();
void start_work();
void stop();
//int insertXMLNode(const char* xmlPath, _ExportDataInfo& data);
int insertXMLNode(const char* xmlPath, _XMLExportDataInfo& data);
bool ConnectFtp();
void ConnectServer(QString srcPath, QString destPath);
void GetFiles(string path, std::vector<string>& files);
ExportDataThread(QObject* parent = 0);
~ExportDataThread()
{
stop();
//export_Data_Info_queue->put(data);
quit();
wait();
}
void init();
void start_work();
void stop();
//int insertXMLNode(const char* xmlPath, _ExportDataInfo& data);
int insertXMLNode(const char* xmlPath, _XMLExportDataInfo& data);
bool ConnectFtp();
void ConnectServer(QString srcPath, QString destPath);
void GetFiles(string path, std::vector<string>& files);
protected:
void run();
void check_save_dir(std::string dir_path);
void run();
void check_save_dir(std::string dir_path);
public:
bool b_quit;
tinyxml2::XMLDocument *pDocument[NumberOfSupportedCameras];
//int flag;
bool b_quit;
tinyxml2::XMLDocument* pDocument[NumberOfSupportedCameras];
//int flag;
HINTERNET hint = NULL;
HINTERNET hftp = NULL;
HINTERNET hint = NULL;
HINTERNET hftp = NULL;
public slots:
void EDrecMsgFromCigarette();
void GetDataFromSaveThread(QString filePath);
void EDrecMsgFromCigarette();
void GetDataFromSaveThread(QString filePath);
};

24
Cigarette/hikcamera.cpp
Unescape Escape View File

@ -18,21 +18,21 @@ HIKCamera::~HIKCamera()
int HIKCamera::Enumerate()
{
int status = 0;
int status = 0;
// ch:枚举设备 | Enum device
// ch:枚举设备 | Enum device
memset(&stDeviceList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));
memset(&stDeviceList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));
status = MV_CC_EnumDevices(MV_GIGE_DEVICE| MV_USB_DEVICE, &stDeviceList);
status = MV_CC_EnumDevices(MV_GIGE_DEVICE | MV_USB_DEVICE, &stDeviceList);
if (MV_OK == status)
{
return stDeviceList.nDeviceNum;
}
else
{
return 0;
}
if (MV_OK == status)
{
return stDeviceList.nDeviceNum;
}
else
{
return 0;
}
}

10
Cigarette/hikcamera.h
Unescape Escape View File

@ -6,15 +6,15 @@
#define HIKClassID 0x03
class HIKCamera: public BaseCamera
class HIKCamera : public BaseCamera
{
public:
HIKCamera(int DeviceNum);
~HIKCamera();
HIKCamera(int DeviceNum);
~HIKCamera();
static int Enumerate();
static int Enumerate();
public:
static MV_CC_DEVICE_INFO_LIST stDeviceList;
static MV_CC_DEVICE_INFO_LIST stDeviceList;
};

32
Cigarette/main.cpp
Unescape Escape View File

@ -7,23 +7,23 @@
#include "CryptoToolLib.h"
#endif
int main(int argc, char *argv[])
int main(int argc, char* argv[])
{
#if defined LICENSE_VERIFY
if(!VerifyLicense())
{
exit(0);
}
if (!VerifyLicense())
{
exit(0);
}
#endif
qRegisterMetaType<cv::Mat>("cv::Mat");
QApplication a(argc, argv);
QPixmap pixmap("D:/Release/splash.jpg");
QSplashScreen splash(pixmap);
splash.show();
a.processEvents();
Cigarette w;
w.show();
//w.showFullScreen();
splash.finish(&w);
return a.exec();
qRegisterMetaType<cv::Mat>("cv::Mat");
QApplication a(argc, argv);
QPixmap pixmap("D:/Release/splash.jpg");
QSplashScreen splash(pixmap);
splash.show();
a.processEvents();
Cigarette w;
w.show();
//w.showFullScreen();
splash.finish(&w);
return a.exec();
}

62
Cigarette/output_statistic.cpp
Unescape Escape View File

@ -9,35 +9,35 @@ extern ConfPath g_conf_path;
#define output_init(a, b)\
textBrowser_mat[a] = ui.textBrowser_##b;
output_statistic::output_statistic(QDialog *parent)
: QDialog(parent)
output_statistic::output_statistic(QDialog* parent)
: QDialog(parent)
{
ui.setupUi(this);
this->setWindowFlags(windowFlags()&~Qt::WindowContextHelpButtonHint);
ui.setupUi(this);
this->setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras > 0)
output_init(0, 1);
output_init(0, 1);
#endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras > 1)
output_init(1, 2);
output_init(1, 2);
#endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras > 2)
output_init(2, 3);
output_init(2, 3);
#endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras > 3)
output_init(3, 4);
output_init(3, 4);
#endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras > 4)
output_init(4, 5);
output_init(4, 5);
#endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras > 5)
output_init(5, 6);
output_init(5, 6);
#endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras > 6)
output_init(6, 7);
output_init(6, 7);
#endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras > 7)
output_init(7, 8);
output_init(7, 8);
#endif
}
@ -47,23 +47,23 @@ output_statistic::~output_statistic()
void output_statistic::recMsgFromDialogSetup()
{
QString file_path, file_name;
QFile file;
for (int i = 0; i < NumberOfSupportedCameras; i++) {
file_name = QString(STATISTIC_FILE).arg(i);
file_path = g_conf_path.config_path + "/" + file_name;
file.setFileName(file_path);
if (file.open(QIODevice::ReadOnly | QIODevice::Text))
{
QTextStream in(&file);
//in.setCodec("UTF-8");
textBrowser_mat[i]->setText(in.readAll());
}
else {
std::cout << "can not open statistic file" << std::endl;
}
file.close();
this->show();
}
//this->show();
QString file_path, file_name;
QFile file;
for (int i = 0; i < NumberOfSupportedCameras; i++) {
file_name = QString(STATISTIC_FILE).arg(i);
file_path = g_conf_path.config_path + "/" + file_name;
file.setFileName(file_path);
if (file.open(QIODevice::ReadOnly | QIODevice::Text))
{
QTextStream in(&file);
//in.setCodec("UTF-8");
textBrowser_mat[i]->setText(in.readAll());
}
else {
std::cout << "can not open statistic file" << std::endl;
}
file.close();
this->show();
}
//this->show();
}

12
Cigarette/output_statistic.h
Unescape Escape View File

@ -6,16 +6,16 @@
class output_statistic : public QDialog
{
Q_OBJECT
Q_OBJECT
public:
output_statistic(QDialog *parent = Q_NULLPTR);
~output_statistic();
output_statistic(QDialog* parent = Q_NULLPTR);
~output_statistic();
private:
Ui::output_statistic ui;
QTextBrowser* textBrowser_mat[NumberOfSupportedCameras];
Ui::output_statistic ui;
QTextBrowser* textBrowser_mat[NumberOfSupportedCameras];
public slots:
void recMsgFromDialogSetup();
void recMsgFromDialogSetup();
};

12
Cigarette/plc_item.h
Unescape Escape View File

@ -4,12 +4,12 @@
class PlcItem
{
public:
PlcItem();
~PlcItem();
PlcItem();
~PlcItem();
public:
std::string func_desc; //功能描述
int address; //modbus地址
std::string memo; //备注
int value; //初始值
std::string func_desc; //功能描述
int address; //modbus地址
std::string memo; //备注
int value; //初始值
};

458
Cigarette/plcsetup.cpp
Unescape Escape View File

@ -10,62 +10,62 @@
#include "PLCDevice.h"
#define PLC_ITEM_FILE "plc.txt"
extern PLCDevice * m_PLCDevice;
extern PLCDevice* m_PLCDevice;
extern ConfPath g_conf_path;
extern bool g_plc_dialog_open; //是否打开plc配置对话框
void task_osk_()
{
system("start /b C:\\Windows\\system32\\osk.exe");
system("start /b C:\\Windows\\system32\\osk.exe");
}
PlcSetup::PlcSetup(QWidget * parent) : QDialog(parent) {
ui.setupUi(this);
this->setWindowFlags(Qt::FramelessWindowHint);
read_plc_items();
ui.tableWidget->setColumnCount(7);
ui.tableWidget->setRowCount(m_plc_items.size());
QStringList header_list;
header_list << QStringLiteral("功能描述") << QStringLiteral("读数值")
<< QStringLiteral("读操作") << QStringLiteral("写数值") << QStringLiteral("写操作") << QStringLiteral("保存") << QStringLiteral("备注") ;
ui.tableWidget->setHorizontalHeaderLabels(header_list);
ui.tableWidget->setColumnWidth(0, 200);
ui.tableWidget->setColumnWidth(1, 100);
ui.tableWidget->setColumnWidth(2, 50);
ui.tableWidget->setColumnWidth(3, 100);
ui.tableWidget->setColumnWidth(4, 50);
ui.tableWidget->setColumnWidth(5, 50);
ui.tableWidget->setColumnWidth(6, 390);
ui.tableWidget->setEditTriggers(QAbstractItemView::NoEditTriggers); //禁止编辑
for (int i = 0; i < m_plc_items.size(); i++)
{
ui.tableWidget->setItem(i, 0, new QTableWidgetItem(QString::fromLocal8Bit(m_plc_items[i].func_desc.c_str())));
//ui.tableWidget->setItem(i, 1, new QTableWidgetItem(QString::number(m_plc_items[i].address)));
QPushButton * pBtnR = new QPushButton();
pBtnR->setText(QStringLiteral("读"));
connect(pBtnR, SIGNAL(clicked(bool)), this, SLOT(click_read()));
ui.tableWidget->setCellWidget(i, 2, pBtnR);
PlcSetup::PlcSetup(QWidget* parent) : QDialog(parent) {
ui.setupUi(this);
this->setWindowFlags(Qt::FramelessWindowHint);
read_plc_items();
ui.tableWidget->setColumnCount(7);
ui.tableWidget->setRowCount(m_plc_items.size());
QStringList header_list;
header_list << QStringLiteral("功能描述") << QStringLiteral("读数值")
<< QStringLiteral("读操作") << QStringLiteral("写数值") << QStringLiteral("写操作") << QStringLiteral("保存") << QStringLiteral("备注");
ui.tableWidget->setHorizontalHeaderLabels(header_list);
ui.tableWidget->setColumnWidth(0, 200);
ui.tableWidget->setColumnWidth(1, 100);
ui.tableWidget->setColumnWidth(2, 50);
ui.tableWidget->setColumnWidth(3, 100);
ui.tableWidget->setColumnWidth(4, 50);
ui.tableWidget->setColumnWidth(5, 50);
ui.tableWidget->setColumnWidth(6, 390);
ui.tableWidget->setEditTriggers(QAbstractItemView::NoEditTriggers); //禁止编辑
for (int i = 0; i < m_plc_items.size(); i++)
{
ui.tableWidget->setItem(i, 0, new QTableWidgetItem(QString::fromLocal8Bit(m_plc_items[i].func_desc.c_str())));
//ui.tableWidget->setItem(i, 1, new QTableWidgetItem(QString::number(m_plc_items[i].address)));
QPushButton* pBtnR = new QPushButton();
pBtnR->setText(QStringLiteral("读"));
connect(pBtnR, SIGNAL(clicked(bool)), this, SLOT(click_read()));
ui.tableWidget->setCellWidget(i, 2, pBtnR);
QLineEdit *edit = new QLineEdit();
edit->setValidator(new QIntValidator(0, 100000, this));
ui.tableWidget->setCellWidget(i, 3, edit);
QLineEdit* edit = new QLineEdit();
edit->setValidator(new QIntValidator(0, 100000, this));
ui.tableWidget->setCellWidget(i, 3, edit);
QPushButton * pBtnW = new QPushButton();
pBtnW->setText(QStringLiteral("写"));
connect(pBtnW, SIGNAL(clicked(bool)), this, SLOT(click_write()));
ui.tableWidget->setCellWidget(i, 4, pBtnW);
QPushButton* pBtnW = new QPushButton();
pBtnW->setText(QStringLiteral("写"));
connect(pBtnW, SIGNAL(clicked(bool)), this, SLOT(click_write()));
ui.tableWidget->setCellWidget(i, 4, pBtnW);
QPushButton * pBtnS = new QPushButton();
pBtnS->setText(QStringLiteral("保存"));
connect(pBtnS, SIGNAL(clicked(bool)), this, SLOT(click_save()));
ui.tableWidget->setCellWidget(i, 5, pBtnS);
QPushButton* pBtnS = new QPushButton();
pBtnS->setText(QStringLiteral("保存"));
connect(pBtnS, SIGNAL(clicked(bool)), this, SLOT(click_save()));
ui.tableWidget->setCellWidget(i, 5, pBtnS);
ui.tableWidget->setItem(i, 6, new QTableWidgetItem(QString::fromLocal8Bit(m_plc_items[i].memo.c_str())));
}
m_pTimer = new QTimer(this);
connect(m_pTimer, SIGNAL(timeout()), this, SLOT(handleTimeout()));
m_pTimer->setSingleShot(true);
m_pTimer->start(1000);
ui.tableWidget->setItem(i, 6, new QTableWidgetItem(QString::fromLocal8Bit(m_plc_items[i].memo.c_str())));
}
m_pTimer = new QTimer(this);
connect(m_pTimer, SIGNAL(timeout()), this, SLOT(handleTimeout()));
m_pTimer->setSingleShot(true);
m_pTimer->start(1000);
}
PlcSetup::~PlcSetup() {
@ -74,224 +74,224 @@ PlcSetup::~PlcSetup() {
void PlcSetup::click_read()
{
QPushButton *pushButton_ = dynamic_cast<QPushButton*>(this->sender());
if (NULL == pushButton_)
{
return;
}
int x = pushButton_->frameGeometry().x();
int y = pushButton_->frameGeometry().y();
QModelIndex index = ui.tableWidget->indexAt(QPoint(x, y));
int row = index.row();
int column = index.column();
QPushButton* pushButton_ = dynamic_cast<QPushButton*>(this->sender());
if (NULL == pushButton_)
{
return;
}
int x = pushButton_->frameGeometry().x();
int y = pushButton_->frameGeometry().y();
QModelIndex index = ui.tableWidget->indexAt(QPoint(x, y));
int row = index.row();
int column = index.column();
int addr = m_plc_items[row].address;
int addr = m_plc_items[row].address;
uint8_t dest[4];
uint16_t * dest16 = (uint16_t *)dest;
memset(dest, 0, 4);
if (addr > 0)
{
if (addr < 40000) //读取线圈值 bit
{
int ret = m_PLCDevice->read_bits_from_plc(addr, 1, dest);
ui.tableWidget->setItem(row, 1, new QTableWidgetItem(QString::number(dest[0])));
}
else { //读取DWORD值，4字节
int ret = m_PLCDevice->read_short_from_plc( addr, 2, dest16);
//printf("%x ", dest16[0]);
//printf("%x \n", dest16[1]);
//printf("%d \n", dest16[0] + (dest16[1] << 16));
ui.tableWidget->setItem(row, 1, new QTableWidgetItem(QString::number(dest16[0] + (dest16[1] << 16))));
}
}
uint8_t dest[4];
uint16_t* dest16 = (uint16_t*)dest;
memset(dest, 0, 4);
if (addr > 0)
{
if (addr < 40000) //读取线圈值 bit
{
int ret = m_PLCDevice->read_bits_from_plc(addr, 1, dest);
ui.tableWidget->setItem(row, 1, new QTableWidgetItem(QString::number(dest[0])));
}
else { //读取DWORD值，4字节
int ret = m_PLCDevice->read_short_from_plc(addr, 2, dest16);
//printf("%x ", dest16[0]);
//printf("%x \n", dest16[1]);
//printf("%d \n", dest16[0] + (dest16[1] << 16));
ui.tableWidget->setItem(row, 1, new QTableWidgetItem(QString::number(dest16[0] + (dest16[1] << 16))));
}
}
}
void PlcSetup::click_write()
{
QPushButton *pushButton_ = dynamic_cast<QPushButton*>(this->sender());
if (NULL == pushButton_)
{
return;
}
int x = pushButton_->frameGeometry().x();
int y = pushButton_->frameGeometry().y();
QModelIndex index = ui.tableWidget->indexAt(QPoint(x, y));
int row = index.row();
int column = index.column();
//std::cout << "row:" << row << "\tcol:" << column << std::endl;
QPushButton* pushButton_ = dynamic_cast<QPushButton*>(this->sender());
if (NULL == pushButton_)
{
return;
}
int x = pushButton_->frameGeometry().x();
int y = pushButton_->frameGeometry().y();
QModelIndex index = ui.tableWidget->indexAt(QPoint(x, y));
int row = index.row();
int column = index.column();
//std::cout << "row:" << row << "\tcol:" << column << std::endl;
int addr = m_plc_items[row].address;
QWidget *widget=ui.tableWidget->cellWidget(row,3);
QLineEdit *edit=(QLineEdit*)widget;
QString d = edit->text();
uint8_t dest[4];
uint16_t * dest16 = (uint16_t *)dest;
memset(dest, 0, 4);
if (d.length() > 0)
{
int data = d.toInt();
if (addr > 0)
{
if (addr < 40000) //写入线圈值 bit
{
if (data != 0) data = 1;
int ret = m_PLCDevice->write_bit_2_plc( addr, data);
}
else { //写入DWORD值，4字节
dest16[0] = (data & 0xffff);
dest16[1] = (data>>16);
int ret = m_PLCDevice->write_short_2_plc(addr, 2, dest16);
}
}
QMessageBox::information(NULL, QStringLiteral("提示"), QStringLiteral("写入成功"), QMessageBox::Ok);
}
int addr = m_plc_items[row].address;
QWidget* widget = ui.tableWidget->cellWidget(row, 3);
QLineEdit* edit = (QLineEdit*)widget;
QString d = edit->text();
uint8_t dest[4];
uint16_t* dest16 = (uint16_t*)dest;
memset(dest, 0, 4);
if (d.length() > 0)
{
int data = d.toInt();
if (addr > 0)
{
if (addr < 40000) //写入线圈值 bit
{
if (data != 0) data = 1;
int ret = m_PLCDevice->write_bit_2_plc(addr, data);
}
else { //写入DWORD值，4字节
dest16[0] = (data & 0xffff);
dest16[1] = (data >> 16);
int ret = m_PLCDevice->write_short_2_plc(addr, 2, dest16);
}
}
QMessageBox::information(NULL, QStringLiteral("提示"), QStringLiteral("写入成功"), QMessageBox::Ok);
}
}
void PlcSetup::click_save()
{
QPushButton *pushButton_ = dynamic_cast<QPushButton*>(this->sender());
if (NULL == pushButton_)
{
return;
}
int x = pushButton_->frameGeometry().x();
int y = pushButton_->frameGeometry().y();
QModelIndex index = ui.tableWidget->indexAt(QPoint(x, y));
int row = index.row();
int column = index.column();
//std::cout << "row:" << row << "\tcol:" << column << std::endl;
QPushButton* pushButton_ = dynamic_cast<QPushButton*>(this->sender());
if (NULL == pushButton_)
{
return;
}
int x = pushButton_->frameGeometry().x();
int y = pushButton_->frameGeometry().y();
QModelIndex index = ui.tableWidget->indexAt(QPoint(x, y));
int row = index.row();
int column = index.column();
//std::cout << "row:" << row << "\tcol:" << column << std::endl;
int addr = m_plc_items[row].address;
QWidget *widget = ui.tableWidget->cellWidget(row, 3);
QLineEdit *edit = (QLineEdit*)widget;
QString d = edit->text();
uint8_t dest[4];
uint16_t * dest16 = (uint16_t *)dest;
memset(dest, 0, 4);
if (d.length() > 0)
{
int data = d.toInt();
if (addr > 0)
{
if (addr < 40000) //写入线圈值 bit
{
if (data != 0) data = 1;
int ret = m_PLCDevice->write_bit_2_plc( addr, data);
}
else { //写入DWORD值，4字节
dest16[0] = (data & 0xffff);
dest16[1] = (data >> 16);
int ret = m_PLCDevice->write_short_2_plc(addr, 2, dest16);
}
}
//int data = d.toInt();
for (int i = 0; i < m_plc_items.size(); i++)
{
//std::cout << m_plc_items[i].address << std::endl;
if (m_plc_items[i].address == addr)
{
//std::cout << "Hit" << addr << std::endl;
m_plc_items[i].value = data;
//std::cout << "SAVE start" << std::endl;
save_plc_items();
//std::cout << "SAVE END" << std::endl;
QMessageBox::information(NULL, QStringLiteral("提示"), QStringLiteral("写入并且保存成功"), QMessageBox::Ok);
break;
}
}
}
int addr = m_plc_items[row].address;
QWidget* widget = ui.tableWidget->cellWidget(row, 3);
QLineEdit* edit = (QLineEdit*)widget;
QString d = edit->text();
uint8_t dest[4];
uint16_t* dest16 = (uint16_t*)dest;
memset(dest, 0, 4);
if (d.length() > 0)
{
int data = d.toInt();
if (addr > 0)
{
if (addr < 40000) //写入线圈值 bit
{
if (data != 0) data = 1;
int ret = m_PLCDevice->write_bit_2_plc(addr, data);
}
else { //写入DWORD值，4字节
dest16[0] = (data & 0xffff);
dest16[1] = (data >> 16);
int ret = m_PLCDevice->write_short_2_plc(addr, 2, dest16);
}
}
//int data = d.toInt();
for (int i = 0; i < m_plc_items.size(); i++)
{
//std::cout << m_plc_items[i].address << std::endl;
if (m_plc_items[i].address == addr)
{
//std::cout << "Hit" << addr << std::endl;
m_plc_items[i].value = data;
//std::cout << "SAVE start" << std::endl;
save_plc_items();
//std::cout << "SAVE END" << std::endl;
QMessageBox::information(NULL, QStringLiteral("提示"), QStringLiteral("写入并且保存成功"), QMessageBox::Ok);
break;
}
}
}
}
void PlcSetup::on_toolButton_batch_read_released()
{
for (int i = 0; i < m_plc_items.size(); i++)
{
int addr = m_plc_items[i].address;
uint8_t dest[4];
uint16_t * dest16 = (uint16_t *)dest;
memset(dest, 0, 4);
if (addr > 0)
{
if (addr < 40000) //读取线圈值 bit
{
int ret = m_PLCDevice->read_bits_from_plc(addr, 1, dest);
ui.tableWidget->setItem(i, 1, new QTableWidgetItem(QString::number(dest[0])));
}
else { //读取DWORD值，4字节
int ret = m_PLCDevice->read_short_from_plc( addr, 2, dest16);
ui.tableWidget->setItem(i, 1, new QTableWidgetItem(QString::number(dest16[0] + (dest16[1] << 16))));
}
}
}
for (int i = 0; i < m_plc_items.size(); i++)
{
int addr = m_plc_items[i].address;
uint8_t dest[4];
uint16_t* dest16 = (uint16_t*)dest;
memset(dest, 0, 4);
if (addr > 0)
{
if (addr < 40000) //读取线圈值 bit
{
int ret = m_PLCDevice->read_bits_from_plc(addr, 1, dest);
ui.tableWidget->setItem(i, 1, new QTableWidgetItem(QString::number(dest[0])));
}
else { //读取DWORD值，4字节
int ret = m_PLCDevice->read_short_from_plc(addr, 2, dest16);
ui.tableWidget->setItem(i, 1, new QTableWidgetItem(QString::number(dest16[0] + (dest16[1] << 16))));
}
}
}
}
void PlcSetup::on_toolButton_keyboard_released()
{
std::thread osk_thread = std::thread(task_osk_);
osk_thread.detach();
std::thread osk_thread = std::thread(task_osk_);
osk_thread.detach();
}
void PlcSetup::on_toolButton_close_released()
{
g_plc_dialog_open = false;
this->close();
g_plc_dialog_open = false;
this->close();
}
void PlcSetup::handleTimeout()
{
on_toolButton_batch_read_released();
on_toolButton_batch_read_released();
}
void PlcSetup::read_plc_items()
{
std::fstream cfg_file;
QString plc_file = g_conf_path.config_path + "/" + PLC_CONFIG_FILE;
std::fstream cfg_file;
QString plc_file = g_conf_path.config_path + "/" + PLC_CONFIG_FILE;
cfg_file.open(plc_file.toLocal8Bit().constData());
cfg_file.open(plc_file.toLocal8Bit().constData());
if (!cfg_file.is_open())
{
std::cout << "Error: Open production file " << PLC_ITEM_FILE << std::endl;
return;
}
while (!cfg_file.eof())
{
char tmp[1024] = "";
cfg_file.getline(tmp, 1024);
std::string line(tmp);
std::cout << line << std::endl;
if (line.length() > 0)
{
std::vector<std::string> vec_info;
string_split(line, "|", vec_info);
if (vec_info.size() == 4)
{
PlcItem plc_item;
plc_item.func_desc = vec_info[0];
plc_item.address = atoi(vec_info[1].c_str());
plc_item.value = atoi(vec_info[2].c_str());
plc_item.memo = vec_info[3];
m_plc_items.push_back(plc_item);
}
}
}
cfg_file.close();
if (!cfg_file.is_open())
{
std::cout << "Error: Open production file " << PLC_ITEM_FILE << std::endl;
return;
}
while (!cfg_file.eof())
{
char tmp[1024] = "";
cfg_file.getline(tmp, 1024);
std::string line(tmp);
std::cout << line << std::endl;
if (line.length() > 0)
{
std::vector<std::string> vec_info;
string_split(line, "|", vec_info);
if (vec_info.size() == 4)
{
PlcItem plc_item;
plc_item.func_desc = vec_info[0];
plc_item.address = atoi(vec_info[1].c_str());
plc_item.value = atoi(vec_info[2].c_str());
plc_item.memo = vec_info[3];
m_plc_items.push_back(plc_item);
}
}
}
cfg_file.close();
}
void PlcSetup::save_plc_items()
{
std::fstream cfg_file;
QString plc_file = g_conf_path.config_path + "/" + PLC_CONFIG_FILE;
cfg_file.open(plc_file.toLocal8Bit().constData(), std::ios::out | std::ios::trunc);
if (cfg_file.good())
{
for (int i = 0; i < m_plc_items.size(); i++)
{
char buf[512];
memset(buf, 0, 512);
sprintf(buf, "%s|%d|%d|%s\n", m_plc_items[i].func_desc.c_str(),
m_plc_items[i].address, m_plc_items[i].value, m_plc_items[i].memo.c_str());
cfg_file.write(buf, strlen(buf));
}
cfg_file.close();
}
std::fstream cfg_file;
QString plc_file = g_conf_path.config_path + "/" + PLC_CONFIG_FILE;
cfg_file.open(plc_file.toLocal8Bit().constData(), std::ios::out | std::ios::trunc);
if (cfg_file.good())
{
for (int i = 0; i < m_plc_items.size(); i++)
{
char buf[512];
memset(buf, 0, 512);
sprintf(buf, "%s|%d|%d|%s\n", m_plc_items[i].func_desc.c_str(),
m_plc_items[i].address, m_plc_items[i].value, m_plc_items[i].memo.c_str());
cfg_file.write(buf, strlen(buf));
}
cfg_file.close();
}
}

32
Cigarette/plcsetup.hpp
Unescape Escape View File

@ -1,4 +1,4 @@
#pragma once
#pragma once
#include <QDialog>
#include <QPushButton>
#include "ui_plcsetup.h"
@ -11,29 +11,29 @@
class QTimer;
class PlcSetup : public QDialog {
Q_OBJECT
Q_OBJECT
public:
PlcSetup(QWidget * parent = Q_NULLPTR);
~PlcSetup();
PlcSetup(QWidget* parent = Q_NULLPTR);
~PlcSetup();
QTimer *m_pTimer;
QTimer* m_pTimer;
void read_plc_items();
void save_plc_items();
void read_plc_items();
void save_plc_items();
private slots:
void click_read();
void click_write();
void click_save();
void click_read();
void click_write();
void click_save();
void on_toolButton_batch_read_released();
void on_toolButton_keyboard_released();
void on_toolButton_close_released();
void on_toolButton_batch_read_released();
void on_toolButton_keyboard_released();
void on_toolButton_close_released();
void handleTimeout(); //窗口加载时执行一次，批处理读取所有地址
void handleTimeout(); //窗口加载时执行一次，批处理读取所有地址
private:
Ui::PlcSetup ui;
Ui::PlcSetup ui;
std::vector<PlcItem> m_plc_items;
std::vector<PlcItem> m_plc_items;
};

136
Cigarette/savethread.h
Unescape Escape View File

@ -12,89 +12,89 @@
#include <opencv2/opencv.hpp>
#include <opencv2/imgproc/types_c.h>
extern SyncQueue<std::pair<std::string, cv::Mat>>* g_save_queue; //ͼÏñ±£´æ¶ÓÁÐ
extern SyncQueue<std::pair<std::string, cv::Mat>>* g_save_queue; //图像保存队列
class SaveThread : public QThread
{
Q_OBJECT
Q_OBJECT
signals:
void sendDataToExport(QString filePath);
void sendDataToExport(QString filePath);
public:
SaveThread(QObject *parent = 0): QThread(parent)
{
SaveThread(QObject* parent = 0) : QThread(parent)
{
}
~SaveThread()
{
stop();
g_save_queue->put(std::make_pair("", cv::Mat()));
quit();
wait();
}
}
~SaveThread()
{
stop();
g_save_queue->put(std::make_pair("", cv::Mat()));
quit();
wait();
}
void init()
{
b_quit = false;
}
void start_work()
{
start(HighestPriority);
}
void stop()
{
b_quit = true;
}
void init()
{
b_quit = false;
}
void start_work()
{
start(HighestPriority);
}
void stop()
{
b_quit = true;
}
protected:
void run()
{
while (!b_quit) {
cv::Mat image;
std::pair<std::string, cv::Mat> element;
g_save_queue->take(element);
std::string file_name = element.first;
image = element.second;
if (image.data)
{
std::size_t found = file_name.find_last_of("/\\");
std::string dir_path = file_name.substr(0, found);
check_save_dir(dir_path);
bool b_save = cv::imwrite(file_name, image);
if (b_save)
{
//sendDataToExport(QString::fromStdString(file_name));
sendDataToExport(QString::fromLocal8Bit(QByteArray::fromRawData(file_name.c_str(), file_name.size())));
//qDebug() << "Save pic successfully";
}
}
}
}
void check_save_dir(std::string dir_path)
{
bool b_find = false;
for (int i = 0; i < vec_save_dirs.size(); i++)
{
while (!b_quit) {
cv::Mat image;
std::pair<std::string, cv::Mat> element;
g_save_queue->take(element);
std::string file_name = element.first;
image = element.second;
if (image.data)
{
std::size_t found = file_name.find_last_of("/\\");
std::string dir_path = file_name.substr(0, found);
check_save_dir(dir_path);
bool b_save = cv::imwrite(file_name, image);
if (b_save)
{
//sendDataToExport(QString::fromStdString(file_name));
sendDataToExport(QString::fromLocal8Bit(QByteArray::fromRawData(file_name.c_str(), file_name.size())));
//qDebug() << "Save pic successfully";
}
}
if (dir_path == vec_save_dirs[i])
{
b_find = true;
}
}
void check_save_dir(std::string dir_path)
{
bool b_find = false;
for (int i = 0; i < vec_save_dirs.size(); i++)
{
if (dir_path == vec_save_dirs[i])
{
b_find = true;
}
}
if (!b_find)
{
//QString dir_str = QString::fromStdString(dir_path);
QString dir_str = QString::fromLocal8Bit(QByteArray::fromRawData(dir_path.c_str(), dir_path.size()));
if (!b_find)
{
//QString dir_str = QString::fromStdString(dir_path);
QString dir_str = QString::fromLocal8Bit(QByteArray::fromRawData(dir_path.c_str(), dir_path.size()));
QDir dir;
if (!dir.exists(dir_str))
{
dir.mkpath(dir_str);
}
vec_save_dirs.push_back(dir_path);
}
}
QDir dir;
if (!dir.exists(dir_str))
{
dir.mkpath(dir_str);
}
vec_save_dirs.push_back(dir_path);
}
}
public:
bool b_quit;
std::vector<std::string> vec_save_dirs;
bool b_quit;
std::vector<std::string> vec_save_dirs;
};
#endif

513
Cigarette/syncworkthread.cpp
Unescape Escape View File

@ -8,17 +8,18 @@
#include "exportData.h"
#include <QMap>
extern AlgJd alg_jd[NumberOfSupportedCameras]; //检测胶点的AI算法
extern AlgJd alg_jd[NumberOfSupportedCameras]; //检测胶点的AI算法
extern ConfPath g_conf_path;
extern SysConf g_sys_conf; //系统配置参数
extern SysConf g_sys_conf; //系统配置参数
extern DisplayLabelConf g_display_label_conf[NumberOfSupportedCameras];
extern int rotationAngle[NumberOfSupportedCameras]; //图片旋转角度
extern int rotationAngle[NumberOfSupportedCameras]; //图片旋转角度
extern bool isNeedRotate[NumberOfSupportedCameras];
extern int work_camera_nums;
extern SingleCamInfoStruct SingleCamInfo[NumberOfSupportedCameras];
extern SyncQueue<std::pair<std::string, cv::Mat> >* g_save_queue; //图片保存队列
extern SyncQueue<std::pair<int, cv::Mat>>* g_image_queue[NumberOfSupportedCameras]; //int表示一个目标拍了几张
extern SyncQueue<std::pair<std::string, cv::Mat> >* g_save_queue; //图片保存队列
extern SyncQueue<std::pair<int, cv::Mat>>* g_image_queue[NumberOfSupportedCameras]; //int表示一个目标拍了几张
#ifdef __UDPSend
extern SyncQueue<_UDPSendInfo>* UDP_Info_queue;
#endif
@ -33,315 +34,317 @@ extern bool g_debug_mode;
SyncWorkThread::~SyncWorkThread()
{
stop();
std::vector<std::pair<int, cv::Mat>> queue;
local_g_image_sync_queue->put(queue);
quit();
wait();
stop();
std::vector<std::pair<int, cv::Mat>> queue;
local_g_image_sync_queue->put(queue);
quit();
wait();
}
void SyncWorkThread::init(SyncQueue<std::vector<std::pair<int, cv::Mat>>>* image_ptr, ASyncQueue<bool>* result_ptr)
{
local_g_image_sync_queue = image_ptr;
local_g_result_queue = result_ptr;
b_quit = false;
for (int i = 0; i < NumberOfSupportedCameras; i++) {
frame_total[i] = 0;
}
local_g_image_sync_queue = image_ptr;
local_g_result_queue = result_ptr;
b_quit = false;
for (int i = 0; i < NumberOfSupportedCameras; i++) {
frame_total[i] = 0;
}
}
void SyncWorkThread::start_work()
{
start(HighestPriority);
start(HighestPriority);
}
void SyncWorkThread::stop()
{
b_quit = true;
b_quit = true;
}
void SyncWorkThread::run()
{
try {
uint32_t result_index[NumberOfSupportedCameras] = { 0 };
while (!b_quit) {
QDateTime now_ts = QDateTime::currentDateTime();
std::vector<std::pair<int, cv::Mat>> element_vec;
local_g_image_sync_queue->take(element_vec);
bool IsNGForAll = false;
int merge_index;
cv::Rect roi;
int j = 0; // 实际工作的相机标识，element_vec中可能有相机没在工作
for (int i = 0; i < element_vec.size(); i++)//每个相机的图轮流遍历
{
local_camera_number = i;
int isWork = element_vec[i].first;
std::pair<int, cv::Mat> element;
element = element_vec[i];
int unit_count = element.first;
cv::Mat image = element.second;
{//不要删掉这个括号，用来定义锁的作用域
std::lock_guard<std::mutex> locker(g_sys_conf.lock);
local_SysConf.save = g_sys_conf.save;
local_SysConf.shoot[local_camera_number] = g_sys_conf.shoot[local_camera_number];
local_SysConf.MisMatchAct = g_sys_conf.MisMatchAct;
local_SysConf.ConfThreshold = g_sys_conf.ConfThreshold;//
for (int i = 0; i < 3; i++)local_SysConf.no[local_camera_number][i] = g_sys_conf.no[local_camera_number][i];
try {
uint32_t result_index[NumberOfSupportedCameras] = { 0 };
while (!b_quit) {
QDateTime now_ts = QDateTime::currentDateTime();
std::vector<std::pair<int, cv::Mat>> element_vec;
local_g_image_sync_queue->take(element_vec);
bool IsNGForAll = false;
int merge_index;
cv::Rect roi;
int j = 0; // 实际工作的相机标识，element_vec中可能有相机没在工作
for (int i = 0; i < element_vec.size(); i++)//每个相机的图轮流遍历
{
if (!SingleCamInfo[i].Detect || !SingleCamInfo[i].IsOpen || SingleCamInfo[i].OffLine)
continue;
local_camera_number = i;
int isWork = element_vec[i].first;
std::pair<int, cv::Mat> element;
element = element_vec[i];
int unit_count = element.first;
cv::Mat image = element.second;
{//不要删掉这个括号，用来定义锁的作用域
std::lock_guard<std::mutex> locker(g_sys_conf.lock);
local_SysConf.save = g_sys_conf.save;
local_SysConf.shoot[local_camera_number] = g_sys_conf.shoot[local_camera_number];
local_SysConf.MisMatchAct = g_sys_conf.MisMatchAct;
local_SysConf.ConfThreshold = g_sys_conf.ConfThreshold;//
for (int i = 0; i < 3; i++)local_SysConf.no[local_camera_number][i] = g_sys_conf.no[local_camera_number][i];
#ifdef DRAW_RECT
std::lock_guard<std::mutex> locker2(g_display_label_conf[local_camera_number].lock);
local_DisplayLabelConf.leftButtonDownFlag = g_display_label_conf[local_camera_number].leftButtonDownFlag;
local_DisplayLabelConf.Flag[0] = g_display_label_conf[local_camera_number].Flag[0];
local_DisplayLabelConf.Flag[1] = g_display_label_conf[local_camera_number].Flag[1];
local_DisplayLabelConf.originalPoint = g_display_label_conf[local_camera_number].originalPoint;
local_DisplayLabelConf.processPoint = g_display_label_conf[local_camera_number].processPoint;
local_DisplayLabelConf.RectVet[0] = g_display_label_conf[local_camera_number].RectVet[0];
local_DisplayLabelConf.RectVet[1] = g_display_label_conf[local_camera_number].RectVet[1];
std::lock_guard<std::mutex> locker2(g_display_label_conf[local_camera_number].lock);
local_DisplayLabelConf.leftButtonDownFlag = g_display_label_conf[local_camera_number].leftButtonDownFlag;
local_DisplayLabelConf.Flag[0] = g_display_label_conf[local_camera_number].Flag[0];
local_DisplayLabelConf.Flag[1] = g_display_label_conf[local_camera_number].Flag[1];
local_DisplayLabelConf.originalPoint = g_display_label_conf[local_camera_number].originalPoint;
local_DisplayLabelConf.processPoint = g_display_label_conf[local_camera_number].processPoint;
local_DisplayLabelConf.RectVet[0] = g_display_label_conf[local_camera_number].RectVet[0];
local_DisplayLabelConf.RectVet[1] = g_display_label_conf[local_camera_number].RectVet[1];
#endif
}
}
#ifdef __UDPSend
_UDPSendInfo UDPSendInfo;
UDPSendInfo.FrameID = info_frame;
UDPSendInfo.index = local_camera_number;
_UDPSendInfo UDPSendInfo;
UDPSendInfo.FrameID = info_frame;
UDPSendInfo.index = local_camera_number;
#endif
#ifdef __TCPSend
_TCPSendInfo TCPSendInfo;
_TCPSendInfo TCPSendInfo;
#endif
if (!image.data)
{
continue; //图像为空，跳过
}
cv::Mat merge_image = cv::Mat::zeros(512 * work_camera_nums, 640 * g_sys_conf.shoot[i], CV_8UC3);
if (image.channels() == 1)
{
cv::cvtColor(image, image, CV_BGR2RGB); //灰度图像转为彩色图像
}
cv::resize(image, image, cv::Size(640, 512 * unit_count));
if (local_SysConf.shoot[local_camera_number] == unit_count)
{
std::vector<cv::Mat> vec_in;
int w = image.cols;
int h = image.rows / unit_count;
for (int index = 0; index < unit_count; index++) {
cv::Rect temp_Rect(0, h * index, w, h);
cv::Mat temp_image = image(temp_Rect).clone();
if (isNeedRotate[local_camera_number]) {
if (rotationAngle[local_camera_number] != (cv::ROTATE_90_COUNTERCLOCKWISE + 1))
{
cv::rotate(temp_image, temp_image, rotationAngle[local_camera_number]);
}
}
vec_in.push_back(temp_image.clone());
}
if (!image.data)
{
continue; //图像为空，跳过
}
cv::Mat merge_image = cv::Mat::zeros(512 * work_camera_nums, 640 * g_sys_conf.shoot[i], CV_8UC3);
if (image.channels() == 1)
{
cv::cvtColor(image, image, CV_BGR2RGB); //灰度图像转为彩色图像
}
cv::resize(image, image, cv::Size(640, 512 * unit_count));
if (local_SysConf.shoot[local_camera_number] == unit_count)
{
std::vector<cv::Mat> vec_in;
int w = image.cols;
int h = image.rows / unit_count;
for (int index = 0; index < unit_count; index++) {
cv::Rect temp_Rect(0, h * index, w, h);
cv::Mat temp_image = image(temp_Rect).clone();
if (isNeedRotate[local_camera_number]) {
if (rotationAngle[local_camera_number] != (cv::ROTATE_90_COUNTERCLOCKWISE + 1))
{
cv::rotate(temp_image, temp_image, rotationAngle[local_camera_number]);
}
}
vec_in.push_back(temp_image.clone());
}
std::vector<cv::Mat> vec_out;
std::vector<std::vector<std::pair<int, cv::Rect>>> vec_results;
QDateTime ts_start = QDateTime::currentDateTime();
if (unit_count == 1) {
std::vector<std::pair<int, cv::Rect>> results;
cv::Mat imagein, imageout;
imagein = vec_in[0];
alg_jd[local_camera_number].detect(imagein, imageout, results);
vec_out.push_back(imageout.clone());
vec_results.push_back(results);
}
else {
alg_jd[local_camera_number].detect_batch(vec_in, vec_out, vec_results);
}
QDateTime ts_jd = QDateTime::currentDateTime();
int time_process = ts_start.msecsTo(ts_jd);
std::vector<cv::Mat> vec_out;
std::vector<std::vector<std::pair<int, cv::Rect>>> vec_results;
QDateTime ts_start = QDateTime::currentDateTime();
if (unit_count == 1) {
std::vector<std::pair<int, cv::Rect>> results;
cv::Mat imagein, imageout;
imagein = vec_in[0];
alg_jd[local_camera_number].detect(imagein, imageout, results);
vec_out.push_back(imageout.clone());
vec_results.push_back(results);
}
else {
alg_jd[local_camera_number].detect_batch(vec_in, vec_out, vec_results);
}
QDateTime ts_jd = QDateTime::currentDateTime();
int time_process = ts_start.msecsTo(ts_jd);
#ifdef SYNC_CAMERA
emit display_timecost(local_camera_number, time_process);
emit display_timecost(local_camera_number, time_process);
#endif
#ifdef __UDPSend
UDPSendInfo.timecost = QString::number(time_process);
UDPSendInfo.timecost = QString::number(time_process);
#endif
cv::Mat image1;
cv::Mat image2;
QString jd_no;
for (int index = 0; index < unit_count; index++) {
jd_no += QString::number(vec_results[index].size()) + ",";
}
jd_no.chop(1);
cv::Mat image1;
cv::Mat image2;
QString jd_no;
for (int index = 0; index < unit_count; index++) {
jd_no += QString::number(vec_results[index].size()) + ",";
}
jd_no.chop(1);
#ifdef SYNC_CAMERA
emit display_jd_no(local_camera_number, jd_no);
emit display_jd_no(local_camera_number, jd_no);
#endif
#ifdef __UDPSend
UDPSendInfo.JD = jd_no;
UDPSendInfo.JD = jd_no;
#endif
bool IsNG = false;
int ngReason = 0;
QMap<int, QString> ng_reason_maps;
ng_reason_maps[0] = "unknow";
ng_reason_maps[1] = "less_than_setting";
ng_reason_maps[2] = "too_diff_from_model";
ng_reason_maps[3] = "out_of_setting_range";
for (int index = 0; index < unit_count; index++){
if (vec_results[index].size() < local_SysConf.no[local_camera_number][index])
{
IsNG |= true;
ngReason = 1;
}
//if (vec_results[index].size() != 1)IsNG |= true;//反向训练
if (local_SysConf.ConfThreshold == 0)
{
IsNG = false;
ngReason = 0;
}
if (local_SysConf.save == 2)//三张照片分别存储
{
/// 合成element_vec.size() * unit_count 宫格图像
cv::Mat m = vec_in[index].clone();
QString file_name;
merge_index = j * unit_count + index + 1;
roi = cv::Rect(index * m.cols, j * m.rows, m.cols, m.rows);
m.copyTo(merge_image(roi));
bool IsNG = false;
int ngReason = 0;
QMap<int, QString> ng_reason_maps;
ng_reason_maps[0] = "unknow";
ng_reason_maps[1] = "less_than_setting";
ng_reason_maps[2] = "too_diff_from_model";
ng_reason_maps[3] = "out_of_setting_range";
for (int index = 0; index < unit_count; index++) {
if (vec_results[index].size() < local_SysConf.no[local_camera_number][index])
{
IsNG |= true;
ngReason = 1;
}
//if (vec_results[index].size() != 1)IsNG |= true;//反向训练
if (local_SysConf.ConfThreshold == 0)
{
IsNG = false;
ngReason = 0;
}
if (local_SysConf.save == 2)//三张照片分别存储
{
/// 合成element_vec.size() * unit_count 宫格图像
cv::Mat m = vec_in[index].clone();
QString file_name;
merge_index = j * unit_count + index + 1;
roi = cv::Rect(index * m.cols, j * m.rows, m.cols, m.rows);
m.copyTo(merge_image(roi));
if (merge_index == work_camera_nums * unit_count) {
file_name = g_conf_path.save_pics_path + "/"
+ now_ts.toString("yyyy-MM-dd") + "/"
+ now_ts.toString("yyyy-MM-dd_HH-mm-ss_zzz_") + ".jpg";
g_save_queue->put(std::make_pair(file_name.toLocal8Bit().constData(), merge_image));
if (merge_index == work_camera_nums * unit_count) {
file_name = g_conf_path.save_pics_path + "/"
+ now_ts.toString("yyyy-MM-dd") + "/"
+ now_ts.toString("yyyy-MM-dd_HH-mm-ss_zzz_") + ".jpg";
g_save_queue->put(std::make_pair(file_name.toLocal8Bit().constData(), merge_image));
#ifdef __TCPSend
TCPSendInfo.pics_name = file_name.toLocal8Bit().constData();
TCP_Info_queue->put(TCPSendInfo);
TCPSendInfo.pics_name = file_name.toLocal8Bit().constData();
TCP_Info_queue->put(TCPSendInfo);
#endif
}
}
}
}
}
}
if (unit_count >= 2) {
image1 = vec_out[(result_index[i]) % 2].clone();
if (unit_count >= 2) {
image1 = vec_out[(result_index[i]) % 2].clone();
#ifdef DRAW_RECT
IsNG |= CheckSelectRects(image1, vec_results, (result_index[i]) % 2, local_DisplayLabelConf, 0);
if (IsNG) {
ngReason = 2;
}
IsNG |= CheckSelectRects(image1, vec_results, (result_index[i]) % 2, local_DisplayLabelConf, 0);
if (IsNG) {
ngReason = 2;
}
#endif
}
else {
image1 = vec_out[0].clone();
}
else {
image1 = vec_out[0].clone();
#ifdef DRAW_RECT
IsNG |= CheckSelectRects(image1, vec_results, 0, local_DisplayLabelConf, 0);
if (IsNG) {
ngReason = 2;
}
IsNG |= CheckSelectRects(image1, vec_results, 0, local_DisplayLabelConf, 0);
if (IsNG) {
ngReason = 2;
}
#endif
}
}
#ifdef DRAW_RECT
DrawSelectRects(image1, local_DisplayLabelConf, 0);
DrawSelectRects(image1, local_DisplayLabelConf, 0);
#endif
if (unit_count >= 3) {
image2 = vec_out[2].clone();
if (unit_count >= 3) {
image2 = vec_out[2].clone();
#ifdef DRAW_RECT
DrawSelectRects(image2, local_DisplayLabelConf, 1);
IsNG |= CheckSelectRects(image1, vec_results, 2, local_DisplayLabelConf, 1);
if (IsNG) {
ngReason = 3;
}
DrawSelectRects(image2, local_DisplayLabelConf, 1);
IsNG |= CheckSelectRects(image1, vec_results, 2, local_DisplayLabelConf, 1);
if (IsNG) {
ngReason = 3;
}
#endif
}
result_index[i]++;
}
result_index[i]++;
if (!IsNG)
{
if (!g_debug_mode)
{
if (!IsNG)
{
if (!g_debug_mode)
{
#ifdef SYNC_CAMERA
emit event_ok(local_camera_number);
emit event_ok(local_camera_number);
#endif
local_g_result_queue->put(true);
}
}
else
{
if (!g_debug_mode)
{
local_g_result_queue->put(true);
}
}
else
{
if (!g_debug_mode)
{
#ifdef SYNC_CAMERA
emit event_ng(local_camera_number);
emit event_ng(local_camera_number);
#endif
local_g_result_queue->put(false);
IsNGForAll = TRUE;
}
local_g_result_queue->put(false);
IsNGForAll = TRUE;
}
if ((local_SysConf.save == 2) || (local_SysConf.save == 1))
{
for (int index = 0; index < unit_count; index++)
{
cv::Mat m = vec_in[index].clone();
QString file_name = g_conf_path.save_pics_path + "/ng/" +
now_ts.toString("yyyy-MM-dd") + "/"
+ QString::number(local_camera_number + 1) + "/" + QString::number(index + 1) + "/" +
now_ts.toString("yyyy-MM-dd_HH-mm-ss_zzz_") + QString::number(local_camera_number + 1) +
"#" + "_" + QString::number(index + 1) + "_" + ng_reason_maps[ngReason] +
".jpg";
QString remotePath = "/image/ng/" +
now_ts.toString("yyyy-MM-dd_HH-mm-ss_zzz_") + QString::number(local_camera_number + 1) +
"#" + "_" + QString::number(index + 1) + "_" + ng_reason_maps[ngReason] +
".jpg";
//g_save_queue->put(std::make_pair(file_name.toLocal8Bit().constData(), m));
if ((local_SysConf.save == 2) || (local_SysConf.save == 1))
{
for (int index = 0; index < unit_count; index++)
{
cv::Mat m = vec_in[index].clone();
QString file_name = g_conf_path.save_pics_path + "/ng/" +
now_ts.toString("yyyy-MM-dd") + "/"
+ QString::number(local_camera_number + 1) + "/" + QString::number(index + 1) + "/" +
now_ts.toString("yyyy-MM-dd_HH-mm-ss_zzz_") + QString::number(local_camera_number + 1) +
"#" + "_" + QString::number(index + 1) + "_" + ng_reason_maps[ngReason] +
".jpg";
QString remotePath = "/image/ng/" +
now_ts.toString("yyyy-MM-dd_HH-mm-ss_zzz_") + QString::number(local_camera_number + 1) +
"#" + "_" + QString::number(index + 1) + "_" + ng_reason_maps[ngReason] +
".jpg";
//g_save_queue->put(std::make_pair(file_name.toLocal8Bit().constData(), m));
m = vec_out[index].clone();
file_name = g_conf_path.save_pics_path + "/ng_result/" +
now_ts.toString("yyyy-MM-dd") + "/"
+ QString::number(local_camera_number + 1) + "/" + QString::number(index + 1) + "/" +
now_ts.toString("yyyy-MM-dd_HH-mm-ss_zzz_") + QString::number(local_camera_number + 1) +
"#" + "_" + QString::number(index + 1) + "_" + ng_reason_maps[ngReason] +
".jpg";
remotePath = "/image/ng_result/" +
now_ts.toString("yyyy-MM-dd_HH-mm-ss_zzz_") + QString::number(local_camera_number + 1) +
"#" + "_" + QString::number(index + 1) + "_" + ng_reason_maps[ngReason] +
".jpg";
//g_save_queue->put(std::make_pair(file_name.toStdString(), m));
//g_save_queue->put(std::make_pair(file_name.toLocal8Bit().constData(), m));
}
}
}
m = vec_out[index].clone();
file_name = g_conf_path.save_pics_path + "/ng_result/" +
now_ts.toString("yyyy-MM-dd") + "/"
+ QString::number(local_camera_number + 1) + "/" + QString::number(index + 1) + "/" +
now_ts.toString("yyyy-MM-dd_HH-mm-ss_zzz_") + QString::number(local_camera_number + 1) +
"#" + "_" + QString::number(index + 1) + "_" + ng_reason_maps[ngReason] +
".jpg";
remotePath = "/image/ng_result/" +
now_ts.toString("yyyy-MM-dd_HH-mm-ss_zzz_") + QString::number(local_camera_number + 1) +
"#" + "_" + QString::number(index + 1) + "_" + ng_reason_maps[ngReason] +
".jpg";
//g_save_queue->put(std::make_pair(file_name.toStdString(), m));
//g_save_queue->put(std::make_pair(file_name.toLocal8Bit().constData(), m));
}
}
}
#ifdef SYNC_CAMERA
if (!g_debug_mode)
{
if(isWork != 0)
emit display_check_total(local_camera_number, ++frame_total[local_camera_number]);
//exportDataInfo.cameraTotal = frame_total;
emit notify(local_camera_number, 0, image1);
if (unit_count >= 3)
emit notify(local_camera_number, 1, image2);
}
if (!g_debug_mode)
{
emit display_check_total(local_camera_number, ++frame_total[local_camera_number]);
//exportDataInfo.cameraTotal = frame_total;
emit notify(local_camera_number, 0, image1);
if (unit_count >= 3)
emit notify(local_camera_number, 1, image2);
}
#endif
}
else
{
}
else
{
#ifdef SYNC_CAMERA
//保证不错位
if (!g_debug_mode)
{
if (local_SysConf.MisMatchAct == 1)//as ng
emit event_ng(local_camera_number);
else if (local_SysConf.MisMatchAct == 0)//as ok
emit event_ok(local_camera_number);
emit display_check_total(local_camera_number, ++(frame_total[local_camera_number]));
qDebug() << local_camera_number << "#camera# " << now_ts.toString("yyyy-MM-dd_HH-mm-ss_zzz_") << "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx " << unit_count;
}
//保证不错位
if (!g_debug_mode)
{
if (local_SysConf.MisMatchAct == 1)//as ng
emit event_ng(local_camera_number);
else if (local_SysConf.MisMatchAct == 0)//as ok
emit event_ok(local_camera_number);
emit display_check_total(local_camera_number, ++(frame_total[local_camera_number]));
qDebug() << local_camera_number << "#camera# " << now_ts.toString("yyyy-MM-dd_HH-mm-ss_zzz_") << "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx " << unit_count;
}
#endif
}
}
#ifdef __UDPSend
UDP_Info_queue->put(UDPSendInfo);
UDP_Info_queue->put(UDPSendInfo);
#endif
j++;
}
if (IsNGForAll)
{
/*to do something*/
}
}
}
catch (cv::Exception& e)
{
const char* err_msg = e.what();
std::cout << "exception caught: " << err_msg << std::endl;
}
j++;
}
if (IsNGForAll)
{
/*to do something*/
}
}
}
catch (cv::Exception& e)
{
const char* err_msg = e.what();
std::cout << "exception caught: " << err_msg << std::endl;
}
}

42
Cigarette/syncworkthread.h
Unescape Escape View File

@ -14,33 +14,33 @@ class SyncWorkThread :
#ifdef SYNC_CAMERA
signals:
void notify(int Num, int Cnt, cv::Mat);
void display_timecost(int Num, int ms);
void display_check_total(int Num, long no);
void display_jd_no(int Num, QString jd_no);
void notify(int Num, int Cnt, cv::Mat);
void display_timecost(int Num, int ms);
void display_check_total(int Num, long no);
void display_jd_no(int Num, QString jd_no);
void event_ok(int Num);
void event_ng(int Num);
void event_ok(int Num);
void event_ng(int Num);
#endif
public:
SyncWorkThread(QObject* parent = 0) : QThread(parent)
{
SyncWorkThread(QObject* parent = 0) : QThread(parent)
{
}
~SyncWorkThread();
}
~SyncWorkThread();
void init(SyncQueue<std::vector<std::pair<int, cv::Mat>>>* image_ptr, ASyncQueue<bool>* result_ptr);
void start_work();
void stop();
void init(SyncQueue<std::vector<std::pair<int, cv::Mat>>>* image_ptr, ASyncQueue<bool>* result_ptr);
void start_work();
void stop();
protected:
void run();
void run();
public:
int local_camera_number;
SyncQueue<std::vector<std::pair<int, cv::Mat>>>* local_g_image_sync_queue;
ASyncQueue<bool>* local_g_result_queue;
bool b_quit;
long frame_total[NumberOfSupportedCameras];
SysConf local_SysConf;
DisplayLabelConf local_DisplayLabelConf;
int local_camera_number;
SyncQueue<std::vector<std::pair<int, cv::Mat>>>* local_g_image_sync_queue;
ASyncQueue<bool>* local_g_result_queue;
bool b_quit;
long frame_total[NumberOfSupportedCameras];
SysConf local_SysConf;
DisplayLabelConf local_DisplayLabelConf;
};

122
Cigarette/threadReceive.cpp
Unescape Escape View File

@ -3,87 +3,87 @@
#include "basecamera.h"
void threadReceive::start_work()
{
//start(HighestPriority);
start();
//start(HighestPriority);
start();
}
void threadReceive::stop()
{
isLoop = false;
BOOL bDontLinger = FALSE;
mSocket->abort();
filemSocket->abort();
// wait();
isLoop = false;
BOOL bDontLinger = FALSE;
mSocket->abort();
filemSocket->abort();
// wait();
}
void threadReceive::init(std::string IP,int port)
void threadReceive::init(std::string IP, int port)
{
ip = QString::fromStdString(IP);
ip = QString::fromStdString(IP);
mSocket = new QUdpSocket(this);
mSocket->bind(port + NumberOfSupportedCameras*2+1, QUdpSocket::ShareAddress);
connect(mSocket, &QUdpSocket::readyRead, this, &threadReceive::processPendingDatagram);
mSocket = new QUdpSocket(this);
mSocket->bind(port + NumberOfSupportedCameras * 2 + 1, QUdpSocket::ShareAddress);
connect(mSocket, &QUdpSocket::readyRead, this, &threadReceive::processPendingDatagram);
filemSocket = new QUdpSocket(this);
filemSocket->bind(port + NumberOfSupportedCameras*2+2, QUdpSocket::ShareAddress);
connect(filemSocket, &QUdpSocket::readyRead, this, &threadReceive::fileprocessPendingDatagram);
filemSocket = new QUdpSocket(this);
filemSocket->bind(port + NumberOfSupportedCameras * 2 + 2, QUdpSocket::ShareAddress);
connect(filemSocket, &QUdpSocket::readyRead, this, &threadReceive::fileprocessPendingDatagram);
}
void threadReceive::processPendingDatagram()
{
// 拥有等待的数据报
while (mSocket->hasPendingDatagrams())
{
QByteArray datagram;
// 拥有等待的数据报
while (mSocket->hasPendingDatagrams())
{
QByteArray datagram;
// 让datagram的大小为等待处理的数据报的大小，这样才能接收到完整的数据
datagram.resize(mSocket->pendingDatagramSize());
// 让datagram的大小为等待处理的数据报的大小，这样才能接收到完整的数据
datagram.resize(mSocket->pendingDatagramSize());
// 接收数据报，将其存放到datagram中
mSocket->readDatagram(datagram.data(), datagram.size());
QString data = datagram;
// 接收数据报，将其存放到datagram中
mSocket->readDatagram(datagram.data(), datagram.size());
QString data = datagram;
emit sendMsgToCigratte(data);
}
emit sendMsgToCigratte(data);
}
}
void threadReceive::fileprocessPendingDatagram()
{
QString filename;
std::fstream file;
// 拥有等待的数据报
while (filemSocket->hasPendingDatagrams())
{
QByteArray datagram;
// 让datagram的大小为等待处理的数据报的大小，这样才能接收到完整的数据
datagram.resize(filemSocket->pendingDatagramSize());
QString filename;
std::fstream file;
// 拥有等待的数据报
while (filemSocket->hasPendingDatagrams())
{
QByteArray datagram;
// 让datagram的大小为等待处理的数据报的大小，这样才能接收到完整的数据
datagram.resize(filemSocket->pendingDatagramSize());
// 接收数据报，将其存放到datagram中
filemSocket->readDatagram(datagram.data(), datagram.size());
QString data = datagram;
// 接收数据报，将其存放到datagram中
filemSocket->readDatagram(datagram.data(), datagram.size());
QString data = datagram;
QString str = data.mid(0, 4);
if (str == "SYNC")
{
str = data.mid(4, 3);
if (str == "str")
{
filename = data.mid(7, data.length() - 7);
file.open(("../conf/" + filename.toStdString()).c_str(), std::ios::out | std::ios::trunc | ios::binary);
}
else if (str == "con")
{
str = data.mid(7, data.length() - 7);
if (file.is_open())
{
file.write(str.toStdString().c_str(), str.toStdString().size());
}
}
else if (str == "end")
{
str = data.mid(7, data.length() - 7);
file.close();
}
}
}
QString str = data.mid(0, 4);
if (str == "SYNC")
{
str = data.mid(4, 3);
if (str == "str")
{
filename = data.mid(7, data.length() - 7);
file.open(("../conf/" + filename.toStdString()).c_str(), std::ios::out | std::ios::trunc | ios::binary);
}
else if (str == "con")
{
str = data.mid(7, data.length() - 7);
if (file.is_open())
{
file.write(str.toStdString().c_str(), str.toStdString().size());
}
}
else if (str == "end")
{
str = data.mid(7, data.length() - 7);
file.close();
}
}
}
}

42
Cigarette/threadReceive.h
Unescape Escape View File

@ -13,33 +13,33 @@
class threadReceive : public QThread
{
Q_OBJECT
Q_OBJECT
public:
QString ip;
threadReceive(QObject* o = nullptr) :QThread(o)
{
isLoop = true;
}
QString ip;
threadReceive(QObject* o = nullptr) :QThread(o)
{
isLoop = true;
}
~threadReceive()
{
stop();
quit();
wait();
}
void stop();
void init(std::string IP,int port);
void start_work();
~threadReceive()
{
stop();
quit();
wait();
}
void stop();
void init(std::string IP, int port);
void start_work();
private slots:
void processPendingDatagram();
void fileprocessPendingDatagram();
void processPendingDatagram();
void fileprocessPendingDatagram();
signals:
void sendMsgToCigratte(QString data);
void sendMsgToCigratte(QString data);
public:
std::atomic_bool isLoop = { 0 };
QUdpSocket *mSocket;
QUdpSocket *filemSocket;
std::atomic_bool isLoop = { 0 };
QUdpSocket* mSocket;
QUdpSocket* filemSocket;
};

90
Cigarette/threadSend.cpp
Unescape Escape View File

@ -3,13 +3,13 @@
#include "basecamera.h"
#include <QFile>
#include <QFileInfo>
void threadSend::init(SyncQueue<_UDPSendInfo> *p_UDP_Info_queue,std::string IP,int port)
void threadSend::init(SyncQueue<_UDPSendInfo>* p_UDP_Info_queue, std::string IP, int port)
{
ip = QString::fromStdString(IP);
dataport = port;
imageport = port+NumberOfSupportedCameras;
imageport = port + NumberOfSupportedCameras;
Local_UDP_Info_queue = p_UDP_Info_queue;
qDebug() << "MonitorIP ip:"<<ip<<"|MonitorPort:"<<dataport;
qDebug() << "MonitorIP ip:" << ip << "|MonitorPort:" << dataport;
}
void threadSend::start_work()
{
@ -29,40 +29,40 @@ void threadSend::run()
{
_UDPSendInfo UDPSendInfo;
Local_UDP_Info_queue->take(UDPSendInfo);
switch(UDPSendInfo.FrameID){
case info_frame:{
sendData(&UDPSendInfo, dataport);
break;
}
case speed_frame:{
sendSpeed(&UDPSendInfo, dataport);
break;
}
case kick_frame:{
sendKick(&UDPSendInfo, dataport);
break;
}
case ok_frame:{
sendOK(&UDPSendInfo, dataport);
break;
}
case ng_frame:{
sendNG(&UDPSendInfo, dataport);
break;
}
case total_frame:{
sendTotal(&UDPSendInfo, dataport);
break;
}
case image_frame:{
sendImage(&UDPSendInfo,imageport);
break;
}
switch (UDPSendInfo.FrameID) {
case info_frame: {
sendData(&UDPSendInfo, dataport);
break;
}
case speed_frame: {
sendSpeed(&UDPSendInfo, dataport);
break;
}
case kick_frame: {
sendKick(&UDPSendInfo, dataport);
break;
}
case ok_frame: {
sendOK(&UDPSendInfo, dataport);
break;
}
case ng_frame: {
sendNG(&UDPSendInfo, dataport);
break;
}
case total_frame: {
sendTotal(&UDPSendInfo, dataport);
break;
}
case image_frame: {
sendImage(&UDPSendInfo, imageport);
break;
}
}
}
}
void threadSend::sendData(_UDPSendInfo *UDPSendInfo,int port)
void threadSend::sendData(_UDPSendInfo* UDPSendInfo, int port)
{
QString res = QString("%1_%2_%3")
.arg(QString::number(UDPSendInfo->FrameID))
@ -76,26 +76,26 @@ void threadSend::sendData(QString data, int port)
mSocket.writeDatagram(data.toUtf8(), QHostAddress(ip), port);
}
void threadSend::sendImage(_UDPSendInfo *UDPSendInfo,int port)
void threadSend::sendImage(_UDPSendInfo* UDPSendInfo, int port)
{
cv::Mat mat = UDPSendInfo->image;
char cnt = UDPSendInfo->cnt;
//cv::resize(mat, mat, cv::Size(image_width, image_heigh));
cv::resize(mat, mat, cv::Size(image_width, image_heigh),4,4,2);
cv::resize(mat, mat, cv::Size(image_width, image_heigh), 4, 4, 2);
int length = image_width * image_heigh * 3;
char* data = (char*)malloc(sizeof(char) * length + 1);
if (data)
{
memcpy(data, &cnt, 1);
memcpy(data+1, mat.data, length);
int ret=mSocket.writeDatagram((char*)data, length+1, QHostAddress(ip), port + UDPSendInfo->index);
memcpy(data + 1, mat.data, length);
int ret = mSocket.writeDatagram((char*)data, length + 1, QHostAddress(ip), port + UDPSendInfo->index);
free(data);
}
}
void threadSend::sendSpeed(_UDPSendInfo *UDPSendInfo,int port)
void threadSend::sendSpeed(_UDPSendInfo* UDPSendInfo, int port)
{
QString res = QString("%1_%2")
.arg(QString::number(UDPSendInfo->FrameID))
@ -103,7 +103,7 @@ void threadSend::sendSpeed(_UDPSendInfo *UDPSendInfo,int port)
mSocket.writeDatagram(res.toUtf8(), QHostAddress(ip), port + UDPSendInfo->index);
}
void threadSend::sendKick(_UDPSendInfo *UDPSendInfo,int port)
void threadSend::sendKick(_UDPSendInfo* UDPSendInfo, int port)
{
QString res = QString("%1_%2")
.arg(QString::number(UDPSendInfo->FrameID))
@ -111,7 +111,7 @@ void threadSend::sendKick(_UDPSendInfo *UDPSendInfo,int port)
mSocket.writeDatagram(res.toUtf8(), QHostAddress(ip), port + UDPSendInfo->index);
}
void threadSend::sendOK(_UDPSendInfo *UDPSendInfo,int port)
void threadSend::sendOK(_UDPSendInfo* UDPSendInfo, int port)
{
QString res = QString("%1_%2")
.arg(QString::number(UDPSendInfo->FrameID))
@ -119,7 +119,7 @@ void threadSend::sendOK(_UDPSendInfo *UDPSendInfo,int port)
mSocket.writeDatagram(res.toUtf8(), QHostAddress(ip), port + UDPSendInfo->index);
}
void threadSend::sendNG(_UDPSendInfo *UDPSendInfo,int port)
void threadSend::sendNG(_UDPSendInfo* UDPSendInfo, int port)
{
QString res = QString("%1_%2")
.arg(QString::number(UDPSendInfo->FrameID))
@ -127,7 +127,7 @@ void threadSend::sendNG(_UDPSendInfo *UDPSendInfo,int port)
mSocket.writeDatagram(res.toUtf8(), QHostAddress(ip), port + UDPSendInfo->index);
}
void threadSend::sendTotal(_UDPSendInfo *UDPSendInfo,int port)
void threadSend::sendTotal(_UDPSendInfo* UDPSendInfo, int port)
{
QString res = QString("%1_%2")
.arg(QString::number(UDPSendInfo->FrameID))
@ -143,11 +143,11 @@ void threadSend::sendFile(QString FilePath, int port)
if (file.size() > 0) {
bool isOk = file.open(QIODevice::ReadOnly);
if (false == isOk) {
return ;
return;
}
}
else {
return ;
return;
}
QString sync("SYNC");
if (!file.atEnd()) {
@ -157,7 +157,7 @@ void threadSend::sendFile(QString FilePath, int port)
mSocket.writeDatagram(FileStartFrame.toLatin1(), QHostAddress(ip), port);
}
msleep(10);
msleep(10);
while (!file.atEnd()) {//文件指针
QString FileFrame(sync);
FileFrame.append("con");

110
Cigarette/threadSend.h
Unescape Escape View File

@ -25,72 +25,72 @@
class _UDPSendInfo
{
public:
int FrameID;
int index;
cv::Mat image;
int cnt;
long Total;
QString JD;
QString timecost;
int ok[NumberOfSupportedCameras];
int ng[NumberOfSupportedCameras];
QString speed;
int Kick[NumberOfSupportedCameras];
int FrameID;
int index;
cv::Mat image;
int cnt;
long Total;
QString JD;
QString timecost;
int ok[NumberOfSupportedCameras];
int ng[NumberOfSupportedCameras];
QString speed;
int Kick[NumberOfSupportedCameras];
_UDPSendInfo()
{
FrameID = 0;
index = 0;
image = cv::Mat(image_width, image_heigh, CV_8UC3, cv::Scalar(0,0,0));
Total = 0;
JD = QString("0,0,0");
timecost = QString("0ms");;
for (int i = 0; i < NumberOfSupportedCameras; i++)ok[i] = 0;
for (int i = 0; i < NumberOfSupportedCameras; i++)ng[i] = 0;
speed = QString(" ");
for(int i=0;i<NumberOfSupportedCameras;i++)Kick[i]=0;
}
_UDPSendInfo()
{
FrameID = 0;
index = 0;
image = cv::Mat(image_width, image_heigh, CV_8UC3, cv::Scalar(0, 0, 0));
Total = 0;
JD = QString("0,0,0");
timecost = QString("0ms");;
for (int i = 0; i < NumberOfSupportedCameras; i++)ok[i] = 0;
for (int i = 0; i < NumberOfSupportedCameras; i++)ng[i] = 0;
speed = QString(" ");
for (int i = 0; i < NumberOfSupportedCameras; i++)Kick[i] = 0;
}
};
class threadSend : public QThread
{
public:
QString ip;
int dataport;
int imageport;
threadSend(QObject* o = nullptr) :QThread(o)
{
isLoop = true;
}
QString ip;
int dataport;
int imageport;
threadSend(QObject* o = nullptr) :QThread(o)
{
isLoop = true;
}
~threadSend()
{
stop();
_UDPSendInfo UDPSendInfo;
Local_UDP_Info_queue->put(UDPSendInfo);
quit();
wait();
}
void stop();
~threadSend()
{
stop();
_UDPSendInfo UDPSendInfo;
Local_UDP_Info_queue->put(UDPSendInfo);
quit();
wait();
}
void stop();
protected:
void run();
void run();
public:
void init(SyncQueue<_UDPSendInfo> *p_UDP_Info_queue,std::string IP,int port);
void start_work();
void init(SyncQueue<_UDPSendInfo>* p_UDP_Info_queue, std::string IP, int port);
void start_work();
void sendData(_UDPSendInfo *UDPSendInfo,int port);
void sendData(QString data, int port);
void sendImage(_UDPSendInfo *UDPSendInfo,int port);
void sendSpeed(_UDPSendInfo *UDPSendInfo,int port);
void sendKick(_UDPSendInfo *UDPSendInfo,int port);
void sendOK(_UDPSendInfo *UDPSendInfo,int port);
void sendNG(_UDPSendInfo *UDPSendInfo,int port);
void sendTotal(_UDPSendInfo *UDPSendInfo,int port);
void sendFile(QString FilePath, int port);
void sendData(_UDPSendInfo* UDPSendInfo, int port);
void sendData(QString data, int port);
void sendImage(_UDPSendInfo* UDPSendInfo, int port);
void sendSpeed(_UDPSendInfo* UDPSendInfo, int port);
void sendKick(_UDPSendInfo* UDPSendInfo, int port);
void sendOK(_UDPSendInfo* UDPSendInfo, int port);
void sendNG(_UDPSendInfo* UDPSendInfo, int port);
void sendTotal(_UDPSendInfo* UDPSendInfo, int port);
void sendFile(QString FilePath, int port);
public:
SyncQueue<_UDPSendInfo> *Local_UDP_Info_queue;
std::atomic_bool isLoop = { 0 };
QUdpSocket mSocket;
SyncQueue<_UDPSendInfo>* Local_UDP_Info_queue;
std::atomic_bool isLoop = { 0 };
QUdpSocket mSocket;
};

5
Cigarette/threadSendTCP.cpp
Unescape Escape View File

@ -6,7 +6,6 @@
#pragma comment(lib, "ws2_32.lib")
void threadSendTCP::init(SyncQueue<_TCPSendInfo>* p_TCP_Info_queue, std::string ip_, int port_) {
ip = QString::fromStdString(ip_);
port = port_;
qDebug() << "tcp ip:" << ip << "| tcp port:" << port;
@ -27,9 +26,9 @@ void threadSendTCP::stop()
bool threadSendTCP::connectTCP() {
mySocket = new QTcpSocket();
// 取消已有的连接
// 取消已有的连接
mySocket->abort();
// 连接服务器
// 连接服务器
mySocket->connectToHost(ip, port);
if (!mySocket->waitForConnected(30000)) {
qDebug() << "connect failed!";

62
Cigarette/threadSendTCP.h
Unescape Escape View File

@ -10,46 +10,46 @@
class _TCPSendInfo
{
public:
std::string pics_name;
std::string pics_name;
_TCPSendInfo()
{
pics_name = "";
}
_TCPSendInfo()
{
pics_name = "";
}
};
class threadSendTCP : public QThread {
public:
QString ip;
int port;
int num = 0;
threadSendTCP(QObject* o = nullptr) :QThread(o)
{
isLoop = true;
}
~threadSendTCP()
{
stop();
_TCPSendInfo TCPSendInfo;
Local_TCP_Info_queue->put(TCPSendInfo);
quit();
wait();
}
void stop();
bool connectTCP();
QString ip;
int port;
int num = 0;
threadSendTCP(QObject* o = nullptr) :QThread(o)
{
isLoop = true;
}
~threadSendTCP()
{
stop();
_TCPSendInfo TCPSendInfo;
Local_TCP_Info_queue->put(TCPSendInfo);
quit();
wait();
}
void stop();
bool connectTCP();
protected:
void run();
void run();
public:
void init(SyncQueue<_TCPSendInfo>* p_TCP_Info_queue, std::string ip_, int port_);
void start_work();
void sendData(_TCPSendInfo* TCPSendInfo, int Num);
void init(SyncQueue<_TCPSendInfo>* p_TCP_Info_queue, std::string ip_, int port_);
void start_work();
void sendData(_TCPSendInfo* TCPSendInfo, int Num);
public:
SyncQueue<_TCPSendInfo>* Local_TCP_Info_queue;
std::atomic_bool isLoop = { 0 };
QTcpSocket *mySocket;
SyncQueue<_TCPSendInfo>* Local_TCP_Info_queue;
std::atomic_bool isLoop = { 0 };
QTcpSocket* mySocket;
};

4598
Cigarette/tinyxml2.cpp
View File

File diff suppressed because it is too large Load Diff

4044
Cigarette/tinyxml2.h
View File

File diff suppressed because it is too large Load Diff

464
Cigarette/workthread.cpp
Unescape Escape View File

@ -8,16 +8,16 @@
#include "exportData.h"
#include <QMap>
extern AlgJd alg_jd[NumberOfSupportedCameras]; //检测胶点的AI算法
extern AlgJd alg_jd[NumberOfSupportedCameras]; //检测胶点的AI算法
extern ConfPath g_conf_path;
extern SysConf g_sys_conf; //系统配置参数
extern SysConf g_sys_conf; //系统配置参数
extern DisplayLabelConf g_display_label_conf[NumberOfSupportedCameras];
extern int rotationAngle[NumberOfSupportedCameras]; //图片旋转角度
extern int rotationAngle[NumberOfSupportedCameras]; //图片旋转角度
extern bool isNeedRotate[NumberOfSupportedCameras];
extern SyncQueue<std::pair<std::string, cv::Mat> >* g_save_queue; //图片保存队列
extern SyncQueue<std::pair<int, cv::Mat>>* g_image_queue[NumberOfSupportedCameras]; //int表示一个目标拍了几张
extern SyncQueue<std::pair<std::string, cv::Mat> >* g_save_queue; //图片保存队列
extern SyncQueue<std::pair<int, cv::Mat>>* g_image_queue[NumberOfSupportedCameras]; //int表示一个目标拍了几张
#ifdef __UDPSend
extern SyncQueue<_UDPSendInfo>* UDP_Info_queue;
#endif
@ -32,292 +32,294 @@ extern bool g_debug_mode;
WorkThread::~WorkThread()
{
stop();
local_g_image_queue->put(std::make_pair(0, cv::Mat()));
quit();
wait();
stop();
local_g_image_queue->put(std::make_pair(0, cv::Mat()));
quit();
wait();
}
void WorkThread::init(SyncQueue<std::pair<int, cv::Mat>>* image_ptr, ASyncQueue<bool>* result_ptr, int classid, int Num)
{
local_camera_number = Num;
local_classid = classid;
local_g_image_queue = image_ptr;
local_g_result_queue = result_ptr;
b_quit = false;
frame_total = 0;
local_camera_number = Num;
local_classid = classid;
local_g_image_queue = image_ptr;
local_g_result_queue = result_ptr;
b_quit = false;
frame_total = 0;
}
void WorkThread::start_work()
{
start(HighestPriority);
start(HighestPriority);
}
void WorkThread::stop()
{
b_quit = true;
b_quit = true;
}
void WorkThread::run()
{
try{
uint32_t result_index = 0;
while (!b_quit) {
{//不要删掉这个括号，用来定义锁的作用域
std::lock_guard<std::mutex> locker(g_sys_conf.lock);
local_SysConf.save = g_sys_conf.save;
local_SysConf.shoot[local_camera_number] = g_sys_conf.shoot[local_camera_number];
local_SysConf.MisMatchAct = g_sys_conf.MisMatchAct;
local_SysConf.ConfThreshold = g_sys_conf.ConfThreshold;//
for (int i = 0; i < 3; i++)local_SysConf.no[local_camera_number][i] = g_sys_conf.no[local_camera_number][i];
try {
uint32_t result_index = 0;
while (!b_quit) {
{//不要删掉这个括号，用来定义锁的作用域
std::lock_guard<std::mutex> locker(g_sys_conf.lock);
local_SysConf.save = g_sys_conf.save;
local_SysConf.shoot[local_camera_number] = g_sys_conf.shoot[local_camera_number];
local_SysConf.MisMatchAct = g_sys_conf.MisMatchAct;
local_SysConf.ConfThreshold = g_sys_conf.ConfThreshold;//
for (int i = 0; i < 3; i++)local_SysConf.no[local_camera_number][i] = g_sys_conf.no[local_camera_number][i];
#ifdef DRAW_RECT
std::lock_guard<std::mutex> locker2(g_display_label_conf[local_camera_number].lock);
local_DisplayLabelConf.leftButtonDownFlag = g_display_label_conf[local_camera_number].leftButtonDownFlag;
local_DisplayLabelConf.Flag[0] = g_display_label_conf[local_camera_number].Flag[0];
local_DisplayLabelConf.Flag[1] = g_display_label_conf[local_camera_number].Flag[1];
local_DisplayLabelConf.originalPoint = g_display_label_conf[local_camera_number].originalPoint;
local_DisplayLabelConf.processPoint = g_display_label_conf[local_camera_number].processPoint;
local_DisplayLabelConf.RectVet[0] = g_display_label_conf[local_camera_number].RectVet[0];
local_DisplayLabelConf.RectVet[1] = g_display_label_conf[local_camera_number].RectVet[1];
std::lock_guard<std::mutex> locker2(g_display_label_conf[local_camera_number].lock);
local_DisplayLabelConf.leftButtonDownFlag = g_display_label_conf[local_camera_number].leftButtonDownFlag;
local_DisplayLabelConf.Flag[0] = g_display_label_conf[local_camera_number].Flag[0];
local_DisplayLabelConf.Flag[1] = g_display_label_conf[local_camera_number].Flag[1];
local_DisplayLabelConf.originalPoint = g_display_label_conf[local_camera_number].originalPoint;
local_DisplayLabelConf.processPoint = g_display_label_conf[local_camera_number].processPoint;
local_DisplayLabelConf.RectVet[0] = g_display_label_conf[local_camera_number].RectVet[0];
local_DisplayLabelConf.RectVet[1] = g_display_label_conf[local_camera_number].RectVet[1];
#endif
}
}
QDateTime now_ts = QDateTime::currentDateTime();
std::pair<int, cv::Mat> element;
local_g_image_queue->take(element);
int unit_count = element.first;
cv::Mat image = element.second;
QDateTime now_ts = QDateTime::currentDateTime();
std::pair<int, cv::Mat> element;
local_g_image_queue->take(element);
int unit_count = element.first;
cv::Mat image = element.second;
#ifdef __UDPSend
_UDPSendInfo UDPSendInfo;
UDPSendInfo.FrameID = info_frame;
UDPSendInfo.index = local_camera_number;
_UDPSendInfo UDPSendInfo;
UDPSendInfo.FrameID = info_frame;
UDPSendInfo.index = local_camera_number;
#endif
#ifdef __TCPSend
_TCPSendInfo TCPSendInfo;
_TCPSendInfo TCPSendInfo;
#endif
if (!image.data)
{
continue; //图像为空，跳过
}
if (image.channels() == 1)
{
cv::cvtColor(image, image, CV_BGR2RGB); //灰度图像转为彩色图像
}
if (local_SysConf.shoot[local_camera_number] == unit_count)
{
std::vector<cv::Mat> vec_in;
int w = image.cols;
int h = image.rows / unit_count;
for (int index = 0; index < unit_count; index++) {
cv::Rect temp_Rect(0, h * index, w, h);
cv::Mat temp_image = image(temp_Rect).clone();
if (isNeedRotate[local_camera_number]) {
if (rotationAngle[local_camera_number] != (cv::ROTATE_90_COUNTERCLOCKWISE + 1))
{
cv::rotate(temp_image, temp_image, rotationAngle[local_camera_number]);
}
}
vec_in.push_back(temp_image.clone());
}
if (!image.data)
{
continue; //图像为空，跳过
}
if (image.channels() == 1)
{
cv::cvtColor(image, image, CV_BGR2RGB); //灰度图像转为彩色图像
}
if (local_SysConf.shoot[local_camera_number] == unit_count)
{
std::vector<cv::Mat> vec_in;
int w = image.cols;
int h = image.rows / unit_count;
for (int index = 0; index < unit_count; index++) {
cv::Rect temp_Rect(0, h * index, w, h);
cv::Mat temp_image = image(temp_Rect).clone();
if (isNeedRotate[local_camera_number]) {
if (rotationAngle[local_camera_number] != (cv::ROTATE_90_COUNTERCLOCKWISE + 1))
{
cv::rotate(temp_image, temp_image, rotationAngle[local_camera_number]);
}
}
vec_in.push_back(temp_image.clone());
}
std::vector<cv::Mat> vec_out;
std::vector<std::vector<std::pair<int, cv::Rect> > > vec_results;
QDateTime ts_start = QDateTime::currentDateTime();
if(unit_count == 1){
std::vector<std::pair<int, cv::Rect> > results;
cv::Mat imagein,imageout;
imagein = vec_in[0];
alg_jd[local_camera_number].detect(imagein, imageout, results);
vec_out.push_back(imageout.clone());
vec_results.push_back(results);
}else{
alg_jd[local_camera_number].detect_batch(vec_in, vec_out, vec_results);
}
QDateTime ts_jd = QDateTime::currentDateTime();
int time_process = ts_start.msecsTo(ts_jd);
std::vector<cv::Mat> vec_out;
std::vector<std::vector<std::pair<int, cv::Rect> > > vec_results;
QDateTime ts_start = QDateTime::currentDateTime();
if (unit_count == 1) {
std::vector<std::pair<int, cv::Rect> > results;
cv::Mat imagein, imageout;
imagein = vec_in[0];
alg_jd[local_camera_number].detect(imagein, imageout, results);
vec_out.push_back(imageout.clone());
vec_results.push_back(results);
}
else {
alg_jd[local_camera_number].detect_batch(vec_in, vec_out, vec_results);
}
QDateTime ts_jd = QDateTime::currentDateTime();
int time_process = ts_start.msecsTo(ts_jd);
#ifndef SYNC_CAMERA
emit display_timecost(local_camera_number, time_process);
emit display_timecost(local_camera_number, time_process);
#endif
#ifdef __UDPSend
UDPSendInfo.timecost = QString::number(time_process);
UDPSendInfo.timecost = QString::number(time_process);
#endif
cv::Mat image1;
cv::Mat image2;
cv::Mat image1;
cv::Mat image2;
QString jd_no;
for (int index = 0; index < unit_count; index++) {
jd_no += QString::number(vec_results[index].size()) + ",";
}
jd_no.chop(1);
QString jd_no;
for (int index = 0; index < unit_count; index++) {
jd_no += QString::number(vec_results[index].size()) + ",";
}
jd_no.chop(1);
#ifndef SYNC_CAMERA
emit display_jd_no(local_camera_number, jd_no);
emit display_jd_no(local_camera_number, jd_no);
#endif
#ifdef __UDPSend
UDPSendInfo.JD = jd_no;
UDPSendInfo.JD = jd_no;
#endif
bool IsNG = false;
int ngReason = 0;
QMap<int, QString> ng_reason_maps;
ng_reason_maps[0] = "unknow";
ng_reason_maps[1] = "less_than_setting";
ng_reason_maps[2] = "too_diff_from_model";
ng_reason_maps[3] = "out_of_setting_range";
for(int index=0;index<unit_count;index++)
{
if(vec_results[index].size() < local_SysConf.no[local_camera_number][index])
{
IsNG |= true;
ngReason = 1;
}
//if (vec_results[index].size() != 1)IsNG |= true;//反向训练
if (local_SysConf.ConfThreshold == 0)
{
IsNG = false;
ngReason = 0;
}
if (local_SysConf.save == 2)//三张照片分别存储
{
cv::Mat m = vec_in[index].clone();
QString file_name = g_conf_path.save_pics_path + "/ALL/" +
now_ts.toString("yyyy-MM-dd") + "/"
+ QString::number(local_camera_number + 1) + "/" + QString::number(index + 1) + "/" +
now_ts.toString("yyyy-MM-dd_HH-mm-ss_zzz_") + QString::number(local_camera_number + 1) +
"#" + "_" + QString::number(index + 1) + ".jpg";
std::string filename = file_name.toLocal8Bit().constData();
g_save_queue->put(std::make_pair(filename, m));
bool IsNG = false;
int ngReason = 0;
QMap<int, QString> ng_reason_maps;
ng_reason_maps[0] = "unknow";
ng_reason_maps[1] = "less_than_setting";
ng_reason_maps[2] = "too_diff_from_model";
ng_reason_maps[3] = "out_of_setting_range";
for (int index = 0; index < unit_count; index++)
{
if (vec_results[index].size() < local_SysConf.no[local_camera_number][index])
{
IsNG |= true;
ngReason = 1;
}
//if (vec_results[index].size() != 1)IsNG |= true;//反向训练
if (local_SysConf.ConfThreshold == 0)
{
IsNG = false;
ngReason = 0;
}
if (local_SysConf.save == 2)//三张照片分别存储
{
cv::Mat m = vec_in[index].clone();
QString file_name = g_conf_path.save_pics_path + "/ALL/" +
now_ts.toString("yyyy-MM-dd") + "/"
+ QString::number(local_camera_number + 1) + "/" + QString::number(index + 1) + "/" +
now_ts.toString("yyyy-MM-dd_HH-mm-ss_zzz_") + QString::number(local_camera_number + 1) +
"#" + "_" + QString::number(index + 1) + ".jpg";
std::string filename = file_name.toLocal8Bit().constData();
g_save_queue->put(std::make_pair(filename, m));
QString sendName = now_ts.toString("yyyy-MM-dd_HH-mm-ss_zzz_") + QString::number(local_camera_number + 1) +
"#" + "_" + QString::number(index + 1) + ".jpg";
QString sendName = now_ts.toString("yyyy-MM-dd_HH-mm-ss_zzz_") + QString::number(local_camera_number + 1) +
"#" + "_" + QString::number(index + 1) + ".jpg";
#ifdef __TCPSend
TCPSendInfo.pics_name = sendName.toLocal8Bit().constData();
TCP_Info_queue->put(TCPSendInfo);
TCPSendInfo.pics_name = sendName.toLocal8Bit().constData();
TCP_Info_queue->put(TCPSendInfo);
#endif
}
}
}
}
if (unit_count >= 2){
image1 = vec_out[(result_index) % 2].clone();
if (unit_count >= 2) {
image1 = vec_out[(result_index) % 2].clone();
#ifdef DRAW_RECT
IsNG|=CheckSelectRects(image1,vec_results,(result_index) % 2,local_DisplayLabelConf,0);
if (IsNG) {
ngReason = 2;
}
IsNG |= CheckSelectRects(image1, vec_results, (result_index) % 2, local_DisplayLabelConf, 0);
if (IsNG) {
ngReason = 2;
}
#endif
}else {
image1 = vec_out[0].clone();
}
else {
image1 = vec_out[0].clone();
#ifdef DRAW_RECT
IsNG|=CheckSelectRects(image1,vec_results,0,local_DisplayLabelConf,0);
if (IsNG) {
ngReason = 2;
}
IsNG |= CheckSelectRects(image1, vec_results, 0, local_DisplayLabelConf, 0);
if (IsNG) {
ngReason = 2;
}
#endif
}
}
#ifdef DRAW_RECT
DrawSelectRects(image1, local_DisplayLabelConf, 0);
DrawSelectRects(image1, local_DisplayLabelConf, 0);
#endif
if (unit_count >= 3) {
image2 = vec_out[2].clone();
if (unit_count >= 3) {
image2 = vec_out[2].clone();
#ifdef DRAW_RECT
DrawSelectRects(image2, local_DisplayLabelConf, 1);
IsNG|=CheckSelectRects(image1,vec_results,2,local_DisplayLabelConf,1);
if (IsNG) {
ngReason = 3;
}
DrawSelectRects(image2, local_DisplayLabelConf, 1);
IsNG |= CheckSelectRects(image1, vec_results, 2, local_DisplayLabelConf, 1);
if (IsNG) {
ngReason = 3;
}
#endif
}
result_index++;
}
result_index++;
if (!IsNG)
{
if (!g_debug_mode)
{
if (!IsNG)
{
if (!g_debug_mode)
{
#ifndef SYNC_CAMERA
emit event_ok(local_camera_number);
emit event_ok(local_camera_number);
#endif
local_g_result_queue->put(true);
}
}
else
{
if (!g_debug_mode)
{
local_g_result_queue->put(true);
}
}
else
{
if (!g_debug_mode)
{
#ifndef SYNC_CAMERA
emit event_ng(local_camera_number);
emit event_ng(local_camera_number);
#endif
local_g_result_queue->put(false);
}
local_g_result_queue->put(false);
}
if ((local_SysConf.save == 2) || (local_SysConf.save == 1))
{
for(int index=0;index<unit_count;index++)
{
cv::Mat m = vec_in[index].clone();
QString file_name = g_conf_path.save_pics_path + "/ng/" +
now_ts.toString("yyyy-MM-dd") + "/"
+ QString::number(local_camera_number + 1) + "/" + QString::number(index + 1) + "/" +
now_ts.toString("yyyy-MM-dd_HH-mm-ss_zzz_") + QString::number(local_camera_number + 1) +
"#" + "_" + QString::number(index + 1) + "_" + ng_reason_maps[ngReason] +
".jpg";
QString remotePath = "/image/ng/" +
now_ts.toString("yyyy-MM-dd_HH-mm-ss_zzz_") + QString::number(local_camera_number + 1) +
"#" + "_" + QString::number(index + 1) + "_" + ng_reason_maps[ngReason] +
".jpg";
g_save_queue->put(std::make_pair(file_name.toLocal8Bit().constData(), m));
if ((local_SysConf.save == 2) || (local_SysConf.save == 1))
{
for (int index = 0; index < unit_count; index++)
{
cv::Mat m = vec_in[index].clone();
QString file_name = g_conf_path.save_pics_path + "/ng/" +
now_ts.toString("yyyy-MM-dd") + "/"
+ QString::number(local_camera_number + 1) + "/" + QString::number(index + 1) + "/" +
now_ts.toString("yyyy-MM-dd_HH-mm-ss_zzz_") + QString::number(local_camera_number + 1) +
"#" + "_" + QString::number(index + 1) + "_" + ng_reason_maps[ngReason] +
".jpg";
QString remotePath = "/image/ng/" +
now_ts.toString("yyyy-MM-dd_HH-mm-ss_zzz_") + QString::number(local_camera_number + 1) +
"#" + "_" + QString::number(index + 1) + "_" + ng_reason_maps[ngReason] +
".jpg";
g_save_queue->put(std::make_pair(file_name.toLocal8Bit().constData(), m));
m = vec_out[index].clone();
file_name = g_conf_path.save_pics_path + "/ng_result/" +
now_ts.toString("yyyy-MM-dd") + "/"
+ QString::number(local_camera_number + 1) + "/" + QString::number(index + 1) + "/" +
now_ts.toString("yyyy-MM-dd_HH-mm-ss_zzz_") + QString::number(local_camera_number + 1) +
"#" + "_" + QString::number(index + 1) + "_" + ng_reason_maps[ngReason] +
".jpg";
remotePath = "/image/ng_result/" +
now_ts.toString("yyyy-MM-dd_HH-mm-ss_zzz_") + QString::number(local_camera_number + 1) +
"#" + "_" + QString::number(index + 1) + "_" + ng_reason_maps[ngReason] +
".jpg";
//g_save_queue->put(std::make_pair(file_name.toStdString(), m));
g_save_queue->put(std::make_pair(file_name.toLocal8Bit().constData(), m));
}
}
}
m = vec_out[index].clone();
file_name = g_conf_path.save_pics_path + "/ng_result/" +
now_ts.toString("yyyy-MM-dd") + "/"
+ QString::number(local_camera_number + 1) + "/" + QString::number(index + 1) + "/" +
now_ts.toString("yyyy-MM-dd_HH-mm-ss_zzz_") + QString::number(local_camera_number + 1) +
"#" + "_" + QString::number(index + 1) + "_" + ng_reason_maps[ngReason] +
".jpg";
remotePath = "/image/ng_result/" +
now_ts.toString("yyyy-MM-dd_HH-mm-ss_zzz_") + QString::number(local_camera_number + 1) +
"#" + "_" + QString::number(index + 1) + "_" + ng_reason_maps[ngReason] +
".jpg";
//g_save_queue->put(std::make_pair(file_name.toStdString(), m));
g_save_queue->put(std::make_pair(file_name.toLocal8Bit().constData(), m));
}
}
}
#ifndef SYNC_CAMERA
if (!g_debug_mode)
{
emit display_check_total(local_camera_number, ++frame_total);
//exportDataInfo.cameraTotal = frame_total;
if (!g_debug_mode)
{
emit display_check_total(local_camera_number, ++frame_total);
//exportDataInfo.cameraTotal = frame_total;
emit notify(local_camera_number, 0, image1);
if (unit_count >= 3)
emit notify(local_camera_number, 1, image2);
}
emit notify(local_camera_number, 0, image1);
if (unit_count >= 3)
emit notify(local_camera_number, 1, image2);
}
#endif
}
}
#ifndef SYNC_CAMERA
else
{
//保证不错位
if (!g_debug_mode)
{
if (local_SysConf.MisMatchAct == 1)//as ng
emit event_ng(local_camera_number);
else if (local_SysConf.MisMatchAct == 0)//as ok
emit event_ok(local_camera_number);
emit display_check_total(local_camera_number, ++frame_total);
qDebug() << local_camera_number << "#camera# " << now_ts.toString("yyyy-MM-dd_HH-mm-ss_zzz_") << "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx " << unit_count;
}
}
else
{
//保证不错位
if (!g_debug_mode)
{
if (local_SysConf.MisMatchAct == 1)//as ng
emit event_ng(local_camera_number);
else if (local_SysConf.MisMatchAct == 0)//as ok
emit event_ok(local_camera_number);
emit display_check_total(local_camera_number, ++frame_total);
qDebug() << local_camera_number << "#camera# " << now_ts.toString("yyyy-MM-dd_HH-mm-ss_zzz_") << "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx " << unit_count;
}
}
#endif
#ifdef __UDPSend
UDP_Info_queue->put(UDPSendInfo);
UDP_Info_queue->put(UDPSendInfo);
#endif
}
}
catch (cv::Exception& e)
{
const char* err_msg = e.what();
std::cout << "exception caught: " << err_msg << std::endl;
}
}
}
catch (cv::Exception& e)
{
const char* err_msg = e.what();
std::cout << "exception caught: " << err_msg << std::endl;
}
}

44
Cigarette/workthread.h
Unescape Escape View File

@ -13,34 +13,34 @@ class WorkThread : public QThread
Q_OBJECT
#ifndef SYNC_CAMERA
signals:
void notify(int Num,int Cnt,cv::Mat);
void display_timecost(int Num,int ms);
void display_check_total(int Num,long no);
void display_jd_no(int Num,QString jd_no);
void notify(int Num, int Cnt, cv::Mat);
void display_timecost(int Num, int ms);
void display_check_total(int Num, long no);
void display_jd_no(int Num, QString jd_no);
void event_ok(int Num);
void event_ng(int Num);
void event_ok(int Num);
void event_ng(int Num);
#endif
public:
WorkThread(QObject *parent = 0): QThread(parent)
{
WorkThread(QObject* parent = 0) : QThread(parent)
{
}
~WorkThread();
}
~WorkThread();
void init(SyncQueue<std::pair<int, cv::Mat>>* image_ptr,ASyncQueue<bool> *result_ptr, int classid, int Num);
void start_work();
void stop();
void init(SyncQueue<std::pair<int, cv::Mat>>* image_ptr, ASyncQueue<bool>* result_ptr, int classid, int Num);
void start_work();
void stop();
protected:
void run();
void run();
public:
int local_camera_number;
int local_classid;
SyncQueue<std::pair<int, cv::Mat>>* local_g_image_queue;
ASyncQueue<bool>* local_g_result_queue;
bool b_quit;
long frame_total;
SysConf local_SysConf;
DisplayLabelConf local_DisplayLabelConf;
int local_camera_number;
int local_classid;
SyncQueue<std::pair<int, cv::Mat>>* local_g_image_queue;
ASyncQueue<bool>* local_g_result_queue;
bool b_quit;
long frame_total;
SysConf local_SysConf;
DisplayLabelConf local_DisplayLabelConf;
};

Write Preview
Loading…
Cancel
Save