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

3
Cigarette/AlarmInfo.cpp
Unescape Escape View File

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

13
Cigarette/AlarmInfo.h
Unescape Escape View File

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

200
Cigarette/CaptureThread.cpp
Unescape Escape View File

@ -2,162 +2,162 @@
#include "common.h" #include "common.h"
#include "exportData.h" #include "exportData.h"
extern bool g_debug_mode; //相机调试模式，工作模式必须停止状态才能打开 extern bool g_debug_mode; //相机调试模式，工作模式必须停止状态才能打开
extern SyncQueue<_XMLExportDataInfo>* export_XMLData_Info_queue; extern SyncQueue<_XMLExportDataInfo>* export_XMLData_Info_queue;
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
CaptureThread::CaptureThread( Device* pCurrDev, bool boTerminated, FunctionInterface* pFI_ ,int Num) : CaptureThread::CaptureThread(Device* pCurrDev, bool boTerminated, FunctionInterface* pFI_, int Num) :
pDev_( pCurrDev ), boTerminated_( boTerminated ), requestPendingForDisplay_( INVALID_ID ), pFI_( pFI_ ),Local_Num(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) void CaptureThread::fpsTimeout(void)
{ {
uint64_t delta = m_cntGrabbedImages - m_cntLastGrabbedImages; uint64_t delta = m_cntGrabbedImages - m_cntLastGrabbedImages;
m_cntLastGrabbedImages = m_cntGrabbedImages; m_cntLastGrabbedImages = m_cntGrabbedImages;
QString data = QString("%1").arg(delta); QString data = QString("%1").arg(delta);
emit updateStatistics(data.left(4), Local_Num); emit updateStatistics(data.left(4), Local_Num);
} }
CaptureThread::~CaptureThread() CaptureThread::~CaptureThread()
{ {
delete p_unit_queue; delete p_unit_queue;
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void CaptureThread::process( void ) void CaptureThread::process(void)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
{ {
try try
{ {
//Line5回调 //Line5回调
mvIMPACT::acquire::GenICam::EventControl pEventCtrl_(pDev_); mvIMPACT::acquire::GenICam::EventControl pEventCtrl_(pDev_);
//pEventCtrl_.eventSelector.writeS("Line5FallingEdge"); //pEventCtrl_.eventSelector.writeS("Line5FallingEdge");
//pEventCtrl_.eventNotification.writeS("Off"); //pEventCtrl_.eventNotification.writeS("Off");
//pEventCtrl_.eventSelector.writeS("Line5RisingEdge"); //pEventCtrl_.eventSelector.writeS("Line5RisingEdge");
//pEventCtrl_.eventNotification.writeS("Off"); //pEventCtrl_.eventNotification.writeS("Off");
pEventCtrl_.eventSelector.writeS("Line5AnyEdge"); pEventCtrl_.eventSelector.writeS("Line5AnyEdge");
#ifdef IMM_PROCESS #ifdef IMM_PROCESS
pEventCtrl_.eventNotification.writeS("Off"); pEventCtrl_.eventNotification.writeS("Off");
#else #else
pEventCtrl_.eventNotification.writeS("On"); pEventCtrl_.eventNotification.writeS("On");
#endif #endif
#ifndef IMM_PROCESS #ifndef IMM_PROCESS
EventCallback eventCallback(&pEventCtrl_); EventCallback eventCallback(&pEventCtrl_);
eventCallback.p_unit_queue_ = p_unit_queue; eventCallback.p_unit_queue_ = p_unit_queue;
#ifdef SYNC_CAMERA #ifdef SYNC_CAMERA
eventCallback.p_image_sync_arr_ = p_image_sync_arr; eventCallback.p_image_sync_arr_ = p_image_sync_arr;
eventCallback.p_image_sync_queue_ = p_image_sync_queue; eventCallback.p_image_sync_queue_ = p_image_sync_queue;
#else #else
eventCallback.p_image_queue_ = p_image_queue; eventCallback.p_image_queue_ = p_image_queue;
#endif #endif
eventCallback.p_result_wait_queue_ = p_result_wait_queue; eventCallback.p_result_wait_queue_ = p_result_wait_queue;
eventCallback.p_shooted_queue_ = p_shooted_queue; eventCallback.p_shooted_queue_ = p_shooted_queue;
eventCallback.p_double_queue_ = p_double_queue; eventCallback.p_double_queue_ = p_double_queue;
eventCallback.m_pMVCamera = pDev_; eventCallback.m_pMVCamera = pDev_;
eventCallback.pCaptureThread = this; eventCallback.pCaptureThread = this;
eventCallback.registerComponent(pEventCtrl_.eventLine5AnyEdge); eventCallback.registerComponent(pEventCtrl_.eventLine5AnyEdge);
#endif #endif
m_threadFunc.m_pMVCamera = pDev_; m_threadFunc.m_pMVCamera = pDev_;
m_threadFunc.p_result_queue_ = p_result_queue; m_threadFunc.p_result_queue_ = p_result_queue;
m_threadFunc.p_double_queue_ = p_double_queue; m_threadFunc.p_double_queue_ = p_double_queue;
//相机掉线回调 //相机掉线回调
CIwtCameraLostCallbackMV cam_lost_cb; CIwtCameraLostCallbackMV cam_lost_cb;
cam_lost_cb.channel_ = Local_Num; cam_lost_cb.channel_ = Local_Num;
if (cam_lost_cb.registerComponent(pDev_->state) != true) if (cam_lost_cb.registerComponent(pDev_->state) != true)
{ {
std::cout << "ERROR: Unable to register the camera's lost CallBack function!\n"; std::cout << "ERROR: Unable to register the camera's lost CallBack function!\n";
} }
//图像采集循环 //图像采集循环
TDMR_ERROR result = DMR_NO_ERROR; TDMR_ERROR result = DMR_NO_ERROR;
while( ( result = static_cast< TDMR_ERROR >( pFI_->imageRequestSingle() ) ) == DMR_NO_ERROR ) {}; while ((result = static_cast<TDMR_ERROR>(pFI_->imageRequestSingle())) == DMR_NO_ERROR) {};
if( result != DEV_NO_FREE_REQUEST_AVAILABLE ) 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; int cnt = 0;
// run thread loop // run thread loop
mvIMPACT::acquire::Statistics statistics( pDev_ ); mvIMPACT::acquire::Statistics statistics(pDev_);
mvIMPACT::acquire::Request* pRequest = 0; mvIMPACT::acquire::Request* pRequest = 0;
mvIMPACT::acquire::Request* pPreviousRequest = nullptr; mvIMPACT::acquire::Request* pPreviousRequest = nullptr;
const unsigned int timeout_ms = 100; const unsigned int timeout_ms = 100;
Ready = true; Ready = true;
while( !boTerminated_ ) while (!boTerminated_)
{ {
const int requestNr = pFI_->imageRequestWaitFor( timeout_ms ); const int requestNr = pFI_->imageRequestWaitFor(timeout_ms);
pRequest = pFI_->isRequestNrValid( requestNr ) ? pFI_->getRequest( requestNr ) : 0; pRequest = pFI_->isRequestNrValid(requestNr) ? pFI_->getRequest(requestNr) : 0;
if( pRequest ) if (pRequest)
{ {
if (pRequest->isOK()) if (pRequest->isOK())
{ {
// do something with the image // do something with the image
int openCVDataType = CV_8UC1; int openCVDataType = CV_8UC1;
if ((pRequest->imagePixelFormat.read() == ibpfBGR888Packed) || (pRequest->imagePixelFormat.read() == ibpfRGB888Packed)) if ((pRequest->imagePixelFormat.read() == ibpfBGR888Packed) || (pRequest->imagePixelFormat.read() == ibpfRGB888Packed))
openCVDataType = CV_8UC3; openCVDataType = CV_8UC3;
cv::Mat openCVImage(cv::Size(pRequest->imageWidth.read(), pRequest->imageHeight.read()), openCVDataType, pRequest->imageData.read(), pRequest->imageLinePitch.read()); cv::Mat openCVImage(cv::Size(pRequest->imageWidth.read(), pRequest->imageHeight.read()), openCVDataType, pRequest->imageData.read(), pRequest->imageLinePitch.read());
cv::Mat image_clone = openCVImage.clone(); cv::Mat image_clone = openCVImage.clone();
if (!g_debug_mode) if (!g_debug_mode)
{ {
#ifdef IMM_PROCESS #ifdef IMM_PROCESS
p_image_queue->put(std::make_pair(1,image_clone)); //放入临时队列 p_image_queue->put(std::make_pair(1, image_clone)); //放入临时队列
#else #else
p_unit_queue->put(image_clone); //放入临时队列 p_unit_queue->put(image_clone); //放入临时队列
#endif #endif
} }
else else
{ {
p_debug_queue->put(image_clone); //放入调试队列 p_debug_queue->put(image_clone); //放入调试队列
} }
cnt++; cnt++;
// display some statistics // display some statistics
if (cnt % 10 == 0) if (cnt % 10 == 0)
{ {
QString data = QString::fromStdString(statistics.framesPerSecond.readS()); QString data = QString::fromStdString(statistics.framesPerSecond.readS());
emit updateStatistics(data.left(4),Local_Num); emit updateStatistics(data.left(4), Local_Num);
} }
} }
else else
{ {
// some error: pRequest->requestResult.readS() will return a string representation // some error: pRequest->requestResult.readS() will return a string representation
} }
// this image has been used thus the buffer is no longer needed... // this image has been used thus the buffer is no longer needed...
if (pPreviousRequest) if (pPreviousRequest)
{ {
// this image has been displayed thus the buffer is no longer needed... // this image has been displayed thus the buffer is no longer needed...
pPreviousRequest->unlock(); pPreviousRequest->unlock();
} }
pPreviousRequest = pRequest; pPreviousRequest = pRequest;
// send a new image request into the capture queue // send a new image request into the capture queue
pFI_->imageRequestSingle(); pFI_->imageRequestSingle();
} }
#if defined (IMM_FEED_BACK) || defined (CAP_FEED_BACK) #if defined (IMM_FEED_BACK) || defined (CAP_FEED_BACK)
m_threadFunc.SendFeedBack(ImageCap); m_threadFunc.SendFeedBack(ImageCap);
#endif #endif
} }
manuallyStopAcquisitionIfNeeded( pDev_, *pFI_ ); manuallyStopAcquisitionIfNeeded(pDev_, *pFI_);
if( pRequest ) if (pRequest)
{ {
pRequest->unlock(); 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_; int result = requestPendingForDisplay_;
// Reset the ID of the request to tell the capture loop that this request has already been // 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. // 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: public:
Device* m_pMVCamera; Device* m_pMVCamera;
ASyncQueue<bool> *p_result_queue_; ASyncQueue<bool>* p_result_queue_;
ASyncQueue<bool> *p_double_queue_; ASyncQueue<bool>* p_double_queue_;
void SendFeedBack(int OpID) void SendFeedBack(int OpID)
{ {
bool send_ng=false; bool send_ng = false;
bool send_ok=false; bool send_ok = false;
if(OpID == EdgeEvent) if (OpID == EdgeEvent)
{ {
#if defined DOUBLE_FEED_BACK #if defined DOUBLE_FEED_BACK
if(p_double_queue_->count() > 0) if (p_double_queue_->count() > 0)
{ {
bool temp; bool temp;
p_double_queue_->take(temp); p_double_queue_->take(temp);
send_ng=true; send_ng = true;
} }
#endif #endif
} }
@ -47,88 +47,88 @@ public:
bool result; bool result;
p_result_queue_->take(result); p_result_queue_->take(result);
if (!result) if (!result)
{ {
#if defined DOUBLE_FEED_BACK #if defined DOUBLE_FEED_BACK
p_double_queue_->put(true); p_double_queue_->put(true);
#endif #endif
send_ng=true; send_ng = true;
}
else
{
send_ok = true;
} }
else
{
send_ok=true;
}
} }
try try
{ {
mvIMPACT::acquire::GenICam::DigitalIOControl mvDIOC(m_pMVCamera); mvIMPACT::acquire::GenICam::DigitalIOControl mvDIOC(m_pMVCamera);
if(send_ng){ if (send_ng) {
mvDIOC.userOutputSelector.writeS("UserOutput0"); mvDIOC.userOutputSelector.writeS("UserOutput0");
mvIMPACT::acquire::TBoolean tb = mvDIOC.userOutputValue.read(); mvIMPACT::acquire::TBoolean tb = mvDIOC.userOutputValue.read();
if (tb == bFalse) if (tb == bFalse)
mvDIOC.userOutputValue.write(bTrue); mvDIOC.userOutputValue.write(bTrue);
else else
mvDIOC.userOutputValue.write(bFalse); mvDIOC.userOutputValue.write(bFalse);
} }
else if (send_ok) else if (send_ok)
{ {
mvDIOC.userOutputSelector.writeS("UserOutput1"); mvDIOC.userOutputSelector.writeS("UserOutput1");
mvIMPACT::acquire::TBoolean tb = mvDIOC.userOutputValue.read(); mvIMPACT::acquire::TBoolean tb = mvDIOC.userOutputValue.read();
if (tb == bFalse) if (tb == bFalse)
mvDIOC.userOutputValue.write(bTrue); mvDIOC.userOutputValue.write(bTrue);
else else
mvDIOC.userOutputValue.write(bFalse); mvDIOC.userOutputValue.write(bFalse);
} }
} }
catch (const ImpactAcquireException& e) catch (const ImpactAcquireException& e)
{ {
std::cout<< "(error code: " << e.getErrorCodeAsString() << "). Press [ENTER] to end the application..." << std::endl; std::cout << "(error code: " << e.getErrorCodeAsString() << "). Press [ENTER] to end the application..." << std::endl;
} }
} }
}; };
class CaptureThread : public QObject class CaptureThread : public QObject
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
{ {
Q_OBJECT Q_OBJECT
public: public:
explicit CaptureThread( Device* pCurrDev, bool boTerminated, FunctionInterface* pFi ,int Num); explicit CaptureThread(Device* pCurrDev, bool boTerminated, FunctionInterface* pFi, int Num);
CaptureThread::~CaptureThread(void); CaptureThread::~CaptureThread(void);
void terminate( void ) void terminate(void)
{ {
boTerminated_ = true; boTerminated_ = true;
} }
int getPendingRequestNr(); int getPendingRequestNr();
signals: signals:
void error( QString err ); void error(QString err);
void finished( void ); void finished(void);
void requestReady( void ); void requestReady(void);
void updateStatistics( const QString& data ,int Num); void updateStatistics(const QString& data, int Num);
private slots: private slots:
void process( void ); void process(void);
void fpsTimeout(void); void fpsTimeout(void);
public: public:
int Local_Num; int Local_Num;
QTimer* m_Timer; QTimer* m_Timer;
uint64_t m_cntGrabbedImages = 0; uint64_t m_cntGrabbedImages = 0;
uint64_t m_cntLastGrabbedImages = 0; uint64_t m_cntLastGrabbedImages = 0;
#ifdef SYNC_CAMERA #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; SyncQueue<std::vector<std::pair<int, cv::Mat>>>* p_image_sync_queue;
#else #else
SyncQueue<std::pair<int, cv::Mat> > *p_image_queue; SyncQueue<std::pair<int, cv::Mat> >* p_image_queue;
#endif #endif
ASyncQueue<cv::Mat> *p_unit_queue; ASyncQueue<cv::Mat>* p_unit_queue;
ASyncQueue<bool> *p_result_queue; ASyncQueue<bool>* p_result_queue;
ASyncQueue<bool> *p_result_wait_queue; ASyncQueue<bool>* p_result_wait_queue;
ASyncQueue<bool> *p_double_queue; ASyncQueue<bool>* p_double_queue;
ASyncQueue<bool> *p_shooted_queue; ASyncQueue<bool>* p_shooted_queue;
SyncQueue<cv::Mat> *p_debug_queue; SyncQueue<cv::Mat>* p_debug_queue;
bool Ready = false; bool Ready = false;
CaptureThread_Func m_threadFunc; CaptureThread_Func m_threadFunc;
private: private:
Device* pDev_; Device* pDev_;
volatile bool boTerminated_; volatile bool boTerminated_;
@ -143,125 +143,125 @@ private:
class EventCallback : public mvIMPACT::acquire::ComponentCallback class EventCallback : public mvIMPACT::acquire::ComponentCallback
{ {
public: public:
ASyncQueue<cv::Mat> *p_unit_queue_; ASyncQueue<cv::Mat>* p_unit_queue_;
#ifdef SYNC_CAMERA #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_; SyncQueue<std::vector<std::pair<int, cv::Mat>>>* p_image_sync_queue_;
#else #else
SyncQueue<std::pair<int, cv::Mat> > *p_image_queue_; SyncQueue<std::pair<int, cv::Mat> >* p_image_queue_;
#endif #endif
ASyncQueue<bool> *p_result_wait_queue_; ASyncQueue<bool>* p_result_wait_queue_;
ASyncQueue<bool> *p_shooted_queue_; ASyncQueue<bool>* p_shooted_queue_;
ASyncQueue<bool> *p_double_queue_; ASyncQueue<bool>* p_double_queue_;
explicit EventCallback(void* pUserData = 0) : ComponentCallback(pUserData) {} explicit EventCallback(void* pUserData = 0) : ComponentCallback(pUserData) {}
Device* m_pMVCamera; Device* m_pMVCamera;
CaptureThread* pCaptureThread = NULL; CaptureThread* pCaptureThread = NULL;
int count = 0; int count = 0;
virtual void execute(Component& c, void* pUserData) virtual void execute(Component& c, void* pUserData)
{ {
try 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! // 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); mvIMPACT::acquire::GenICam::EventControl* ec = reinterpret_cast<mvIMPACT::acquire::GenICam::EventControl*>(pUserData);
// Execute the followings if the component is a property. // Execute the followings if the component is a property.
if (c.isProp()) if (c.isProp())
{ {
mvIMPACT::acquire::GenICam::DigitalIOControl mvDIOC(m_pMVCamera); mvIMPACT::acquire::GenICam::DigitalIOControl mvDIOC(m_pMVCamera);
mvDIOC.lineSelector.writeS("Line5"); mvDIOC.lineSelector.writeS("Line5");
if (mvDIOC.lineStatus.read()) if (mvDIOC.lineStatus.read())
{ {
#ifdef IMM_FEED_BACK #ifdef IMM_FEED_BACK
if (p_shooted_queue_->count() > 0) if (p_shooted_queue_->count() > 0)
{ {
bool temp; bool temp;
p_shooted_queue_->take(temp); p_shooted_queue_->take(temp);
} }
#elif defined ONE_TIME_SHIFT #elif defined ONE_TIME_SHIFT
if ( if (
p_shooted_queue_->count() > 0 p_shooted_queue_->count() > 0
#if defined DOUBLE_FEED_BACK #if defined DOUBLE_FEED_BACK
|| p_double_queue_->count() >0 || p_double_queue_->count() > 0
#endif #endif
) )
{ {
if (p_shooted_queue_->count() > 0){ if (p_shooted_queue_->count() > 0) {
bool temp; bool temp;
p_shooted_queue_->take(temp); p_shooted_queue_->take(temp);
} }
pCaptureThread->m_threadFunc.SendFeedBack(EdgeEvent); pCaptureThread->m_threadFunc.SendFeedBack(EdgeEvent);
} }
#else #else
if (p_result_wait_queue_->count() > 0) if (p_result_wait_queue_->count() > 0)
{ {
bool temp; bool temp;
p_result_wait_queue_->take(temp); p_result_wait_queue_->take(temp);
pCaptureThread->m_threadFunc.SendFeedBack(EdgeEvent); pCaptureThread->m_threadFunc.SendFeedBack(EdgeEvent);
} }
if (p_shooted_queue_->count() > 0) if (p_shooted_queue_->count() > 0)
{ {
bool temp; bool temp;
p_shooted_queue_->take(temp); p_shooted_queue_->take(temp);
p_result_wait_queue_->put(true); p_result_wait_queue_->put(true);
} }
#endif #endif
} }
else else
{ {
int unit_count = p_unit_queue_->count(); int unit_count = p_unit_queue_->count();
if (unit_count > 0) if (unit_count > 0)
{ {
cv::Mat long_image; cv::Mat long_image;
for (int i = 0; i < unit_count; i++) for (int i = 0; i < unit_count; i++)
{ {
cv::Mat image; cv::Mat image;
p_unit_queue_->take(image); p_unit_queue_->take(image);
if (0 == i) if (0 == i)
{ {
long_image = cv::Mat::zeros(image.rows * unit_count, image.cols, image.type()); 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::Rect r(0, i * image.rows, image.cols, image.rows);
cv::Mat roi = long_image(r); cv::Mat roi = long_image(r);
image.copyTo(roi); image.copyTo(roi);
} }
#ifdef SYNC_CAMERA #ifdef SYNC_CAMERA
{ {
std::lock_guard<std::mutex> locker(p_image_sync_arr_->lock); 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_->image_sync_arr.at(pCaptureThread->Local_Num) = std::make_pair(unit_count, long_image);
p_image_sync_arr_->collect_cnt++; p_image_sync_arr_->collect_cnt++;
if (p_image_sync_arr_->collect_cnt == work_camera_nums) 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_queue_->put(p_image_sync_arr_->image_sync_arr);
p_image_sync_arr_->collect_cnt = 0; p_image_sync_arr_->collect_cnt = 0;
} }
} }
#else #else
p_image_queue_->put(std::make_pair(unit_count, long_image)); p_image_queue_->put(std::make_pair(unit_count, long_image));
#endif #endif
p_shooted_queue_->put(true); p_shooted_queue_->put(true);
} }
p_unit_queue_->clear(); p_unit_queue_->clear();
} }
} }
} }
catch (const ImpactAcquireException& e) catch (const ImpactAcquireException& e)
{ {
qDebug() << "Error"; qDebug() << "Error";
} }
} }
}; };
class CIwtCameraLostCallbackMV : public mvIMPACT::acquire::ComponentCallback class CIwtCameraLostCallbackMV : public mvIMPACT::acquire::ComponentCallback
{ {
public: public:
CIwtCameraLostCallbackMV() : ComponentCallback() {} CIwtCameraLostCallbackMV() : ComponentCallback() {}
int channel_; int channel_;
virtual void execute(mvIMPACT::acquire::Component& c, void* pDummy) virtual void execute(mvIMPACT::acquire::Component& c, void* pDummy)
{ {
PropertyIDeviceState p(c); PropertyIDeviceState p(c);
std::cout << p.name() << " = " << p.readS() << endl; std::cout << p.name() << " = " << p.readS() << endl;
SingleCamInfo[channel_].OffLine = true; SingleCamInfo[channel_].OffLine = true;
} }
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------

280
Cigarette/CaptureThreadBasler.cpp
Unescape Escape View File

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

296
Cigarette/CaptureThreadBasler.h
Unescape Escape View File

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

379
Cigarette/CaptureThreadHIK.cpp
Unescape Escape View File

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

60
Cigarette/CaptureThreadHIK.h
Unescape Escape View File

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

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

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

236
Cigarette/Cleanthread.cpp
Unescape Escape View File

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

28
Cigarette/Cleanthread.h
Unescape Escape View File

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

100
Cigarette/FtpManager.h
Unescape Escape View File

@ -13,63 +13,63 @@
class FtpManager class FtpManager
{ {
private: private:
QUrl url; QUrl url;
QNetworkAccessManager manager; QNetworkAccessManager manager;
public: public:
FtpManager() { FtpManager() {
/* 设置通讯协议 */ /* 设置通讯协议 */
url.setScheme("ftp"); url.setScheme("ftp");
/* 设置用户名 */ /* 设置用户名 */
url.setUserName("FTP2"); url.setUserName("FTP2");
/* 设置密码 */ /* 设置密码 */
url.setPassword("123"); url.setPassword("123");
/* 设置主机，也可以是域名 */ /* 设置主机，也可以是域名 */
url.setHost("192.168.1.170"); url.setHost("192.168.1.170");
/* 设置端口号，一般为21 */ /* 设置端口号，一般为21 */
url.setPort(666); url.setPort(666);
} }
void uploadSingleFile(QString filePath, QString remotePath) { void uploadSingleFile(QString filePath, QString remotePath) {
// 设置路径 // 设置路径
url.setPath(remotePath); url.setPath(remotePath);
qDebug() << "uploadSingleFile path " << url.path(); qDebug() << "uploadSingleFile path " << url.path();
// 装载本地文件 // 装载本地文件
QFile file(filePath); QFile file(filePath);
bool isopen = false; bool isopen = false;
isopen = file.open(QIODevice::ReadOnly); isopen = file.open(QIODevice::ReadOnly);
qDebug() << "Open file " << isopen; qDebug() << "Open file " << isopen;
if (isopen) { if (isopen) {
// 读取本地文件数据 // 读取本地文件数据
QByteArray data = file.readAll(); QByteArray data = file.readAll();
file.close(); file.close();
// 上传数据，上传成功后会在远端创建文件 // 上传数据，上传成功后会在远端创建文件
manager.setNetworkAccessible(QNetworkAccessManager::Accessible); manager.setNetworkAccessible(QNetworkAccessManager::Accessible);
QNetworkReply* reply = manager.put(QNetworkRequest(url), data); QNetworkReply* reply = manager.put(QNetworkRequest(url), data);
QEventLoop eventLoop; QEventLoop eventLoop;
//QObject::connect(reply, SIGNAL(finished()), &eventLoop, SLOT(quit())); //QObject::connect(reply, SIGNAL(finished()), &eventLoop, SLOT(quit()));
//// 进入等待，但事件循环依然进行 */ //// 进入等待，但事件循环依然进行 */
//eventLoop.exec(); //eventLoop.exec();
//QObject::connect(reply, &QNetworkReply::finished, [&]() { //QObject::connect(reply, &QNetworkReply::finished, [&]() {
// if (reply->error() == QNetworkReply::NoError) { // if (reply->error() == QNetworkReply::NoError) {
// // 读取响应数据 // // 读取响应数据
// QByteArray responseData = reply->readAll(); // QByteArray responseData = reply->readAll();
// // 处理响应数据 // // 处理响应数据
// qDebug() << "Received response:" << responseData; // qDebug() << "Received response:" << responseData;
// } // }
// else { // else {
// // 处理错误 // // 处理错误
// qDebug() << "Error occurred:" << reply->errorString(); // 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) bool CLog::init(LogConfig& logConfig)
{ {
isRecord2File = logConfig.isRecord2File; isRecord2File = logConfig.isRecord2File;
QString logDir = QString(PATH_LogPath); QString logDir = QString(PATH_LogPath);
if (createDir(logDir)) if (createDir(logDir))
{ {
QString fileName = logDir + QDir::separator() + QDate::currentDate().toString("yyyy-MM-dd") + QString(Suffix); QString fileName = logDir + QDir::separator() + QDate::currentDate().toString("yyyy-MM-dd") + QString(Suffix);
QFileInfo fi(fileName); QFileInfo fi(fileName);
if (fi.exists()) if (fi.exists())
{ {
if (!localFile.exists()) if (!localFile.exists())
{ {
localFile.setFileName(fileName); localFile.setFileName(fileName);
if (localFile.open(QFile::WriteOnly | QFile::Append | QFile::Text)) if (localFile.open(QFile::WriteOnly | QFile::Append | QFile::Text))
{ {
isFileReady = true; isFileReady = true;
} }
} }
else else
{ {
isFileReady = true; isFileReady = true;
} }
} }
else else
{ {
localFile.setFileName(fileName); localFile.setFileName(fileName);
if (localFile.open(QFile::WriteOnly | QFile::Append | QFile::Text)) if (localFile.open(QFile::WriteOnly | QFile::Append | QFile::Text))
{ {
isFileReady = true; isFileReady = true;
} }
} }
} }
return isFileReady; return isFileReady;
} }
bool CLog::createDir(QString dirPath) bool CLog::createDir(QString dirPath)
{ {
QFileInfo fileInfo(dirPath); QFileInfo fileInfo(dirPath);
if (!fileInfo.exists()) if (!fileInfo.exists())
{ {
QDir tmpDir; QDir tmpDir;
return tmpDir.mkpath(dirPath); return tmpDir.mkpath(dirPath);
} }
return true; return true;
} }
void CLog::log(CLOG_TYPE nType, const char* fileDesc, const char* functionDesc, int lineNum, const char* data, ...) void CLog::log(CLOG_TYPE nType, const char* fileDesc, const char* functionDesc, int lineNum, const char* data, ...)
{ {
QMutexLocker locker(&mutexLog); QMutexLocker locker(&mutexLog);
if (isFileReady) if (isFileReady)
{ {
QString recordInfo = QString("[%1]").arg(QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss:zzz")); QString recordInfo = QString("[%1]").arg(QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss:zzz"));
recordInfo.append(getTypeDesc(nType)); recordInfo.append(getTypeDesc(nType));
#ifndef QT_NO_DEBUG #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 #endif
va_list vlist; va_list vlist;
va_start(vlist, data); va_start(vlist, data);
QByteArray byteArray; QByteArray byteArray;
#if defined(Q_OS_WIN) #if defined(Q_OS_WIN)
int recordLen = _vscprintf(data, vlist); int recordLen = _vscprintf(data, vlist);
byteArray.resize(recordLen); byteArray.resize(recordLen);
#else #else
byteArray.resize(1024); byteArray.resize(1024);
#endif #endif
vsprintf(byteArray.data(), data, vlist); vsprintf(byteArray.data(), data, vlist);
recordInfo.append(byteArray); recordInfo.append(byteArray);
va_end(vlist); va_end(vlist);
recordInfo.append("\n"); recordInfo.append("\n");
if (isRecord2File) { if (isRecord2File) {
localFile.write(recordInfo.toLocal8Bit().data(), recordInfo.toLocal8Bit().length()); localFile.write(recordInfo.toLocal8Bit().data(), recordInfo.toLocal8Bit().length());
localFile.flush(); localFile.flush();
} }
else { else {
// qDebug()<<recordInfo; // qDebug()<<recordInfo;
} }
} }
} }
void CLog::log(CLOG_TYPE nType, const char* data, ...) void CLog::log(CLOG_TYPE nType, const char* data, ...)
{ {
QMutexLocker locker(&mutexLog); QMutexLocker locker(&mutexLog);
if (isFileReady) if (isFileReady)
{ {
QString recordInfo = QString("[%1]").arg(QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss:zzz")); QString recordInfo = QString("[%1]").arg(QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss:zzz"));
recordInfo.append(getTypeDesc(nType)); recordInfo.append(getTypeDesc(nType));
recordInfo.append(" "); recordInfo.append(" ");
va_list vlist; va_list vlist;
va_start(vlist, data); va_start(vlist, data);
QByteArray byteArray; QByteArray byteArray;
#if defined(Q_OS_WIN) #if defined(Q_OS_WIN)
int recordLen = _vscprintf(data, vlist); int recordLen = _vscprintf(data, vlist);
byteArray.resize(recordLen); byteArray.resize(recordLen);
#else #else
byteArray.resize(1024); byteArray.resize(1024);
#endif #endif
vsprintf(byteArray.data(), data, vlist); vsprintf(byteArray.data(), data, vlist);
recordInfo.append(byteArray); recordInfo.append(byteArray);
va_end(vlist); va_end(vlist);
recordInfo.append("\n"); recordInfo.append("\n");
if (isRecord2File) { if (isRecord2File) {
localFile.write(recordInfo.toLocal8Bit().data(), recordInfo.toLocal8Bit().length()); localFile.write(recordInfo.toLocal8Bit().data(), recordInfo.toLocal8Bit().length());
localFile.flush(); localFile.flush();
} }
else { else {
// qDebug()<<recordInfo; // qDebug()<<recordInfo;
} }
} }
} }
QString CLog::getTypeDesc(CLog::CLOG_TYPE type) QString CLog::getTypeDesc(CLog::CLOG_TYPE type)
{ {
/* /*
switch (type) switch (type)
{ {
case CLOG_TYPE::STARTAPP: case CLOG_TYPE::STARTAPP:
return "[INFO]"; return "[INFO]";
case CLOG_TYPE::STARTWORK: case CLOG_TYPE::STARTWORK:
return "[WARNING]"; return "[WARNING]";
case CLOG_TYPE::PAUSEWORK: case CLOG_TYPE::PAUSEWORK:
return "[ERROR]"; return "[ERROR]";
} }
*/ */
return "[INFO]"; return "[INFO]";
} }
void CLog::recMegFromCigarette(QString str) void CLog::recMegFromCigarette(QString str)
{ {
CLog::LogConfig logConfig; CLog::LogConfig logConfig;
logConfig.isRecord2File = true; logConfig.isRecord2File = true;
logConfig.level = 0; logConfig.level = 0;
CLog::init(logConfig); CLog::init(logConfig);
//qDebug() << GetCurrentThreadId() << "WinAPI"; //qDebug() << GetCurrentThreadId() << "WinAPI";
CLOG_INFO(str.toStdString().c_str()); CLOG_INFO(str.toStdString().c_str());
} }

72
Cigarette/Logthread.h
Unescape Escape View File

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

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

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

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

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

78
Cigarette/SyncQueue.h
Unescape Escape View File

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

54
Cigarette/alarmdialog.cpp
Unescape Escape View File

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

14
Cigarette/alarmdialog.hpp
Unescape Escape View File

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

4
Cigarette/balluffcamera.cpp
Unescape Escape View File

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

12
Cigarette/balluffcamera.h
Unescape Escape View File

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

18
Cigarette/basecamera.h
Unescape Escape View File

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

48
Cigarette/baslercamera.cpp
Unescape Escape View File

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

22
Cigarette/baslercamera.h
Unescape Escape View File

@ -12,21 +12,21 @@
#define BaslerClassID 0x02 #define BaslerClassID 0x02
#define c_maxCamerasToUse (size_t)2 #define c_maxCamerasToUse (size_t)2
//5:»ÒÉ« //5:灰色
//6:ºÚÉ« //6:黑色
//1:ºìÉ« //1:红色
//2:»ÆÉ« //2:黄色
//3:°×É« //3:白色
//4:ÂÌÉ« //4:绿色
class BaslerCamera: public BaseCamera class BaslerCamera : public BaseCamera
{ {
public: public:
BaslerCamera(); BaslerCamera();
~BaslerCamera(); ~BaslerCamera();
static int Enumerate(); static int Enumerate();
public: 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][1] = ui.spinBox_##b##2;\
spinBox[a][2] = ui.spinBox_##b##3; spinBox[a][2] = ui.spinBox_##b##3;
camera_glue::camera_glue(QDialog *parent) camera_glue::camera_glue(QDialog* parent)
: QDialog(parent) : QDialog(parent)
{ {
ui.setupUi(this); ui.setupUi(this);
this->setWindowFlags(windowFlags()&~Qt::WindowContextHelpButtonHint); this->setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>0) #if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>0)
camera_glue_init(0,1) camera_glue_init(0, 1)
#endif #endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>1) #if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>1)
camera_glue_init(1,2) camera_glue_init(1, 2)
#endif #endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>2) #if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>2)
camera_glue_init(2,3) camera_glue_init(2, 3)
#endif #endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>3) #if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>3)
camera_glue_init(3,4) camera_glue_init(3, 4)
#endif #endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>4) #if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>4)
camera_glue_init(4,5) camera_glue_init(4, 5)
#endif #endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>5) #if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>5)
camera_glue_init(5,6) camera_glue_init(5, 6)
#endif #endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>6) #if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>6)
camera_glue_init(6,7) camera_glue_init(6, 7)
#endif #endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>7) #if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras>7)
camera_glue_init(7,8) camera_glue_init(7, 8)
#endif #endif
} }
@ -43,17 +43,17 @@ camera_glue::~camera_glue()
void camera_glue::recMsgFromDialogSetup(int ptr[][3]) void camera_glue::recMsgFromDialogSetup(int ptr[][3])
{ {
for(int i=0;i<NumberOfSupportedCameras;i++) for (int i = 0; i < NumberOfSupportedCameras; i++)
for(int j=0;j<3;j++) for (int j = 0; j < 3; j++)
spinBox[i][j]->setValue(ptr[i][j]); spinBox[i][j]->setValue(ptr[i][j]);
} }
void camera_glue::on_pushButton_take_released(void) void camera_glue::on_pushButton_take_released(void)
{ {
int mat[NumberOfSupportedCameras][3]; int mat[NumberOfSupportedCameras][3];
for(int i=0;i<NumberOfSupportedCameras;i++) for (int i = 0; i < NumberOfSupportedCameras; i++)
for(int j=0;j<3;j++) for (int j = 0; j < 3; j++)
mat[i][j]=spinBox[i][j]->value(); mat[i][j] = spinBox[i][j]->value();
emit sendMsgToDialogSetup(mat); emit sendMsgToDialogSetup(mat);
this->close(); this->close();
} }

18
Cigarette/camera_glue.h
Unescape Escape View File

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

126
Cigarette/change_shift.cpp
Unescape Escape View File

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

640
Cigarette/common.cpp
Unescape Escape View File

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

292
Cigarette/common.h
Unescape Escape View File

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

4
Cigarette/db_label.h
Unescape Escape View File

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

111
Cigarette/debugthread.h
Unescape Escape View File

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

89
Cigarette/dialogin.cpp
Unescape Escape View File

@ -1,19 +1,16 @@
#include "dialogin.hpp" #include "dialogin.hpp"
#include <QCryptographicHash> #include <QCryptographicHash>
#include <qdebug.h> #include <qdebug.h>
#include <qmessagebox.h> #include <qmessagebox.h>
extern bool g_op_mode; //是否操作员模式 extern bool g_op_mode; //是否操作员模式
extern QString g_op_pswd; //操作员密码 extern QString g_op_pswd; //操作员密码
Dialogin::Dialogin(QWidget * parent) : QDialog(parent) { Dialogin::Dialogin(QWidget* parent) : QDialog(parent) {
ui.setupUi(this); ui.setupUi(this);
m_pswd = ""; m_pswd = "";
this->setWindowFlags(Qt::FramelessWindowHint); this->setWindowFlags(Qt::FramelessWindowHint);
} }
Dialogin::~Dialogin() { Dialogin::~Dialogin() {
@ -22,78 +19,78 @@ Dialogin::~Dialogin() {
void Dialogin::on_pushButton_close_released() void Dialogin::on_pushButton_close_released()
{ {
this->close(); this->close();
} }
void Dialogin::on_pushButton_clr_released() void Dialogin::on_pushButton_clr_released()
{ {
m_pswd = ""; m_pswd = "";
ui.lineEdit->setText(""); ui.lineEdit->setText("");
} }
void Dialogin::on_pushButton_ok_released() void Dialogin::on_pushButton_ok_released()
{ {
QString md5Str = QCryptographicHash::hash(m_pswd.toLatin1(), QCryptographicHash::Md5).toHex(); QString md5Str = QCryptographicHash::hash(m_pswd.toLatin1(), QCryptographicHash::Md5).toHex();
qDebug() << "m_pswd_op:" << m_pswd; qDebug() << "m_pswd_op:" << m_pswd;
qDebug() << "m_pswd_op md5:" << md5Str; qDebug() << "m_pswd_op md5:" << md5Str;
qDebug() << "g_admin_pswd_op md5:" << g_op_pswd; qDebug() << "g_admin_pswd_op md5:" << g_op_pswd;
if (md5Str.compare(g_op_pswd, Qt::CaseInsensitive) == 0) if (md5Str.compare(g_op_pswd, Qt::CaseInsensitive) == 0)
{ {
g_op_mode = true; g_op_mode = true;
//QMessageBox::information(NULL, QStringLiteral("提示消息"), QStringLiteral("验证通过，进入管理员模式"), QMessageBox::Ok); //QMessageBox::information(NULL, QStringLiteral("提示消息"), QStringLiteral("验证通过，进入管理员模式"), QMessageBox::Ok);
emit enter_op(); emit enter_op();
this->close(); this->close();
} }
else { else {
QMessageBox::information(NULL, QStringLiteral("提示消息"), QStringLiteral("密码错误，请重新输入"), QMessageBox::Ok); QMessageBox::information(NULL, QStringLiteral("提示消息"), QStringLiteral("密码错误，请重新输入"), QMessageBox::Ok);
on_pushButton_clr_released(); on_pushButton_clr_released();
} }
} }
void Dialogin::on_pushButton_0_released() void Dialogin::on_pushButton_0_released()
{ {
m_pswd += "0"; m_pswd += "0";
ui.lineEdit->setText(ui.lineEdit->text() + "*"); ui.lineEdit->setText(ui.lineEdit->text() + "*");
} }
void Dialogin::on_pushButton_1_released() void Dialogin::on_pushButton_1_released()
{ {
m_pswd += "1"; m_pswd += "1";
ui.lineEdit->setText(ui.lineEdit->text() + "*"); ui.lineEdit->setText(ui.lineEdit->text() + "*");
} }
void Dialogin::on_pushButton_2_released() void Dialogin::on_pushButton_2_released()
{ {
m_pswd += "2"; m_pswd += "2";
ui.lineEdit->setText(ui.lineEdit->text() + "*"); ui.lineEdit->setText(ui.lineEdit->text() + "*");
} }
void Dialogin::on_pushButton_3_released() void Dialogin::on_pushButton_3_released()
{ {
m_pswd += "3"; m_pswd += "3";
ui.lineEdit->setText(ui.lineEdit->text() + "*"); ui.lineEdit->setText(ui.lineEdit->text() + "*");
} }
void Dialogin::on_pushButton_4_released() void Dialogin::on_pushButton_4_released()
{ {
m_pswd += "4"; m_pswd += "4";
ui.lineEdit->setText(ui.lineEdit->text() + "*"); ui.lineEdit->setText(ui.lineEdit->text() + "*");
} }
void Dialogin::on_pushButton_5_released() void Dialogin::on_pushButton_5_released()
{ {
m_pswd += "5"; m_pswd += "5";
ui.lineEdit->setText(ui.lineEdit->text() + "*"); ui.lineEdit->setText(ui.lineEdit->text() + "*");
} }
void Dialogin::on_pushButton_6_released() void Dialogin::on_pushButton_6_released()
{ {
m_pswd += "6"; m_pswd += "6";
ui.lineEdit->setText(ui.lineEdit->text() + "*"); ui.lineEdit->setText(ui.lineEdit->text() + "*");
} }
void Dialogin::on_pushButton_7_released() void Dialogin::on_pushButton_7_released()
{ {
m_pswd += "7"; m_pswd += "7";
ui.lineEdit->setText(ui.lineEdit->text() + "*"); ui.lineEdit->setText(ui.lineEdit->text() + "*");
} }
void Dialogin::on_pushButton_8_released() void Dialogin::on_pushButton_8_released()
{ {
m_pswd += "8"; m_pswd += "8";
ui.lineEdit->setText(ui.lineEdit->text() + "*"); ui.lineEdit->setText(ui.lineEdit->text() + "*");
} }
void Dialogin::on_pushButton_9_released() void Dialogin::on_pushButton_9_released()
{ {
m_pswd += "9"; m_pswd += "9";
ui.lineEdit->setText(ui.lineEdit->text() + "*"); 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 <QDialog>
#include "ui_dialogin.h" #include "ui_dialogin.h"
class Dialogin : public QDialog { class Dialogin : public QDialog {
Q_OBJECT Q_OBJECT
signals : signals:
void enter_op(); void enter_op();
public: public:
Dialogin(QWidget * parent = Q_NULLPTR); Dialogin(QWidget* parent = Q_NULLPTR);
~Dialogin(); ~Dialogin();
private slots : private slots:
void on_pushButton_close_released(); void on_pushButton_close_released();
void on_pushButton_clr_released(); void on_pushButton_clr_released();
void on_pushButton_ok_released(); void on_pushButton_ok_released();
void on_pushButton_0_released(); void on_pushButton_0_released();
void on_pushButton_1_released(); void on_pushButton_1_released();
void on_pushButton_2_released(); void on_pushButton_2_released();
void on_pushButton_3_released(); void on_pushButton_3_released();
void on_pushButton_4_released(); void on_pushButton_4_released();
void on_pushButton_5_released(); void on_pushButton_5_released();
void on_pushButton_6_released(); void on_pushButton_6_released();
void on_pushButton_7_released(); void on_pushButton_7_released();
void on_pushButton_8_released(); void on_pushButton_8_released();
void on_pushButton_9_released(); void on_pushButton_9_released();
public: public:
QString m_pswd; QString m_pswd;
private: 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 <QDialog>
#include "ui_dialogsetup.h" #include "ui_dialogsetup.h"
#include "basecamera.h" #include "basecamera.h"
#include <qdebug.h> #include <qdebug.h>
#include <common.h> #include "common.h"
#include <camera_glue.h> #include "camera_glue.h"
#include <output_statistic.h> #include "output_statistic.h"
#include <change_shift.h> #include "change_shift.h"
class DialogSetup : public QDialog { class DialogSetup : public QDialog {
Q_OBJECT Q_OBJECT
signals : signals:
void system_exit(); void system_exit();
void sendMsgToShift(QTime timeA, QTime timeB, QTime timeC); void sendMsgToShift(QTime timeA, QTime timeB, QTime timeC);
void sendMsgToOutput(); void sendMsgToOutput();
void sendMsgToConfig(int ptr[][3]); void sendMsgToConfig(int ptr[][3]);
#ifdef __DEBUG #ifdef __DEBUG
void _testimg(); void _testimg();
void _testimgs(); void _testimgs();
#endif #endif
private slots : private slots:
void on_toolButton_keyboard_released(); void on_toolButton_keyboard_released();
void on_pushButton_exit_released(); void on_pushButton_exit_released();
void on_pushButton_save_released(); void on_pushButton_save_released();
void on_pushButton_close_released(); void on_pushButton_close_released();
void on_toolButton_choose_config_path_released(); void on_toolButton_choose_config_path_released();
void on_toolButton_choose_model_path_released(); void on_toolButton_choose_model_path_released();
void on_toolButton_choose_path_jpg_released(); void on_toolButton_choose_path_jpg_released();
void on_toolButton_choose_save_pics_path_released(); void on_toolButton_choose_save_pics_path_released();
void on_pushButton_desktop_released(); void on_pushButton_desktop_released();
void on_pushButton_image_released(); void on_pushButton_image_released();
void on_pushButton_pswd_released(); void on_pushButton_pswd_released();
void on_pushButton_pswd_op_released(); void on_pushButton_pswd_op_released();
void on_pushButton_expo_released(); void on_pushButton_expo_released();
void on_pushButton_filter_released(); void on_pushButton_filter_released();
void on_pushButton_clear_pic_released(); void on_pushButton_clear_pic_released();
void on_pushButton_config_released(); void on_pushButton_config_released();
void on_pushButton_change_released(); void on_pushButton_change_released();
void on_pushButton_statistic_released(); void on_pushButton_statistic_released();
void on_checkBox_auto_open_clicked(bool checked); void on_checkBox_auto_open_clicked(bool checked);
void on_checkBox_auto_work_clicked(bool checked); void on_checkBox_auto_work_clicked(bool checked);
void recMsgFromDialogConfig(int ptr[][3]); void recMsgFromDialogConfig(int ptr[][3]);
void recMsgFromChangeShift(QTime timeA, QTime timeB, QTime timeC); void recMsgFromChangeShift(QTime timeA, QTime timeB, QTime timeC);
void onComboBoxSelect(int index); void onComboBoxSelect(int index);
void onComboBoxConfSelect(int index); void onComboBoxConfSelect(int index);
void onComboBoxPicsPathSelect(int index); void onComboBoxPicsPathSelect(int index);
#ifdef __DEBUG #ifdef __DEBUG
void on_pushButton_testimg_released(); void on_pushButton_testimg_released();
void on_pushButton_testimgs_released(); void on_pushButton_testimgs_released();
#endif #endif
public: public:
DialogSetup(QWidget * parent = Q_NULLPTR); DialogSetup(QWidget* parent = Q_NULLPTR);
~DialogSetup(); ~DialogSetup();
QLineEdit *lineEdit_expo_mat[NumberOfSupportedCameras]; QLineEdit* lineEdit_expo_mat[NumberOfSupportedCameras];
QLineEdit *lineEdit_gain_mat[NumberOfSupportedCameras]; QLineEdit* lineEdit_gain_mat[NumberOfSupportedCameras];
QLineEdit *lineEdit_filter_mat[NumberOfSupportedCameras]; QLineEdit* lineEdit_filter_mat[NumberOfSupportedCameras];
void InitPtrMat(); void InitPtrMat();
static void write_pswd(); static void write_pswd();
static void write_pswd_op(); static void write_pswd_op();
static void write_config(); static void write_config();
static void write_conf_path(); static void write_conf_path();
public: public:
camera_glue *m_camera_glue=NULL; camera_glue* m_camera_glue = NULL;
change_shift *m_change_shift=NULL; change_shift* m_change_shift = NULL;
output_statistic *m_output_statistic=NULL; output_statistic* m_output_statistic = NULL;
private: 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> #include <QCryptographicHash>
@ -9,10 +9,10 @@
extern bool g_admin_mode; //是否管理员模式 extern bool g_admin_mode; //是否管理员模式
extern QString g_admin_pswd; //管理员密码 extern QString g_admin_pswd; //管理员密码
DialogSetupPasswd::DialogSetupPasswd(QWidget * parent) : QDialog(parent) { DialogSetupPasswd::DialogSetupPasswd(QWidget* parent) : QDialog(parent) {
ui.setupUi(this); ui.setupUi(this);
m_pswd = ""; m_pswd = "";
this->setWindowFlags(Qt::FramelessWindowHint); this->setWindowFlags(Qt::FramelessWindowHint);
} }
DialogSetupPasswd::~DialogSetupPasswd() { DialogSetupPasswd::~DialogSetupPasswd() {
@ -21,78 +21,78 @@ DialogSetupPasswd::~DialogSetupPasswd() {
void DialogSetupPasswd::on_pushButton_close_released() void DialogSetupPasswd::on_pushButton_close_released()
{ {
this->close(); this->close();
} }
void DialogSetupPasswd::on_pushButton_clr_released() void DialogSetupPasswd::on_pushButton_clr_released()
{ {
m_pswd = ""; m_pswd = "";
ui.lineEdit->setText(""); ui.lineEdit->setText("");
} }
void DialogSetupPasswd::on_pushButton_ok_released() void DialogSetupPasswd::on_pushButton_ok_released()
{ {
QString md5Str = QCryptographicHash::hash(m_pswd.toLatin1(), QCryptographicHash::Md5).toHex(); QString md5Str = QCryptographicHash::hash(m_pswd.toLatin1(), QCryptographicHash::Md5).toHex();
qDebug() << "m_pswd:" << m_pswd; qDebug() << "m_pswd:" << m_pswd;
qDebug() << "m_pswd md5:" << md5Str; qDebug() << "m_pswd md5:" << md5Str;
qDebug() << "g_admin_pswd md5:" << g_admin_pswd; qDebug() << "g_admin_pswd md5:" << g_admin_pswd;
if (md5Str.compare(g_admin_pswd, Qt::CaseInsensitive) == 0) if (md5Str.compare(g_admin_pswd, Qt::CaseInsensitive) == 0)
{ {
g_admin_mode = true; g_admin_mode = true;
//QMessageBox::information(NULL, QStringLiteral("提示消息"), QStringLiteral("验证通过，进入管理员模式"), QMessageBox::Ok); //QMessageBox::information(NULL, QStringLiteral("提示消息"), QStringLiteral("验证通过，进入管理员模式"), QMessageBox::Ok);
emit enter_admin(); emit enter_admin();
this->close(); this->close();
} }
else { else {
QMessageBox::information(NULL, QStringLiteral("提示消息"), QStringLiteral("密码错误，请重新输入"), QMessageBox::Ok); QMessageBox::information(NULL, QStringLiteral("提示消息"), QStringLiteral("密码错误，请重新输入"), QMessageBox::Ok);
on_pushButton_clr_released(); on_pushButton_clr_released();
} }
} }
void DialogSetupPasswd::on_pushButton_0_released() void DialogSetupPasswd::on_pushButton_0_released()
{ {
m_pswd += "0"; m_pswd += "0";
ui.lineEdit->setText(ui.lineEdit->text() + "*"); ui.lineEdit->setText(ui.lineEdit->text() + "*");
} }
void DialogSetupPasswd::on_pushButton_1_released() void DialogSetupPasswd::on_pushButton_1_released()
{ {
m_pswd += "1"; m_pswd += "1";
ui.lineEdit->setText(ui.lineEdit->text() + "*"); ui.lineEdit->setText(ui.lineEdit->text() + "*");
} }
void DialogSetupPasswd::on_pushButton_2_released() void DialogSetupPasswd::on_pushButton_2_released()
{ {
m_pswd += "2"; m_pswd += "2";
ui.lineEdit->setText(ui.lineEdit->text() + "*"); ui.lineEdit->setText(ui.lineEdit->text() + "*");
} }
void DialogSetupPasswd::on_pushButton_3_released() void DialogSetupPasswd::on_pushButton_3_released()
{ {
m_pswd += "3"; m_pswd += "3";
ui.lineEdit->setText(ui.lineEdit->text() + "*"); ui.lineEdit->setText(ui.lineEdit->text() + "*");
} }
void DialogSetupPasswd::on_pushButton_4_released() void DialogSetupPasswd::on_pushButton_4_released()
{ {
m_pswd += "4"; m_pswd += "4";
ui.lineEdit->setText(ui.lineEdit->text() + "*"); ui.lineEdit->setText(ui.lineEdit->text() + "*");
} }
void DialogSetupPasswd::on_pushButton_5_released() void DialogSetupPasswd::on_pushButton_5_released()
{ {
m_pswd += "5"; m_pswd += "5";
ui.lineEdit->setText(ui.lineEdit->text() + "*"); ui.lineEdit->setText(ui.lineEdit->text() + "*");
} }
void DialogSetupPasswd::on_pushButton_6_released() void DialogSetupPasswd::on_pushButton_6_released()
{ {
m_pswd += "6"; m_pswd += "6";
ui.lineEdit->setText(ui.lineEdit->text() + "*"); ui.lineEdit->setText(ui.lineEdit->text() + "*");
} }
void DialogSetupPasswd::on_pushButton_7_released() void DialogSetupPasswd::on_pushButton_7_released()
{ {
m_pswd += "7"; m_pswd += "7";
ui.lineEdit->setText(ui.lineEdit->text() + "*"); ui.lineEdit->setText(ui.lineEdit->text() + "*");
} }
void DialogSetupPasswd::on_pushButton_8_released() void DialogSetupPasswd::on_pushButton_8_released()
{ {
m_pswd += "8"; m_pswd += "8";
ui.lineEdit->setText(ui.lineEdit->text() + "*"); ui.lineEdit->setText(ui.lineEdit->text() + "*");
} }
void DialogSetupPasswd::on_pushButton_9_released() void DialogSetupPasswd::on_pushButton_9_released()
{ {
m_pswd += "9"; m_pswd += "9";
ui.lineEdit->setText(ui.lineEdit->text() + "*"); 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 <QDialog>
#include "ui_dialogsetuppasswd.h" #include "ui_dialogsetuppasswd.h"
class DialogSetupPasswd : public QDialog { class DialogSetupPasswd : public QDialog {
Q_OBJECT Q_OBJECT
signals : signals:
void enter_admin(); void enter_admin();
public: public:
DialogSetupPasswd(QWidget * parent = Q_NULLPTR); DialogSetupPasswd(QWidget* parent = Q_NULLPTR);
~DialogSetupPasswd(); ~DialogSetupPasswd();
private slots : private slots:
void on_pushButton_close_released(); void on_pushButton_close_released();
void on_pushButton_clr_released(); void on_pushButton_clr_released();
void on_pushButton_ok_released(); void on_pushButton_ok_released();
void on_pushButton_0_released(); void on_pushButton_0_released();
void on_pushButton_1_released(); void on_pushButton_1_released();
void on_pushButton_2_released(); void on_pushButton_2_released();
void on_pushButton_3_released(); void on_pushButton_3_released();
void on_pushButton_4_released(); void on_pushButton_4_released();
void on_pushButton_5_released(); void on_pushButton_5_released();
void on_pushButton_6_released(); void on_pushButton_6_released();
void on_pushButton_7_released(); void on_pushButton_7_released();
void on_pushButton_8_released(); void on_pushButton_8_released();
void on_pushButton_9_released(); void on_pushButton_9_released();
public: public:
QString m_pswd; QString m_pswd;
private: 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) ExportDataThread::ExportDataThread(QObject* parent) : QThread(parent)
{ {
cg->read_conf(g_conf_path); cg->read_conf(g_conf_path);
for (int index = 0; index < NumberOfSupportedCameras; index++) for (int index = 0; index < NumberOfSupportedCameras; index++)
{ {
XMLError error; XMLError error;
pDocument[index] = new tinyxml2::XMLDocument(); pDocument[index] = new tinyxml2::XMLDocument();
QString xmlPath = QString(EXPORTDATA_FILE).arg(index); QString xmlPath = QString(EXPORTDATA_FILE).arg(index);
QString filePath = g_conf_path.config_path + "/" + xmlPath; QString filePath = g_conf_path.config_path + "/" + xmlPath;
error = pDocument[index]->LoadFile(filePath.toLocal8Bit().constData()); error = pDocument[index]->LoadFile(filePath.toLocal8Bit().constData());
if (error != XML_SUCCESS) { if (error != XML_SUCCESS) {
XMLDeclaration* declaration = pDocument[index]->NewDeclaration(); XMLDeclaration* declaration = pDocument[index]->NewDeclaration();
pDocument[index]->InsertFirstChild(declaration); pDocument[index]->InsertFirstChild(declaration);
} }
} }
hint = InternetOpen(0, INTERNET_OPEN_TYPE_PRECONFIG, 0, 0, 0); hint = InternetOpen(0, INTERNET_OPEN_TYPE_PRECONFIG, 0, 0, 0);
if (hint == NULL) { if (hint == NULL) {
return; return;
} }
if (!ConnectFtp()) if (!ConnectFtp())
qDebug() << "First connect FTP failed because " << GetLastError(); qDebug() << "First connect FTP failed because " << GetLastError();
} }
void ExportDataThread::init() void ExportDataThread::init()
{ {
b_quit = false; b_quit = false;
flag = false; flag = false;
} }
void ExportDataThread::start_work() void ExportDataThread::start_work()
{ {
start(HighestPriority); start(HighestPriority);
} }
void ExportDataThread::stop() void ExportDataThread::stop()
{ {
b_quit = true; b_quit = true;
_XMLExportDataInfo data; _XMLExportDataInfo data;
export_XMLData_Info_queue->put(data); export_XMLData_Info_queue->put(data);
InternetCloseHandle(hftp); InternetCloseHandle(hftp);
InternetCloseHandle(hint); InternetCloseHandle(hint);
} }
bool ExportDataThread::ConnectFtp() { bool ExportDataThread::ConnectFtp() {
// FTP地址 // FTP地址
string ftpServer = "192.168.1.170"; string ftpServer = "192.168.1.170";
/* 端口号，一般为21 */ /* 端口号，一般为21 */
int port = 666; int port = 666;
/* 用户名 */ /* 用户名 */
string userName = "FTP2"; string userName = "FTP2";
/* 密码 */ /* 密码 */
string pwd = "123"; string pwd = "123";
if (hftp != NULL) { if (hftp != NULL) {
InternetCloseHandle(hftp); InternetCloseHandle(hftp);
hftp = NULL; hftp = NULL;
} }
// 创建ftp连接 // 创建ftp连接
hftp = InternetConnectA(hint, ftpServer.c_str(), port, userName.c_str(), pwd.c_str(), INTERNET_SERVICE_FTP, 0, 0); hftp = InternetConnectA(hint, ftpServer.c_str(), port, userName.c_str(), pwd.c_str(), INTERNET_SERVICE_FTP, 0, 0);
if (hftp == NULL) { if (hftp == NULL) {
qDebug() << "ftp connect failed because " << GetLastError(); qDebug() << "ftp connect failed because " << GetLastError();
return false; return false;
} }
else else
qDebug() << "ftp reconnect success"; qDebug() << "ftp reconnect success";
return true; return true;
} }
bool _ExportDataInfo::getAverageData(map<string, float> &averageData, int index) bool _ExportDataInfo::getAverageData(map<string, float>& averageData, int index)
{ {
tinyxml2::XMLDocument doc; tinyxml2::XMLDocument doc;
//char xmlPath[256]; //char xmlPath[256];
XMLError error; XMLError error;
map<string, float> data; map<string, float> data;
//memset(xmlPath, 0, 256); //memset(xmlPath, 0, 256);
QString xmlPath = QString(EXPORTDATA_FILE).arg(index); QString xmlPath = QString(EXPORTDATA_FILE).arg(index);
//sprintf(xmlPath, EXPORTDATA_FILE, index); //sprintf(xmlPath, EXPORTDATA_FILE, index);
QString filePath = g_conf_path.config_path + "/" + xmlPath; QString filePath = g_conf_path.config_path + "/" + xmlPath;
error = doc.LoadFile(filePath.toLocal8Bit().constData()); error = doc.LoadFile(filePath.toLocal8Bit().constData());
if (error != XML_SUCCESS) if (error != XML_SUCCESS)
if (doc.LoadFile(filePath.toLocal8Bit().constData()) != 0) if (doc.LoadFile(filePath.toLocal8Bit().constData()) != 0)
{ {
cout << "load xml file failed" << endl; cout << "load xml file failed" << endl;
return false; return false;
} }
XMLElement* root = doc.RootElement(); XMLElement* root = doc.RootElement();
XMLElement* userNode = root->FirstChildElement("Camera"); XMLElement* userNode = root->FirstChildElement("Camera");
data["CameraId"] = index; data["CameraId"] = index;
data["IsNG"] = 0; data["IsNG"] = 0;
data["IsJdExist"] = 0; data["IsJdExist"] = 0;
data["Total"] = 0; data["Total"] = 0;
while (userNode != NULL) while (userNode != NULL)
{ {
if (atoi(userNode->Attribute("Id")) == index) { if (atoi(userNode->Attribute("Id")) == index) {
data["IsNG"]++; data["IsNG"]++;
data["IsJdExist"]++; data["IsJdExist"]++;
data["Total"]++; data["Total"]++;
XMLElement* IsNgNode = userNode->FirstChildElement("IsNG"); XMLElement* IsNgNode = userNode->FirstChildElement("IsNG");
data["IsNg"] = strcmp(IsNgNode->GetText(), "TRUE"); data["IsNg"] = strcmp(IsNgNode->GetText(), "TRUE");
XMLElement* IsJdExistNode = userNode->FirstChildElement("IsJdExist"); XMLElement* IsJdExistNode = userNode->FirstChildElement("IsJdExist");
if (strcmp(IsJdExistNode->GetText(), "TRUE") == 0) if (strcmp(IsJdExistNode->GetText(), "TRUE") == 0)
data["IsJdExist"]++; data["IsJdExist"]++;
XMLElement* TimeCostNode = userNode->FirstChildElement("TimeCost"); XMLElement* TimeCostNode = userNode->FirstChildElement("TimeCost");
data["TimeCost"] += stof(TimeCostNode->GetText()); data["TimeCost"] += stof(TimeCostNode->GetText());
} }
userNode = userNode->NextSiblingElement();//下一个兄弟节点 userNode = userNode->NextSiblingElement();//下一个兄弟节点
} }
if (data["Total"] == 0) if (data["Total"] == 0)
return false; return false;
data["TimeCost"] = data["TimeCost"] / data["Total"]; data["TimeCost"] = data["TimeCost"] / data["Total"];
averageData = data; averageData = data;
return true; return true;
} }
int ExportDataThread::insertXMLNode(const char* xmlPath, _XMLExportDataInfo& data) int ExportDataThread::insertXMLNode(const char* xmlPath, _XMLExportDataInfo& data)
{ {
XMLElement* root = pDocument[data.cameraId]->RootElement(); XMLElement* root = pDocument[data.cameraId]->RootElement();
if (root == NULL) { if (root == NULL) {
root = pDocument[data.cameraId]->NewElement("Root"); root = pDocument[data.cameraId]->NewElement("Root");
pDocument[data.cameraId]->InsertEndChild(root); pDocument[data.cameraId]->InsertEndChild(root);
pDocument[data.cameraId]->SaveFile(xmlPath); pDocument[data.cameraId]->SaveFile(xmlPath);
//return 0; //return 0;
} }
/// 总统计数据 /// 总统计数据
// 总检测数量 // 总检测数量
XMLElement* Total= pDocument[data.cameraId]->NewElement("TotalDatas"); XMLElement* Total = pDocument[data.cameraId]->NewElement("TotalDatas");
XMLElement* time = pDocument[data.cameraId]->NewElement("CurrentTime"); XMLElement* time = pDocument[data.cameraId]->NewElement("CurrentTime");
QString currentTime = QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss"); QString currentTime = QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss");
time->InsertEndChild(pDocument[data.cameraId]->NewText(currentTime.toStdString().c_str())); time->InsertEndChild(pDocument[data.cameraId]->NewText(currentTime.toStdString().c_str()));
Total->InsertEndChild(time); Total->InsertEndChild(time);
XMLElement* TotalCheckNum = pDocument[data.cameraId]->NewElement("TotalCheckNum"); XMLElement* TotalCheckNum = pDocument[data.cameraId]->NewElement("TotalCheckNum");
char s[20]; char s[20];
TotalCheckNum->InsertEndChild(pDocument[data.cameraId]->NewText(itoa(data.TotalCheckNum, s, 10))); TotalCheckNum->InsertEndChild(pDocument[data.cameraId]->NewText(itoa(data.TotalCheckNum, s, 10)));
Total->InsertEndChild(TotalCheckNum); Total->InsertEndChild(TotalCheckNum);
// 总剔除数量 // 总剔除数量
XMLElement* TotalKickNum = pDocument[data.cameraId]->NewElement("TotalKickNum"); XMLElement* TotalKickNum = pDocument[data.cameraId]->NewElement("TotalKickNum");
TotalKickNum->InsertEndChild(pDocument[data.cameraId]->NewText(itoa(data.TotalKickNum, s, 10))); TotalKickNum->InsertEndChild(pDocument[data.cameraId]->NewText(itoa(data.TotalKickNum, s, 10)));
Total->InsertEndChild(TotalKickNum); Total->InsertEndChild(TotalKickNum);
root->InsertEndChild(Total); root->InsertEndChild(Total);
/// 各相机数据 /// 各相机数据
// 相机id & 总数 // 相机id & 总数
XMLElement* CameraNode = pDocument[data.cameraId]->NewElement("Camera"); XMLElement* CameraNode = pDocument[data.cameraId]->NewElement("Camera");
CameraNode->SetAttribute("Count ", data.cameraTotal); CameraNode->SetAttribute("Count ", data.cameraTotal);
CameraNode->SetAttribute("Id", data.cameraId); CameraNode->SetAttribute("Id", data.cameraId);
XMLElement* JudgeNum = pDocument[data.cameraId]->NewElement("JudgeNum"); XMLElement* JudgeNum = pDocument[data.cameraId]->NewElement("JudgeNum");
// 各相机检测数量 // 各相机检测数量
XMLElement* checkNum = pDocument[data.cameraId]->NewElement("CheckNum"); XMLElement* checkNum = pDocument[data.cameraId]->NewElement("CheckNum");
checkNum->InsertEndChild(pDocument[data.cameraId]->NewText(itoa(data.checkNum, s, 10))); checkNum->InsertEndChild(pDocument[data.cameraId]->NewText(itoa(data.checkNum, s, 10)));
JudgeNum->InsertEndChild(checkNum); JudgeNum->InsertEndChild(checkNum);
// 各相机ok数量 // 各相机ok数量
XMLElement* okNum = pDocument[data.cameraId]->NewElement("OkNum"); XMLElement* okNum = pDocument[data.cameraId]->NewElement("OkNum");
okNum->InsertEndChild(pDocument[data.cameraId]->NewText(itoa(data.okNum, s, 10))); okNum->InsertEndChild(pDocument[data.cameraId]->NewText(itoa(data.okNum, s, 10)));
JudgeNum->InsertEndChild(okNum); JudgeNum->InsertEndChild(okNum);
// 各相机ng数量 // 各相机ng数量
XMLElement* ngNum = pDocument[data.cameraId]->NewElement("NgNum"); XMLElement* ngNum = pDocument[data.cameraId]->NewElement("NgNum");
ngNum->InsertEndChild(pDocument[data.cameraId]->NewText(itoa(data.ngNum, s, 10))); ngNum->InsertEndChild(pDocument[data.cameraId]->NewText(itoa(data.ngNum, s, 10)));
JudgeNum->InsertEndChild(ngNum); JudgeNum->InsertEndChild(ngNum);
// 各相机实际剔除数量（单通道剔除时为总剔除数量） // 各相机实际剔除数量（单通道剔除时为总剔除数量）
XMLElement* kickNum = pDocument[data.cameraId]->NewElement("KickNum"); XMLElement* kickNum = pDocument[data.cameraId]->NewElement("KickNum");
kickNum->InsertEndChild(pDocument[data.cameraId]->NewText(itoa(data.kickNum, s, 10))); kickNum->InsertEndChild(pDocument[data.cameraId]->NewText(itoa(data.kickNum, s, 10)));
JudgeNum->InsertEndChild(kickNum); JudgeNum->InsertEndChild(kickNum);
// 合格率 // 合格率
XMLElement* PassRate = pDocument[data.cameraId]->NewElement("PassRate"); XMLElement* PassRate = pDocument[data.cameraId]->NewElement("PassRate");
std::string temp_str = std::to_string(data.PassRate * 100 ) + "%"; std::string temp_str = std::to_string(data.PassRate * 100) + "%";
const char* temp_char = temp_str.c_str(); const char* temp_char = temp_str.c_str();
PassRate->InsertEndChild(pDocument[data.cameraId]->NewText(temp_char)); PassRate->InsertEndChild(pDocument[data.cameraId]->NewText(temp_char));
JudgeNum->InsertEndChild(PassRate); JudgeNum->InsertEndChild(PassRate);
// 剔除率 // 剔除率
XMLElement* KickRate = pDocument[data.cameraId]->NewElement("KickRate"); XMLElement* KickRate = pDocument[data.cameraId]->NewElement("KickRate");
temp_str = std::to_string(data.KickRate * 100) + "%"; temp_str = std::to_string(data.KickRate * 100) + "%";
temp_char = temp_str.c_str(); temp_char = temp_str.c_str();
KickRate->InsertEndChild(pDocument[data.cameraId]->NewText(temp_char)); KickRate->InsertEndChild(pDocument[data.cameraId]->NewText(temp_char));
JudgeNum->InsertEndChild(KickRate); JudgeNum->InsertEndChild(KickRate);
// 各相机胶点识别个数 // 各相机胶点识别个数
XMLElement* JdNum = pDocument[data.cameraId]->NewElement("JdNum"); XMLElement* JdNum = pDocument[data.cameraId]->NewElement("JdNum");
JdNum->InsertEndChild(pDocument[data.cameraId]->NewText(data.jdNum.toStdString().c_str())); JdNum->InsertEndChild(pDocument[data.cameraId]->NewText(data.jdNum.toStdString().c_str()));
JudgeNum->InsertEndChild(JdNum); JudgeNum->InsertEndChild(JdNum);
XMLElement* shotCounts = pDocument[data.cameraId]->NewElement("ShotCounts"); XMLElement* shotCounts = pDocument[data.cameraId]->NewElement("ShotCounts");
shotCounts->InsertEndChild(pDocument[data.cameraId]->NewText(itoa(data.shotCounts, s, 10))); shotCounts->InsertEndChild(pDocument[data.cameraId]->NewText(itoa(data.shotCounts, s, 10)));
JudgeNum->InsertEndChild(shotCounts); JudgeNum->InsertEndChild(shotCounts);
CameraNode->InsertEndChild(JudgeNum); CameraNode->InsertEndChild(JudgeNum);
// 各相机采集速度 // 各相机采集速度
XMLElement* speed = pDocument[data.cameraId]->NewElement("Speed"); XMLElement* speed = pDocument[data.cameraId]->NewElement("Speed");
XMLElement* AcquisitionSpeed = pDocument[data.cameraId]->NewElement("AcquisitionSpeed"); XMLElement* AcquisitionSpeed = pDocument[data.cameraId]->NewElement("AcquisitionSpeed");
AcquisitionSpeed->InsertEndChild(pDocument[data.cameraId]->NewText(data.AcquisitionSpeed.toStdString().c_str())); AcquisitionSpeed->InsertEndChild(pDocument[data.cameraId]->NewText(data.AcquisitionSpeed.toStdString().c_str()));
speed->InsertEndChild(AcquisitionSpeed); speed->InsertEndChild(AcquisitionSpeed);
// 各相机检测速度 // 各相机检测速度
XMLElement* DetectSpeed = pDocument[data.cameraId]->NewElement("DetectSpeed"); XMLElement* DetectSpeed = pDocument[data.cameraId]->NewElement("DetectSpeed");
DetectSpeed->InsertEndChild(pDocument[data.cameraId]->NewText(data.DetectSpeed.toStdString().c_str())); DetectSpeed->InsertEndChild(pDocument[data.cameraId]->NewText(data.DetectSpeed.toStdString().c_str()));
speed->InsertEndChild(DetectSpeed); speed->InsertEndChild(DetectSpeed);
CameraNode->InsertEndChild(speed); CameraNode->InsertEndChild(speed);
root->InsertEndChild(CameraNode); root->InsertEndChild(CameraNode);
return pDocument[data.cameraId]->SaveFile(xmlPath); return pDocument[data.cameraId]->SaveFile(xmlPath);
} }
void ExportDataThread::run() void ExportDataThread::run()
{ {
while (!b_quit) { while (!b_quit) {
_XMLExportDataInfo element; _XMLExportDataInfo element;
export_XMLData_Info_queue->take(element); export_XMLData_Info_queue->take(element);
if (element.cameraId != -1 && flag) { if (element.cameraId != -1 && flag) {
char buf[256]; char buf[256];
memset(buf, 0, 256); memset(buf, 0, 256);
QString xmlPath = QString(EXPORTDATA_FILE).arg(element.cameraId); QString xmlPath = QString(EXPORTDATA_FILE).arg(element.cameraId);
QString filePath = g_conf_path.config_path + "/" + xmlPath; QString filePath = g_conf_path.config_path + "/" + xmlPath;
sprintf(buf, filePath.toLocal8Bit().constData(), element.cameraId); sprintf(buf, filePath.toLocal8Bit().constData(), element.cameraId);
insertXMLNode(buf, element); insertXMLNode(buf, element);
QString remotePath = "/tmp/" + xmlPath; QString remotePath = "/tmp/" + xmlPath;
ConnectServer(filePath, remotePath); ConnectServer(filePath, remotePath);
} }
} }
flag = false; flag = false;
for (int index = 0; index < NumberOfSupportedCameras; index++) { for (int index = 0; index < NumberOfSupportedCameras; index++) {
pDocument[index]->~XMLDocument(); pDocument[index]->~XMLDocument();
} }
} }
//*****************************************已经调试好，没有理清逻辑前不要动********************** //*****************************************已经调试好，没有理清逻辑前不要动**********************
void ExportDataThread::check_save_dir(std::string dir_path) void ExportDataThread::check_save_dir(std::string dir_path)
{ {
// 如果目的路径不存在，一级一级创建 // 如果目的路径不存在，一级一级创建
// 目的路径格式为:"./dir/dir1/.../" // 目的路径格式为:"./dir/dir1/.../"
if (FALSE == FtpSetCurrentDirectoryA(hftp, dir_path.c_str())) { if (FALSE == FtpSetCurrentDirectoryA(hftp, dir_path.c_str())) {
FtpSetCurrentDirectoryA(hftp, "/"); FtpSetCurrentDirectoryA(hftp, "/");
int pos = 1; int pos = 1;
while (pos > 0) { while (pos > 0) {
// 从第二个“/”开始依次找到目的路径中的“/”位置 // 从第二个“/”开始依次找到目的路径中的“/”位置
pos = dir_path.find_first_of('/', pos + 1); pos = dir_path.find_first_of('/', pos + 1);
if (pos == -1) if (pos == -1)
break; break;
string tempPath = dir_path.substr(0, pos + 1); string tempPath = dir_path.substr(0, pos + 1);
FtpCreateDirectoryA(hftp, tempPath.c_str()); FtpCreateDirectoryA(hftp, tempPath.c_str());
} }
//FtpSetCurrentDirectoryA(hftp, dir_path.c_str()); //FtpSetCurrentDirectoryA(hftp, dir_path.c_str());
} }
} }
void ExportDataThread::EDrecMsgFromCigarette(){ void ExportDataThread::EDrecMsgFromCigarette() {
flag = true; flag = true;
} }
void ExportDataThread::ConnectServer(QString srcPath, QString destPath) { void ExportDataThread::ConnectServer(QString srcPath, QString destPath) {
string filePath = srcPath.toLocal8Bit().constData(); string filePath = srcPath.toLocal8Bit().constData();
string remotePath = destPath.toLocal8Bit().constData(); string remotePath = destPath.toLocal8Bit().constData();
std::vector<string> files; std::vector<string> files;
// 判断上传的是文件还是文件夹标识 // 判断上传的是文件还是文件夹标识
int size = 0; int size = 0;
struct stat st; struct stat st;
stat(filePath.c_str(), &st); stat(filePath.c_str(), &st);
if (st.st_mode & S_IFDIR) { if (st.st_mode & S_IFDIR) {
//qDebug() << "filePath is Directory"; //qDebug() << "filePath is Directory";
// 获取文件夹下所有文件名 // 获取文件夹下所有文件名
GetFiles(filePath, files); GetFiles(filePath, files);
size = files.size(); size = files.size();
} }
// 上传文件源为一个文件 // 上传文件源为一个文件
if (size == 0) { if (size == 0) {
int pos = remotePath.find_last_of('/'); int pos = remotePath.find_last_of('/');
string destFileName = remotePath.substr(pos + 1); string destFileName = remotePath.substr(pos + 1);
string tempPath = remotePath.substr(0, pos + 1); string tempPath = remotePath.substr(0, pos + 1);
check_save_dir(tempPath); check_save_dir(tempPath);
if (!InternetGetConnectedState(NULL, 0)) { if (!InternetGetConnectedState(NULL, 0)) {
qDebug() << "计算机未连接到互联网"; qDebug() << "计算机未连接到互联网";
} }
else { else {
while (!FtpPutFileA(hftp, filePath.c_str(), remotePath.c_str(), FTP_TRANSFER_TYPE_BINARY, 0)) { while (!FtpPutFileA(hftp, filePath.c_str(), remotePath.c_str(), FTP_TRANSFER_TYPE_BINARY, 0)) {
qDebug() << "ftp put file "<< filePath.c_str() << "failed because" << GetLastError(); qDebug() << "ftp put file " << filePath.c_str() << "failed because" << GetLastError();
if (!ConnectFtp()) if (!ConnectFtp())
qDebug() << "connect FTP failed because " << GetLastError(); qDebug() << "connect FTP failed because " << GetLastError();
} }
} }
} }
// 上传源为一个文件夹 // 上传源为一个文件夹
else{ else {
for (int i = 0; i < size; i++) { for (int i = 0; i < size; i++) {
string tempFilePath = (string(files[i]).erase(0, filePath.length() + 1)).c_str(); string tempFilePath = (string(files[i]).erase(0, filePath.length() + 1)).c_str();
// 获取上传路径中的文件名 // 获取上传路径中的文件名
int pos = tempFilePath.find_last_of('/'); int pos = tempFilePath.find_last_of('/');
string destFileName = tempFilePath.substr(pos + 1); string destFileName = tempFilePath.substr(pos + 1);
check_save_dir(remotePath + tempFilePath.substr(0, 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)) if (!FtpPutFileA(hftp, files[i].c_str(), destFileName.c_str(), FTP_TRANSFER_TYPE_BINARY, 0))
qDebug() << "ftp put files failed because " << GetLastError(); qDebug() << "ftp put files failed because " << GetLastError();
} }
} }
} }
void ExportDataThread::GetDataFromSaveThread(QString filePath) { void ExportDataThread::GetDataFromSaveThread(QString filePath) {
QString remotePath; QString remotePath;
remotePath = filePath.mid(filePath.indexOf("image") - 1); remotePath = filePath.mid(filePath.indexOf("image") - 1);
ConnectServer(filePath, remotePath); ConnectServer(filePath, remotePath);
} }
//*****************************************已经调试好，没有理清逻辑前不要动********************** //*****************************************已经调试好，没有理清逻辑前不要动**********************
void ExportDataThread::GetFiles(string path, std::vector<string>& files) { void ExportDataThread::GetFiles(string path, std::vector<string>& files) {
//文件句柄 //文件句柄
intptr_t hFile = 0; intptr_t hFile = 0;
//文件信息的结构体 //文件信息的结构体
struct _finddata_t fileinfo; struct _finddata_t fileinfo;
string p; string p;
if ((hFile = _findfirst(p.assign(path).append("\\*").c_str(), &fileinfo)) != -1) if ((hFile = _findfirst(p.assign(path).append("\\*").c_str(), &fileinfo)) != -1)
{ {
// "\\*"是指读取文件夹下的所有类型的文件 // "\\*"是指读取文件夹下的所有类型的文件
do do
{ {
//如果是目录,迭代之 //如果是目录,迭代之
//如果不是,加入列表 //如果不是,加入列表
if ((fileinfo.attrib & _A_SUBDIR)) if ((fileinfo.attrib & _A_SUBDIR))
{ {
if (strcmp(fileinfo.name, ".") != 0 && strcmp(fileinfo.name, "..") != 0) if (strcmp(fileinfo.name, ".") != 0 && strcmp(fileinfo.name, "..") != 0)
GetFiles(p.assign(path).append("/").append(fileinfo.name), files); GetFiles(p.assign(path).append("/").append(fileinfo.name), files);
} }
else else
{ {
files.push_back(p.assign(path).append("/").append(fileinfo.name)); files.push_back(p.assign(path).append("/").append(fileinfo.name));
} }
} while (_findnext(hFile, &fileinfo) == 0); } while (_findnext(hFile, &fileinfo) == 0);
_findclose(hFile); _findclose(hFile);
} }
} }

192
Cigarette/exportData.h
Unescape Escape View File

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

24
Cigarette/hikcamera.cpp
Unescape Escape View File

@ -18,21 +18,21 @@ HIKCamera::~HIKCamera()
int HIKCamera::Enumerate() 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) if (MV_OK == status)
{ {
return stDeviceList.nDeviceNum; return stDeviceList.nDeviceNum;
} }
else else
{ {
return 0; return 0;
} }
} }

10
Cigarette/hikcamera.h
Unescape Escape View File

@ -6,15 +6,15 @@
#define HIKClassID 0x03 #define HIKClassID 0x03
class HIKCamera: public BaseCamera class HIKCamera : public BaseCamera
{ {
public: public:
HIKCamera(int DeviceNum); HIKCamera(int DeviceNum);
~HIKCamera(); ~HIKCamera();
static int Enumerate(); static int Enumerate();
public: 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" #include "CryptoToolLib.h"
#endif #endif
int main(int argc, char *argv[]) int main(int argc, char* argv[])
{ {
#if defined LICENSE_VERIFY #if defined LICENSE_VERIFY
if(!VerifyLicense()) if (!VerifyLicense())
{ {
exit(0); exit(0);
} }
#endif #endif
qRegisterMetaType<cv::Mat>("cv::Mat"); qRegisterMetaType<cv::Mat>("cv::Mat");
QApplication a(argc, argv); QApplication a(argc, argv);
QPixmap pixmap("D:/Release/splash.jpg"); QPixmap pixmap("D:/Release/splash.jpg");
QSplashScreen splash(pixmap); QSplashScreen splash(pixmap);
splash.show(); splash.show();
a.processEvents(); a.processEvents();
Cigarette w; Cigarette w;
w.show(); w.show();
//w.showFullScreen(); //w.showFullScreen();
splash.finish(&w); splash.finish(&w);
return a.exec(); 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)\ #define output_init(a, b)\
textBrowser_mat[a] = ui.textBrowser_##b; textBrowser_mat[a] = ui.textBrowser_##b;
output_statistic::output_statistic(QDialog *parent) output_statistic::output_statistic(QDialog* parent)
: QDialog(parent) : QDialog(parent)
{ {
ui.setupUi(this); ui.setupUi(this);
this->setWindowFlags(windowFlags()&~Qt::WindowContextHelpButtonHint); this->setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras > 0) #if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras > 0)
output_init(0, 1); output_init(0, 1);
#endif #endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras > 1) #if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras > 1)
output_init(1, 2); output_init(1, 2);
#endif #endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras > 2) #if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras > 2)
output_init(2, 3); output_init(2, 3);
#endif #endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras > 3) #if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras > 3)
output_init(3, 4); output_init(3, 4);
#endif #endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras > 4) #if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras > 4)
output_init(4, 5); output_init(4, 5);
#endif #endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras > 5) #if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras > 5)
output_init(5, 6); output_init(5, 6);
#endif #endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras > 6) #if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras > 6)
output_init(6, 7); output_init(6, 7);
#endif #endif
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras > 7) #if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras > 7)
output_init(7, 8); output_init(7, 8);
#endif #endif
} }
@ -47,23 +47,23 @@ output_statistic::~output_statistic()
void output_statistic::recMsgFromDialogSetup() void output_statistic::recMsgFromDialogSetup()
{ {
QString file_path, file_name; QString file_path, file_name;
QFile file; QFile file;
for (int i = 0; i < NumberOfSupportedCameras; i++) { for (int i = 0; i < NumberOfSupportedCameras; i++) {
file_name = QString(STATISTIC_FILE).arg(i); file_name = QString(STATISTIC_FILE).arg(i);
file_path = g_conf_path.config_path + "/" + file_name; file_path = g_conf_path.config_path + "/" + file_name;
file.setFileName(file_path); file.setFileName(file_path);
if (file.open(QIODevice::ReadOnly | QIODevice::Text)) if (file.open(QIODevice::ReadOnly | QIODevice::Text))
{ {
QTextStream in(&file); QTextStream in(&file);
//in.setCodec("UTF-8"); //in.setCodec("UTF-8");
textBrowser_mat[i]->setText(in.readAll()); textBrowser_mat[i]->setText(in.readAll());
} }
else { else {
std::cout << "can not open statistic file" << std::endl; std::cout << "can not open statistic file" << std::endl;
} }
file.close(); file.close();
this->show(); this->show();
} }
//this->show(); //this->show();
} }

12
Cigarette/output_statistic.h
Unescape Escape View File

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

12
Cigarette/plc_item.h
Unescape Escape View File

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

458
Cigarette/plcsetup.cpp
Unescape Escape View File

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

32
Cigarette/plcsetup.hpp
Unescape Escape View File

@ -1,4 +1,4 @@
#pragma once #pragma once
#include <QDialog> #include <QDialog>
#include <QPushButton> #include <QPushButton>
#include "ui_plcsetup.h" #include "ui_plcsetup.h"
@ -11,29 +11,29 @@
class QTimer; class QTimer;
class PlcSetup : public QDialog { class PlcSetup : public QDialog {
Q_OBJECT Q_OBJECT
public: public:
PlcSetup(QWidget * parent = Q_NULLPTR); PlcSetup(QWidget* parent = Q_NULLPTR);
~PlcSetup(); ~PlcSetup();
QTimer *m_pTimer; QTimer* m_pTimer;
void read_plc_items(); void read_plc_items();
void save_plc_items(); void save_plc_items();
private slots: private slots:
void click_read(); void click_read();
void click_write(); void click_write();
void click_save(); void click_save();
void on_toolButton_batch_read_released(); void on_toolButton_batch_read_released();
void on_toolButton_keyboard_released(); void on_toolButton_keyboard_released();
void on_toolButton_close_released(); void on_toolButton_close_released();
void handleTimeout(); //窗口加载时执行一次，批处理读取所有地址 void handleTimeout(); //窗口加载时执行一次，批处理读取所有地址
private: 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/opencv.hpp>
#include <opencv2/imgproc/types_c.h> #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 class SaveThread : public QThread
{ {
Q_OBJECT Q_OBJECT
signals: signals:
void sendDataToExport(QString filePath); void sendDataToExport(QString filePath);
public: public:
SaveThread(QObject *parent = 0): QThread(parent) SaveThread(QObject* parent = 0) : QThread(parent)
{ {
} }
~SaveThread() ~SaveThread()
{ {
stop(); stop();
g_save_queue->put(std::make_pair("", cv::Mat())); g_save_queue->put(std::make_pair("", cv::Mat()));
quit(); quit();
wait(); wait();
} }
void init() void init()
{ {
b_quit = false; b_quit = false;
} }
void start_work() void start_work()
{ {
start(HighestPriority); start(HighestPriority);
} }
void stop() void stop()
{ {
b_quit = true; b_quit = true;
} }
protected: protected:
void run() 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) { if (dir_path == vec_save_dirs[i])
cv::Mat image; {
std::pair<std::string, cv::Mat> element; b_find = true;
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) if (!b_find)
{ {
bool b_find = false; //QString dir_str = QString::fromStdString(dir_path);
for (int i = 0; i < vec_save_dirs.size(); i++) QString dir_str = QString::fromLocal8Bit(QByteArray::fromRawData(dir_path.c_str(), dir_path.size()));
{
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()));
QDir dir; QDir dir;
if (!dir.exists(dir_str)) if (!dir.exists(dir_str))
{ {
dir.mkpath(dir_str); dir.mkpath(dir_str);
} }
vec_save_dirs.push_back(dir_path); vec_save_dirs.push_back(dir_path);
} }
} }
public: public:
bool b_quit; bool b_quit;
std::vector<std::string> vec_save_dirs; std::vector<std::string> vec_save_dirs;
}; };
#endif #endif

513
Cigarette/syncworkthread.cpp
Unescape Escape View File

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

122
Cigarette/threadReceive.cpp
Unescape Escape View File

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

42
Cigarette/threadReceive.h
Unescape Escape View File

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

90
Cigarette/threadSend.cpp
Unescape Escape View File

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

110
Cigarette/threadSend.h
Unescape Escape View File

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

5
Cigarette/threadSendTCP.cpp
Unescape Escape View File

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

62
Cigarette/threadSendTCP.h
Unescape Escape View File

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

Write Preview
Loading…
Cancel
Save