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

3
Cigarette/AlarmInfo.cpp
Unescape Escape View File

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

9
Cigarette/AlarmInfo.h
Unescape Escape View File

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

56
Cigarette/CaptureThread.cpp
Unescape Escape View File

@ -2,13 +2,13 @@
#include "common.h"
#include "exportData.h"
extern bool g_debug_mode; //相机调试模式，工作模式必须停止状态才能打开
extern bool g_debug_mode; //相机调试模式，工作模式必须停止状态才能打开
extern SyncQueue<_XMLExportDataInfo>* export_XMLData_Info_queue;
//-----------------------------------------------------------------------------
CaptureThread::CaptureThread( Device* pCurrDev, bool boTerminated, FunctionInterface* pFI_ ,int Num) :
pDev_( pCurrDev ), boTerminated_( boTerminated ), requestPendingForDisplay_( INVALID_ID ), pFI_( pFI_ ),Local_Num(Num)
//-----------------------------------------------------------------------------
CaptureThread::CaptureThread(Device* pCurrDev, bool boTerminated, FunctionInterface* pFI_, int Num) :
pDev_(pCurrDev), boTerminated_(boTerminated), requestPendingForDisplay_(INVALID_ID), pFI_(pFI_), Local_Num(Num)
//-----------------------------------------------------------------------------
{
p_unit_queue = new ASyncQueue<cv::Mat>(Unit_Queue_Size);
}
@ -26,12 +26,12 @@ CaptureThread::~CaptureThread()
delete p_unit_queue;
}
//-----------------------------------------------------------------------------
void CaptureThread::process( void )
void CaptureThread::process(void)
//-----------------------------------------------------------------------------
{
try
{
//Line5回调
//Line5回调
mvIMPACT::acquire::GenICam::EventControl pEventCtrl_(pDev_);
//pEventCtrl_.eventSelector.writeS("Line5FallingEdge");
//pEventCtrl_.eventNotification.writeS("Off");
@ -65,34 +65,34 @@ void CaptureThread::process( void )
m_threadFunc.p_result_queue_ = p_result_queue;
m_threadFunc.p_double_queue_ = p_double_queue;
//相机掉线回调
//相机掉线回调
CIwtCameraLostCallbackMV cam_lost_cb;
cam_lost_cb.channel_ = Local_Num;
if (cam_lost_cb.registerComponent(pDev_->state) != true)
{
std::cout << "ERROR: Unable to register the camera's lost CallBack function!\n";
}
//图像采集循环
//图像采集循环
TDMR_ERROR result = DMR_NO_ERROR;
while( ( result = static_cast< TDMR_ERROR >( pFI_->imageRequestSingle() ) ) == DMR_NO_ERROR ) {};
if( result != DEV_NO_FREE_REQUEST_AVAILABLE )
while ((result = static_cast<TDMR_ERROR>(pFI_->imageRequestSingle())) == DMR_NO_ERROR) {};
if (result != DEV_NO_FREE_REQUEST_AVAILABLE)
{
qDebug() << "'FunctionInterface.imageRequestSingle' returned with an unexpected result: " << QString::fromStdString( mvIMPACT::acquire::ImpactAcquireException::getErrorCodeAsString( result ) );
qDebug() << "'FunctionInterface.imageRequestSingle' returned with an unexpected result: " << QString::fromStdString(mvIMPACT::acquire::ImpactAcquireException::getErrorCodeAsString(result));
}
manuallyStartAcquisitionIfNeeded( pDev_, *pFI_ );
manuallyStartAcquisitionIfNeeded(pDev_, *pFI_);
int cnt = 0;
// run thread loop
mvIMPACT::acquire::Statistics statistics( pDev_ );
mvIMPACT::acquire::Statistics statistics(pDev_);
mvIMPACT::acquire::Request* pRequest = 0;
mvIMPACT::acquire::Request* pPreviousRequest = nullptr;
const unsigned int timeout_ms = 100;
Ready = true;
while( !boTerminated_ )
while (!boTerminated_)
{
const int requestNr = pFI_->imageRequestWaitFor( timeout_ms );
pRequest = pFI_->isRequestNrValid( requestNr ) ? pFI_->getRequest( requestNr ) : 0;
if( pRequest )
const int requestNr = pFI_->imageRequestWaitFor(timeout_ms);
pRequest = pFI_->isRequestNrValid(requestNr) ? pFI_->getRequest(requestNr) : 0;
if (pRequest)
{
if (pRequest->isOK())
{
@ -105,21 +105,21 @@ void CaptureThread::process( void )
if (!g_debug_mode)
{
#ifdef IMM_PROCESS
p_image_queue->put(std::make_pair(1,image_clone)); //放入临时队列
p_image_queue->put(std::make_pair(1, image_clone)); //放入临时队列
#else
p_unit_queue->put(image_clone); //放入临时队列
p_unit_queue->put(image_clone); //放入临时队列
#endif
}
else
{
p_debug_queue->put(image_clone); //放入调试队列
p_debug_queue->put(image_clone); //放入调试队列
}
cnt++;
// display some statistics
if (cnt % 10 == 0)
{
QString data = QString::fromStdString(statistics.framesPerSecond.readS());
emit updateStatistics(data.left(4),Local_Num);
emit updateStatistics(data.left(4), Local_Num);
}
}
else
@ -140,24 +140,24 @@ void CaptureThread::process( void )
m_threadFunc.SendFeedBack(ImageCap);
#endif
}
manuallyStopAcquisitionIfNeeded( pDev_, *pFI_ );
if( pRequest )
manuallyStopAcquisitionIfNeeded(pDev_, *pFI_);
if (pRequest)
{
pRequest->unlock();
}
pFI_->imageRequestReset( 0, 0 );
pFI_->imageRequestReset(0, 0);
}
catch( const ImpactAcquireException& e )
catch (const ImpactAcquireException& e)
{
emit error( QString::fromStdString( e.getErrorCodeAsString() ) );
emit error(QString::fromStdString(e.getErrorCodeAsString()));
}
}
//-----------------------------------------------------------------------------
int CaptureThread::getPendingRequestNr( void )
int CaptureThread::getPendingRequestNr(void)
//-----------------------------------------------------------------------------
{
QMutexLocker lockedScope( &lock_ );
QMutexLocker lockedScope(&lock_);
int result = requestPendingForDisplay_;
// Reset the ID of the request to tell the capture loop that this request has already been
// picked up and someone else will take care of it from now on.

72
Cigarette/CaptureThread.h
Unescape Escape View File

@ -25,20 +25,20 @@ class CaptureThread_Func
{
public:
Device* m_pMVCamera;
ASyncQueue<bool> *p_result_queue_;
ASyncQueue<bool> *p_double_queue_;
ASyncQueue<bool>* p_result_queue_;
ASyncQueue<bool>* p_double_queue_;
void SendFeedBack(int OpID)
{
bool send_ng=false;
bool send_ok=false;
if(OpID == EdgeEvent)
bool send_ng = false;
bool send_ok = false;
if (OpID == EdgeEvent)
{
#if defined DOUBLE_FEED_BACK
if(p_double_queue_->count() > 0)
if (p_double_queue_->count() > 0)
{
bool temp;
p_double_queue_->take(temp);
send_ng=true;
send_ng = true;
}
#endif
}
@ -51,17 +51,17 @@ public:
#if defined DOUBLE_FEED_BACK
p_double_queue_->put(true);
#endif
send_ng=true;
send_ng = true;
}
else
{
send_ok=true;
send_ok = true;
}
}
try
{
mvIMPACT::acquire::GenICam::DigitalIOControl mvDIOC(m_pMVCamera);
if(send_ng){
if (send_ng) {
mvDIOC.userOutputSelector.writeS("UserOutput0");
mvIMPACT::acquire::TBoolean tb = mvDIOC.userOutputValue.read();
if (tb == bFalse)
@ -81,33 +81,33 @@ public:
}
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
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
{
Q_OBJECT
public:
explicit CaptureThread( Device* pCurrDev, bool boTerminated, FunctionInterface* pFi ,int Num);
explicit CaptureThread(Device* pCurrDev, bool boTerminated, FunctionInterface* pFi, int Num);
CaptureThread::~CaptureThread(void);
void terminate( void )
void terminate(void)
{
boTerminated_ = true;
}
int getPendingRequestNr();
signals:
void error( QString err );
void finished( void );
void requestReady( void );
void updateStatistics( const QString& data ,int Num);
void error(QString err);
void finished(void);
void requestReady(void);
void updateStatistics(const QString& data, int Num);
private slots:
void process( void );
void process(void);
void fpsTimeout(void);
public:
@ -116,17 +116,17 @@ public:
uint64_t m_cntGrabbedImages = 0;
uint64_t m_cntLastGrabbedImages = 0;
#ifdef SYNC_CAMERA
ImageSyncArr *p_image_sync_arr;
ImageSyncArr* p_image_sync_arr;
SyncQueue<std::vector<std::pair<int, cv::Mat>>>* p_image_sync_queue;
#else
SyncQueue<std::pair<int, cv::Mat> > *p_image_queue;
SyncQueue<std::pair<int, cv::Mat> >* p_image_queue;
#endif
ASyncQueue<cv::Mat> *p_unit_queue;
ASyncQueue<bool> *p_result_queue;
ASyncQueue<bool> *p_result_wait_queue;
ASyncQueue<bool> *p_double_queue;
ASyncQueue<bool> *p_shooted_queue;
SyncQueue<cv::Mat> *p_debug_queue;
ASyncQueue<cv::Mat>* p_unit_queue;
ASyncQueue<bool>* p_result_queue;
ASyncQueue<bool>* p_result_wait_queue;
ASyncQueue<bool>* p_double_queue;
ASyncQueue<bool>* p_shooted_queue;
SyncQueue<cv::Mat>* p_debug_queue;
bool Ready = false;
CaptureThread_Func m_threadFunc;
private:
@ -143,16 +143,16 @@ private:
class EventCallback : public mvIMPACT::acquire::ComponentCallback
{
public:
ASyncQueue<cv::Mat> *p_unit_queue_;
ASyncQueue<cv::Mat>* p_unit_queue_;
#ifdef SYNC_CAMERA
ImageSyncArr *p_image_sync_arr_;
SyncQueue<std::vector<std::pair<int, cv::Mat>>> *p_image_sync_queue_;
ImageSyncArr* p_image_sync_arr_;
SyncQueue<std::vector<std::pair<int, cv::Mat>>>* p_image_sync_queue_;
#else
SyncQueue<std::pair<int, cv::Mat> > *p_image_queue_;
SyncQueue<std::pair<int, cv::Mat> >* p_image_queue_;
#endif
ASyncQueue<bool> *p_result_wait_queue_;
ASyncQueue<bool> *p_shooted_queue_;
ASyncQueue<bool> *p_double_queue_;
ASyncQueue<bool>* p_result_wait_queue_;
ASyncQueue<bool>* p_shooted_queue_;
ASyncQueue<bool>* p_double_queue_;
explicit EventCallback(void* pUserData = 0) : ComponentCallback(pUserData) {}
Device* m_pMVCamera;
CaptureThread* pCaptureThread = NULL;
@ -181,11 +181,11 @@ public:
if (
p_shooted_queue_->count() > 0
#if defined DOUBLE_FEED_BACK
|| p_double_queue_->count() >0
|| p_double_queue_->count() > 0
#endif
)
{
if (p_shooted_queue_->count() > 0){
if (p_shooted_queue_->count() > 0) {
bool temp;
p_shooted_queue_->take(temp);
}

20
Cigarette/CaptureThreadBasler.cpp
Unescape Escape View File

@ -5,11 +5,11 @@
#include <qdebug.h>
#include <exportData.h>
extern SyncQueue<_XMLExportDataInfo>* export_XMLData_Info_queue;
extern PLCDevice * m_PLCDevice;
//-----------------------------------------------------------------------------
CaptureThreadBasler::CaptureThreadBasler(Pylon::CBaslerUniversalInstantCamera* pCurrDev, bool boTerminated,int Num,int shoot) :
pDev_( pCurrDev ), boTerminated_( boTerminated ),Local_Num(Num)
extern PLCDevice* m_PLCDevice;
//-----------------------------------------------------------------------------
CaptureThreadBasler::CaptureThreadBasler(Pylon::CBaslerUniversalInstantCamera* pCurrDev, bool boTerminated, int Num, int shoot) :
pDev_(pCurrDev), boTerminated_(boTerminated), Local_Num(Num)
//-----------------------------------------------------------------------------
{
p_unit_queue = new ASyncQueue<cv::Mat>(Unit_Queue_Size);
Shoot_Num = shoot;
@ -87,11 +87,11 @@ void CaptureThreadBasler::process(void)
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);
}
if(pDev_->EventSelector.TrySetValue("Line1FallingEdge"))
if (pDev_->EventSelector.TrySetValue("Line1FallingEdge"))
{
pDev_->EventNotification.SetValue(Basler_UniversalCameraParams::EventNotification_Off);
}
@ -101,7 +101,7 @@ void CaptureThreadBasler::process(void)
if (pDev_->TriggerSelector.TrySetValue(Basler_UniversalCameraParams::TriggerSelector_FrameBurstStart))
{
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);
}
@ -162,10 +162,10 @@ void CaptureThreadBasler::process(void)
pDev_->DeregisterCameraEventHandler(&BurstEvent, "EventLine1FallingEdgeData");
#endif
}
catch(const Pylon::GenericException& e)
catch (const Pylon::GenericException& e)
{
emit error( QString::fromStdString( e.GetDescription()) );
std::cout << e.GetSourceLine()<<e.GetDescription() << std::endl;
emit error(QString::fromStdString(e.GetDescription()));
std::cout << e.GetSourceLine() << e.GetDescription() << std::endl;
if (pDev_->IsCameraDeviceRemoved())
{
cout << "The camera has been removed from the computer." << endl;

98
Cigarette/CaptureThreadBasler.h
Unescape Escape View File

@ -28,21 +28,21 @@ class CaptureThreadBasler_Func
{
public:
Pylon::CBaslerUniversalInstantCamera* pDev__;
ASyncQueue<bool> *p_result_queue_;
ASyncQueue<bool> *p_double_queue_;
QTimer *m_IOTimer_ = NULL;
ASyncQueue<bool>* p_result_queue_;
ASyncQueue<bool>* p_double_queue_;
QTimer* m_IOTimer_ = NULL;
void SendFeedBack(int OpID)
{
bool send_ng=false;
bool send_ok=false;
if(OpID == EdgeEvent)
bool send_ng = false;
bool send_ok = false;
if (OpID == EdgeEvent)
{
#if defined DOUBLE_FEED_BACK
if(p_double_queue_->count() > 0)
if (p_double_queue_->count() > 0)
{
bool temp;
p_double_queue_->take(temp);
send_ng=true;
send_ng = true;
}
#endif
}
@ -54,11 +54,11 @@ public:
#if defined DOUBLE_FEED_BACK
p_double_queue_->put(true);
#endif
send_ng=true;
send_ng = true;
}
else
{
send_ok=true;
send_ok = true;
}
}
#ifndef USB_BASLER_NEW_FW
@ -92,21 +92,21 @@ class CaptureThreadBasler : public QObject
Q_OBJECT
public:
explicit CaptureThreadBasler(Pylon::CBaslerUniversalInstantCamera* pCurrDev, bool boTerminated,int Num,int shoot);
explicit CaptureThreadBasler(Pylon::CBaslerUniversalInstantCamera* pCurrDev, bool boTerminated, int Num, int shoot);
CaptureThreadBasler::~CaptureThreadBasler(void);
void terminate( void )
void terminate(void)
{
boTerminated_ = true;
}
signals:
void error( QString err );
void finished( void );
void requestReady( void );
void updateStatistics( const QString& data ,int Num);
void error(QString err);
void finished(void);
void requestReady(void);
void updateStatistics(const QString& data, int Num);
private slots:
void process( void );
void process(void);
void fpsTimeout(void);
void ioTimeout(void);
@ -114,18 +114,18 @@ public:
int Local_Num;
int Shoot_Num;
#ifdef SYNC_CAMERA
ImageSyncArr *p_image_sync_arr;
ImageSyncArr* p_image_sync_arr;
SyncQueue<std::vector<std::pair<int, cv::Mat>>>* p_image_sync_queue;
#else
SyncQueue<std::pair<int, cv::Mat> >* p_image_queue;
#endif
ASyncQueue<cv::Mat> *p_unit_queue;
ASyncQueue<bool> *p_result_queue;
ASyncQueue<bool> *p_result_wait_queue;
ASyncQueue<bool> *p_double_queue;
ASyncQueue<bool> *p_shooted_queue;
SyncQueue<cv::Mat> *p_debug_queue;
QTimer *m_Timer = NULL,*m_IOTimer = NULL;
ASyncQueue<cv::Mat>* p_unit_queue;
ASyncQueue<bool>* p_result_queue;
ASyncQueue<bool>* p_result_wait_queue;
ASyncQueue<bool>* p_double_queue;
ASyncQueue<bool>* p_shooted_queue;
SyncQueue<cv::Mat>* p_debug_queue;
QTimer* m_Timer = NULL, * m_IOTimer = NULL;
uint64_t m_cntGrabbedImages = 0;
uint64_t m_cntLastGrabbedImages = 0;
bool Ready = false;
@ -141,7 +141,7 @@ class CSampleConfigurationEventHandler : public Pylon::CBaslerUniversalConfigura
public:
int channel_;
// This method is called from a different thread when the camera device removal has been detected.
void OnCameraDeviceRemoved( Pylon::CBaslerUniversalInstantCamera& camera )
void OnCameraDeviceRemoved(Pylon::CBaslerUniversalInstantCamera& camera)
{
SingleCamInfo[channel_].OffLine = true;
}
@ -151,15 +151,15 @@ public:
class CSampleCameraEventHandler : public Pylon::CBaslerUniversalCameraEventHandler
{
public:
QTimer * ioTimer;
QTimer* ioTimer;
ASyncQueue<cv::Mat>* p_unit_queue_;
ASyncQueue<bool> *p_result_wait_queue_;
ASyncQueue<bool> *p_result_queue_;
ASyncQueue<bool> *p_double_queue_;
ASyncQueue<bool> *p_shooted_queue_;
ASyncQueue<bool>* p_result_wait_queue_;
ASyncQueue<bool>* p_result_queue_;
ASyncQueue<bool>* p_double_queue_;
ASyncQueue<bool>* p_shooted_queue_;
#ifdef SYNC_CAMERA
ImageSyncArr *p_image_sync_arr_;
SyncQueue<std::vector<std::pair<int, cv::Mat>>> *p_image_sync_queue_;
ImageSyncArr* p_image_sync_arr_;
SyncQueue<std::vector<std::pair<int, cv::Mat>>>* p_image_sync_queue_;
#else
SyncQueue<std::pair<int, cv::Mat> >* p_image_queue_;
#endif
@ -183,19 +183,19 @@ public:
#elif defined ONE_TIME_SHIFT
if (
p_shooted_queue_->count() > 0
#if defined DOUBLE_FEED_BACK
|| p_double_queue_->count() >0
#endif
#if defined DOUBLE_FEED_BACK
|| p_double_queue_->count() > 0
#endif
)
{
if (p_shooted_queue_->count() > 0){
if (p_shooted_queue_->count() > 0) {
bool temp;
p_shooted_queue_->take(temp);
}
pCaptureThreadBasler->m_threadFunc.SendFeedBack(EdgeEvent);
}
#else
if(p_unit_queue_->count() > 0){
if (p_unit_queue_->count() > 0) {
int unit_count = p_unit_queue_->count();
cv::Mat long_image;
for (int i = 0; i < unit_count; i++)
@ -214,13 +214,13 @@ public:
p_shooted_queue_->put(true);
p_unit_queue_->clear();
}
if(p_result_wait_queue_->count() > 0)
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)
if (p_shooted_queue_->count() > 0)
{
bool temp;
p_shooted_queue_->take(temp);
@ -241,9 +241,9 @@ public:
#elif defined ONE_TIME_SHIFT
if (
p_shooted_queue_->count() > 0
#if defined DOUBLE_FEED_BACK
|| p_double_queue_->count() >0
#endif
#if defined DOUBLE_FEED_BACK
|| p_double_queue_->count() > 0
#endif
)
{
bool temp;
@ -251,13 +251,13 @@ public:
pCaptureThreadBasler->m_threadFunc.SendFeedBack(EdgeEvent);
}
#else
if(p_result_wait_queue_->count() > 0)
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)
if (p_shooted_queue_->count() > 0)
{
bool temp;
p_shooted_queue_->take(temp);
@ -315,13 +315,13 @@ class CSampleImageEventHandler : public Pylon::CBaslerUniversalImageEventHandler
public:
ASyncQueue<cv::Mat>* p_unit_queue_;
#ifdef SYNC_CAMERA
ImageSyncArr *p_image_sync_arr_;
SyncQueue<std::vector<std::pair<int, cv::Mat>>> *p_image_sync_queue_;
ImageSyncArr* p_image_sync_arr_;
SyncQueue<std::vector<std::pair<int, cv::Mat>>>* p_image_sync_queue_;
#else
SyncQueue<std::pair<int, cv::Mat> >* p_image_queue_;
#endif
SyncQueue<cv::Mat>* p_debug_queue_;
ASyncQueue<bool> *p_shooted_queue_;
ASyncQueue<bool>* p_shooted_queue_;
Pylon::CBaslerUniversalInstantCamera* pDev__;
uint64_t* m_cntGrabbedImages_;
int Shoot_Num_;
@ -347,7 +347,7 @@ public:
if (!g_debug_mode)
{
#ifdef IMM_PROCESS
p_image_queue_->put(std::make_pair(1,image_clone));
p_image_queue_->put(std::make_pair(1, image_clone));
#else
p_unit_queue_->put(image_clone);
#endif

65
Cigarette/CaptureThreadHIK.cpp
Unescape Escape View File

@ -4,24 +4,24 @@
#include "common.h"
#include <windows.h>
#include "exportData.h"
extern bool g_debug_mode; //相机调试模式，工作模式必须停止状态才能打开
extern bool g_debug_mode; //相机调试模式，工作模式必须停止状态才能打开
extern SingleCamInfoStruct SingleCamInfo[NumberOfSupportedCameras];
extern SyncQueue<_XMLExportDataInfo>* export_XMLData_Info_queue;
extern PLCDevice* m_PLCDevice;
extern int work_camera_nums;
inline void LossCallBackfunction(unsigned int pData, void* pUser){
try{
inline void LossCallBackfunction(unsigned int pData, void* pUser) {
try {
CaptureThreadHIK* CaptureThreadHIKptr = (CaptureThreadHIK*)pUser;
SingleCamInfo[CaptureThreadHIKptr->Local_Num].OffLine = true;
CaptureThreadHIKptr->terminate();
}
catch(...){
catch (...) {
std::cout << "LossCallBackfunction error" << std::endl;
}
}
inline void FallingGpioEventfunction(MV_EVENT_OUT_INFO* pEventInfo, void* pUser){
try{
inline void FallingGpioEventfunction(MV_EVENT_OUT_INFO* pEventInfo, void* pUser) {
try {
CaptureThreadHIK* CaptureThreadHIKptr = (CaptureThreadHIK*)pUser;
int unit_count = CaptureThreadHIKptr->p_unit_queue->count();
if (unit_count > 0)
@ -48,6 +48,7 @@ inline void FallingGpioEventfunction(MV_EVENT_OUT_INFO* pEventInfo, void* pUser)
{
CaptureThreadHIKptr->p_image_sync_queue->put(CaptureThreadHIKptr->p_image_sync_arr->image_sync_arr);
CaptureThreadHIKptr->p_image_sync_arr->collect_cnt = 0;
//CaptureThreadHIKptr->p_image_sync_arr->image_sync_arr.swap(std::vector<std::pair<int, cv::Mat>>());
}
}
#else
@ -57,12 +58,20 @@ inline void FallingGpioEventfunction(MV_EVENT_OUT_INFO* pEventInfo, void* pUser)
}
CaptureThreadHIKptr->p_unit_queue->clear();
}
catch(...){
std::cout << "FallingGpioEventfunction error" << std::endl;
catch (...) {
//std::cout << "FallingGpioEventfunction error" << std::endl;
std::exception_ptr p = std::current_exception();
try {
if (p)
std::rethrow_exception(p);
}
catch (const std::exception& e) {
qDebug() << "Caught an exception: " << e.what();
}
}
}
inline void RisingGpioEventfunction(MV_EVENT_OUT_INFO* pEventInfo, void* pUser){
try{
inline void RisingGpioEventfunction(MV_EVENT_OUT_INFO* pEventInfo, void* pUser) {
try {
CaptureThreadHIK* CaptureThreadHIKptr = (CaptureThreadHIK*)pUser;
#ifdef IMM_FEED_BACK
if (CaptureThreadHIKptr->p_shooted_queue->count() > 0)
@ -72,27 +81,27 @@ inline void RisingGpioEventfunction(MV_EVENT_OUT_INFO* pEventInfo, void* pUser){
}
#elif defined ONE_TIME_SHIFT
if(
if (
CaptureThreadHIKptr->p_shooted_queue->count() > 0
#if defined DOUBLE_FEED_BACK
#if defined DOUBLE_FEED_BACK
|| CaptureThreadHIKptr->p_double_queue->count() > 0
#endif
#endif
)
{
if (CaptureThreadHIKptr->p_shooted_queue->count() > 0){
if (CaptureThreadHIKptr->p_shooted_queue->count() > 0) {
bool temp;
CaptureThreadHIKptr->p_shooted_queue->take(temp);
}
CaptureThreadHIKptr->m_threadFunc.SendFeedBack(EdgeEvent);
}
#else
if(CaptureThreadHIKptr->p_result_wait_queue->count() > 0)
if (CaptureThreadHIKptr->p_result_wait_queue->count() > 0)
{
bool temp;
CaptureThreadHIKptr->p_result_wait_queue->take(temp);
CaptureThreadHIKptr->m_threadFunc.SendFeedBack(EdgeEvent);
}
if(CaptureThreadHIKptr->p_shooted_queue->count() > 0)
if (CaptureThreadHIKptr->p_shooted_queue->count() > 0)
{
bool temp;
CaptureThreadHIKptr->p_shooted_queue->take(temp);
@ -100,7 +109,7 @@ inline void RisingGpioEventfunction(MV_EVENT_OUT_INFO* pEventInfo, void* pUser){
}
#endif
}
catch(...){
catch (...) {
std::cout << "RisingGpioEventfunction error" << std::endl;
}
}
@ -221,9 +230,9 @@ void CaptureThreadHIK::fpsTimeout(void)
}
//-----------------------------------------------------------------------------
CaptureThreadHIK::CaptureThreadHIK(void *camhandle, bool boTerminated,int Num) :
CamHandle( camhandle ), boTerminated_( boTerminated ),Local_Num(Num)
//-----------------------------------------------------------------------------
CaptureThreadHIK::CaptureThreadHIK(void* camhandle, bool boTerminated, int Num) :
CamHandle(camhandle), boTerminated_(boTerminated), Local_Num(Num)
//-----------------------------------------------------------------------------
{
p_unit_queue = new ASyncQueue<cv::Mat>(Unit_Queue_Size);
g_pImage_buf = (unsigned char*)malloc(3000 * 3000 * 3);
@ -234,7 +243,7 @@ CaptureThreadHIK::~CaptureThreadHIK()
free(g_pImage_buf);
}
//-----------------------------------------------------------------------------
void CaptureThreadHIK::process( void )
void CaptureThreadHIK::process(void)
//-----------------------------------------------------------------------------
{
try {
@ -247,7 +256,7 @@ void CaptureThreadHIK::process( void )
nRet = MV_CC_RegisterExceptionCallBack(CamHandle, LossCallBack[Local_Num], this);
if (nRet) { std::cout << "can not register loss callback" << std::endl; nnRet = nRet; }
//#ifdef IMM_FEED_BACK ///不打开无反馈等( 延后一次两次用ifndef // 不延后用ifdef)
//#ifdef IMM_FEED_BACK ///不打开无反馈等( 延后一次两次用ifndef // 不延后用ifdef)
nRet = MV_CC_SetEnumValueByString(CamHandle, "EventSelector", "Line0FallingEdge");
if (nRet) { std::cout << "can not set EventSelector" << std::endl; nnRet = nRet; }
@ -265,7 +274,7 @@ void CaptureThreadHIK::process( void )
nRet = MV_CC_RegisterEventCallBackEx(CamHandle, "Line0RisingEdge", RisingGpioEvent[Local_Num], this);
if (nRet) { std::cout << "can not register GPIO callback" << std::endl; nnRet = nRet; }
//#endif
//#endif
m_Timer = new QTimer();
connect(m_Timer, SIGNAL(timeout()), this, SLOT(fpsTimeout()));
@ -275,10 +284,10 @@ void CaptureThreadHIK::process( void )
MVCC_INTVALUE_EX stIntValue = { 0 };
nRet = MV_CC_GetIntValueEx(CamHandle, "PayloadSize", &stIntValue);
if (nRet) { std::cout << "Get PayloadSize error" << std::endl; }
nDataSize = stIntValue.nCurValue*3;///
nDataSize = stIntValue.nCurValue * 3;///
MV_CC_StartGrabbing(CamHandle);
Ready = true;
while(!boTerminated_)
while (!boTerminated_)
{
//nRet = MV_CC_GetOneFrameTimeout(CamHandle, g_pImage_buf, nDataSize, &stFrameInfo, 200);
nRet = MV_CC_GetImageForBGR(CamHandle, g_pImage_buf, nDataSize, &stFrameInfo, 100);
@ -291,14 +300,14 @@ void CaptureThreadHIK::process( void )
if (!g_debug_mode)
{
#ifdef IMM_PROCESS
p_image_queue->put(std::make_pair(1,image_clone));
p_image_queue->put(std::make_pair(1, image_clone));
#else
p_unit_queue->put(image_clone); //放入临时队列
p_unit_queue->put(image_clone); //放入临时队列
#endif
}
else
{
p_debug_queue->put(image_clone); //放入调试队列
p_debug_queue->put(image_clone); //放入调试队列
}
}
#if defined (IMM_FEED_BACK) || defined (CAP_FEED_BACK)

50
Cigarette/CaptureThreadHIK.h
Unescape Escape View File

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

4
Cigarette/Cigarette.vcxproj
Unescape Escape View File

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

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

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

2
Cigarette/Cleanthread.cpp
Unescape Escape View File

@ -62,7 +62,7 @@ void CleanWorkThread::doWork()
CleanImageFile(dir, delDays--);
//调用函数获取磁盘参数(单位为字节Byte),转化为GB，需要除以(1024*1024*1024)
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;
//delDays = g_sys_conf.save_days;
while ((spaceSize < 1) && (delDays > 1)) { //磁盘剩余空间小于百分之十

28
Cigarette/FtpManager.h
Unescape Escape View File

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

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

@ -7,7 +7,7 @@
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)
{
@ -37,7 +37,7 @@ bool PLCDevice::init_plc(PLCDevice* PLCptr)
bool PLCDevice::disconnect_plc(void)
{
if(g_modbus)
if (g_modbus)
{
modbus_close(g_modbus);
modbus_free(g_modbus);
@ -61,12 +61,12 @@ int PLCDevice::write_bit_2_plc(int addr, int value)
}
}
int PLCDevice::read_bits_from_plc(int addr, int nb,uint8_t* value)
int PLCDevice::read_bits_from_plc(int addr, int nb, uint8_t* value)
{
if (g_plc_ok)
{
g_mutex.lock();
int ret = modbus_read_bits(g_modbus, addr, nb ,value);
int ret = modbus_read_bits(g_modbus, addr, nb, value);
g_mutex.unlock();
//printf("modbus_read_bits:addr=%d,nb=%d,value=%d,ret=%d\n", addr, nb, *value, ret);
return ret;
@ -77,7 +77,7 @@ int PLCDevice::read_bits_from_plc(int addr, int nb,uint8_t* value)
}
}
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)
{
@ -93,7 +93,7 @@ int PLCDevice::write_short_2_plc(int addr, int nb, uint16_t *value)
}
}
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)
{

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

@ -10,11 +10,11 @@ public:
//[0]:1=连接,0=断开
uint8_t g_plc_status;
static bool init_plc(PLCDevice *PLCptr);
static bool init_plc(PLCDevice* PLCptr);
int write_bit_2_plc(int addr, int value);
int read_bits_from_plc(int addr, int nb, uint8_t* value);
int write_short_2_plc(int addr, int nb, uint16_t *value);
int read_short_from_plc(int addr, int nb, uint16_t *value);
int write_short_2_plc(int addr, int nb, uint16_t* value);
int read_short_from_plc(int addr, int nb, uint16_t* value);
bool disconnect_plc(void);
};

2
Cigarette/alarmdialog.cpp
Unescape Escape View File

@ -3,7 +3,7 @@
extern std::vector<AlarmInfo> g_vec_alarm;
AlarmDialog::AlarmDialog(QWidget * parent) : QDialog(parent) {
AlarmDialog::AlarmDialog(QWidget* parent) : QDialog(parent) {
ui.setupUi(this);
this->setWindowFlags(Qt::FramelessWindowHint);
ui.tableWidget->setColumnCount(4);

4
Cigarette/alarmdialog.hpp
Unescape Escape View File

@ -1,4 +1,4 @@
#pragma once
#pragma once
#include <QDialog>
#include "ui_alarmdialog.h"
@ -6,7 +6,7 @@ class AlarmDialog : public QDialog {
Q_OBJECT
public:
AlarmDialog(QWidget * parent = Q_NULLPTR);
AlarmDialog(QWidget* parent = Q_NULLPTR);
~AlarmDialog();
private slots:

54
Cigarette/alg_jd.cpp
Unescape Escape View File

@ -1,10 +1,10 @@
#include "alg_jd.h"
#include <direct.h> //所需的库文件
#include <direct.h> //所需的库文件
extern SysConf g_sys_conf;
// Initialize the parameters
static float confThreshold = g_sys_conf.ConfThreshold*0.01; // Confidence threshold
static float confThreshold = g_sys_conf.ConfThreshold * 0.01; // Confidence threshold
static float nmsThreshold = 0.4; // Non-maximum suppression threshold
static int inpWidth = 416; // Width of network's input image
static int inpHeight = 416; // Height of network's input image
@ -20,7 +20,7 @@ bool AlgJd::init(QString model_path, QString model_name)
QString image_path;
if (model_path.length() > 0 && model_name.length() > 0) {
// 拼凑的模型文件路径
// 拼凑的模型文件路径
modelWeights = model_path.toStdString() + "/" + model_name.toStdString();
modelConfiguration = model_path.toStdString() + "/jd.cfg";
classesFile = model_path.toStdString() + "/jd.names";
@ -41,7 +41,7 @@ bool AlgJd::init(QString model_path, QString model_name)
while (std::getline(classNamesFile, className))
classes.push_back(className);
}
else{
else {
return false;
}
@ -60,14 +60,14 @@ bool AlgJd::init(QString model_path, QString model_name)
image = cv::imread("D:/Release/alg_jd.bmp");
}*/
//识别一张图，测试模型是否正确，并且完成GPU数据加载
if (!image.data) return false; //判断测试图片是否正常读取
//识别一张图，测试模型是否正确，并且完成GPU数据加载
if (!image.data) return false; //判断测试图片是否正常读取
std::vector<std::pair<int, cv::Rect> > results;
detect(image, image, results);
if (results.size() > 0)
return true; //检测到目标，则初始化成功
return true; //检测到目标，则初始化成功
else
return false; //否则初始化失败
return false; //否则初始化失败
}
bool AlgJd::test_detect()
@ -95,8 +95,8 @@ bool AlgJd::test_detect_batcht(int shoot)
m4 = cv::Mat(544, 728, CV_8UC3, cv::Scalar(0, 0, 0));
double t = (double)cv::getTickCount();
switch(shoot){
case 1:{
switch (shoot) {
case 1: {
std::vector<std::pair<int, cv::Rect> > results;
detect(m1, m1, results);
break;
@ -104,7 +104,7 @@ bool AlgJd::test_detect_batcht(int shoot)
case 3:vec_in.push_back(m3);
case 2:vec_in.push_back(m2);
case 4:vec_in.push_back(m4);
default:{
default: {
vec_in.push_back(m1);
detect_batch(vec_in, vec_out, vec_results);
}
@ -114,14 +114,14 @@ bool AlgJd::test_detect_batcht(int shoot)
return true;
}
int AlgJd::detect(cv::Mat& _frame, cv::Mat &out, std::vector<std::pair<int, cv::Rect> > &results)
int AlgJd::detect(cv::Mat& _frame, cv::Mat& out, std::vector<std::pair<int, cv::Rect> >& results)
{
cv::Mat frame = _frame.clone();
cv::Mat image_clone=frame.clone();
cv::Mat image_clone = frame.clone();
// Process frames.
// Create a 4D blob from a frame.
cv::Mat blob;
cv::dnn::blobFromImage(frame, blob, 1/255.0, cv::Size(inpWidth, inpHeight), cv::Scalar(0,0,0), true, false);
cv::dnn::blobFromImage(frame, blob, 1 / 255.0, cv::Size(inpWidth, inpHeight), cv::Scalar(0, 0, 0), true, false);
//Sets the input to the network
net.setInput(blob);
@ -140,7 +140,7 @@ int AlgJd::detect(cv::Mat& _frame, cv::Mat &out, std::vector<std::pair<int, cv::
cv::Mat detectedFrame;
frame.convertTo(detectedFrame, CV_8U);
//show detectedFrame
out=detectedFrame.clone();
out = detectedFrame.clone();
return results.size();
}
@ -178,7 +178,7 @@ std::vector<cv::String> AlgJd::getOutputsNames(const cv::dnn::Net& net)
return names;
}
void AlgJd::post_process(cv::Mat& frame, std::vector<cv::Mat>& outs, std::vector<std::pair<int, cv::Rect> > &results)
void AlgJd::post_process(cv::Mat& frame, std::vector<cv::Mat>& outs, std::vector<std::pair<int, cv::Rect> >& results)
{
std::vector < std::vector<int>> classIds(classes.size());
std::vector < std::vector<float>> confidences(classes.size());
@ -236,17 +236,17 @@ void AlgJd::post_process(cv::Mat& frame, std::vector<cv::Mat>& outs, std::vector
void AlgJd::drawPred(int classId, float conf, int left, int top, int right, int bottom, cv::Mat& frame)
{
cv::Scalar color;
if(classId==0)
color = cv::Scalar(0,255,0);
else if(classId == 1)
color = cv::Scalar(255,0,0);
if (classId == 0)
color = cv::Scalar(0, 255, 0);
else if (classId == 1)
color = cv::Scalar(255, 0, 0);
else
color = cv::Scalar(0, 255, 0);
//Draw a rectangle displaying the bounding box
cv::rectangle(frame, cv::Point(left, top), cv::Point(right, bottom), color, 4);
//Get the label for the class name and its confidence
std::string label = cv::format("%.2f%%", (conf*100));///
std::string label = cv::format("%.2f%%", (conf * 100));///
if (!classes.empty())
{
CV_Assert(classId < (int)classes.size());
@ -254,17 +254,17 @@ void AlgJd::drawPred(int classId, float conf, int left, int top, int right, int
}
else
{
std::cout<<"classes is empty..."<<std::endl;
std::cout << "classes is empty..." << std::endl;
}
//Display the label at the top of the bounding box
int baseLine;
cv::Size labelSize = cv::getTextSize(label, cv::FONT_HERSHEY_SIMPLEX, 1, 1, &baseLine);
top = std::max(top, labelSize.height);
cv::putText(frame, label, cv::Point(left, top-5), cv::FONT_HERSHEY_SIMPLEX, 0.8, color, 1);
cv::putText(frame, label, cv::Point(left, top - 5), cv::FONT_HERSHEY_SIMPLEX, 0.8, color, 1);
}
void AlgJd::detect_batch(std::vector<cv::Mat>& vec_in, std::vector<cv::Mat> &vec_out, std::vector<std::vector<std::pair<int, cv::Rect> > > &vec_results)
void AlgJd::detect_batch(std::vector<cv::Mat>& vec_in, std::vector<cv::Mat>& vec_out, std::vector<std::vector<std::pair<int, cv::Rect> > >& vec_results)
{
cv::Mat blobs;
std::vector<cv::Mat> image;
@ -297,7 +297,7 @@ void AlgJd::detect_batch(std::vector<cv::Mat>& vec_in, std::vector<cv::Mat> &vec
}
}
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();
double confidence;///
@ -356,10 +356,10 @@ void AlgJd::post_process_batch(std::vector<cv::Mat>& vec_frame, std::vector<cv::
{
int idx = indices[j];
cv::Rect box = boxes[i][idx];
if (confidences[i][idx] > g_sys_conf.ConfThreshold * 0.01)///识别度低于阈值NG处理
if (confidences[i][idx] > g_sys_conf.ConfThreshold * 0.01)///识别度低于阈值NG处理
{
if (box.width > 15)
{//识别框宽度大于15显示识别，小于认为无胶点，NG处理
{//识别框宽度大于15显示识别，小于认为无胶点，NG处理
drawPred(classIds[i][idx], confidences[i][idx], box.x, box.y,
box.x + box.width, box.y + box.height, vec_frame[k]);
results.push_back(std::make_pair(classIds[i][idx], box));

14
Cigarette/alg_jd.h
Unescape Escape View File

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

2
Cigarette/balluffcamera.cpp
Unescape Escape View File

@ -3,7 +3,7 @@
#include <iostream>
#include <thread>
mvIMPACT::acquire::DeviceManager BalluffCamera:: devMgr;
mvIMPACT::acquire::DeviceManager BalluffCamera::devMgr;
bool BalluffCamera::license_pass = false;
BalluffCamera::BalluffCamera()
{

2
Cigarette/balluffcamera.h
Unescape Escape View File

@ -6,7 +6,7 @@
#define BalluffClassID 0x01
class BalluffCamera: public BaseCamera
class BalluffCamera : public BaseCamera
{
public:
BalluffCamera();

14
Cigarette/baslercamera.h
Unescape Escape View File

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

30
Cigarette/camera_glue.cpp
Unescape Escape View File

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

4
Cigarette/camera_glue.h
Unescape Escape View File

@ -9,7 +9,7 @@ class camera_glue : public QDialog
Q_OBJECT
public:
camera_glue(QDialog *parent = Q_NULLPTR);
camera_glue(QDialog* parent = Q_NULLPTR);
~camera_glue();
signals:
void sendMsgToDialogSetup(int ptr[][3]);
@ -20,6 +20,6 @@ public slots:
private:
Ui::camera_glue ui;
QSpinBox *spinBox[NumberOfSupportedCameras][3];
QSpinBox* spinBox[NumberOfSupportedCameras][3];
SysConf local_SysConf;
};

6
Cigarette/change_shift.cpp
Unescape Escape View File

@ -3,11 +3,11 @@
#include <dialogsetup.hpp>
extern SysConf g_sys_conf;
change_shift::change_shift(QDialog *parent)
change_shift::change_shift(QDialog* parent)
: QDialog(parent)
{
ui.setupUi(this);
this->setWindowFlags(windowFlags()&~Qt::WindowContextHelpButtonHint);
this->setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
if (g_sys_conf.auto_shift == 1) {
ui.radioButton_auto->setChecked(true);
@ -38,7 +38,7 @@ void change_shift::on_pushButton_apply_released()
QTime timeA;
QTime timeB;
QTime timeC;
if (ui.radioButton_auto->isChecked()) { /// ÒÑÒþ²Ø
if (ui.radioButton_auto->isChecked()) { /// 已隐藏
g_sys_conf.auto_shift = 1;
g_sys_conf.timing_shift = 0;
g_sys_conf.shift_byhand = 0;

2
Cigarette/change_shift.h
Unescape Escape View File

@ -9,7 +9,7 @@ class change_shift : public QDialog
Q_OBJECT
public:
change_shift(QDialog *parent = Q_NULLPTR);
change_shift(QDialog* parent = Q_NULLPTR);
~change_shift();
private:

872
Cigarette/cigarette.cpp
View File

File diff suppressed because it is too large Load Diff

88
Cigarette/cigarette.h
Unescape Escape View File

@ -59,7 +59,7 @@ class Cigarette : public QMainWindow
Q_OBJECT
public:
Cigarette(QWidget *parent = 0);
Cigarette(QWidget* parent = 0);
~Cigarette();
static QImage cvMatToQImage(const cv::Mat& mat);
@ -67,23 +67,23 @@ public:
QString read_pswd();
QString read_op_pswd();
bool read_conf(ConfPath &conf_path);
bool read_sys_config(SysConf &conf, QString conf_path);
bool read_modbus_config(ModbusConf &conf);
bool read_conf(ConfPath& conf_path);
bool read_sys_config(SysConf& conf, QString conf_path);
bool read_modbus_config(ModbusConf& conf);
void read_plc_items();
bool save_rotate_message();
bool read_rotate_message();
bool save_alarm_message(std::vector<AlarmInfo> &AlarmInfo_vect);
bool save_alarm_message(std::vector<AlarmInfo>& AlarmInfo_vect);
void init_plc_value();
void CreatWorkThread(int classid,int Num,Cigarette* classptr);
void CreatWorkThread(int classid, int Num, Cigarette* classptr);
void InitPtrMat();
bool ControlCamOpenOrClose(int Num,bool OpenOrClose);
void EnumerateCameras(SingleCamInfoStruct *TempSingleCamInfo,bool showinfo,SysConf &conf);
bool ControlCamOpenOrClose(int Num, bool OpenOrClose);
void EnumerateCameras(SingleCamInfoStruct* TempSingleCamInfo, bool showinfo, SysConf& conf);
void start_work();
void pause_work();
void CleanThreadStart();
void Exit();
private slots :
private slots:
void on_btn_start_released();
void on_btn_pause_released();
//void on_btn_pause_clicked(bool checked);
@ -135,27 +135,27 @@ private slots :
#endif
private:
Ui::CigaretteClass ui;
DialogSetupPasswd *dialog_setup_passwd;
Dialogin *dialogin;
DialogSetup *dialog_setup;
PlcSetup * dialog_plc_setup;
DialogSetupPasswd* dialog_setup_passwd;
Dialogin* dialogin;
DialogSetup* dialog_setup;
PlcSetup* dialog_plc_setup;
std::vector<PlcItem> m_plc_items;
public:
QTimer *m_pTimer_Cam_mat[NumberOfSupportedCameras]; //相机重启定时器
QLabel *label_cap_speed_mat[NumberOfSupportedCameras];
QLabel *cam_status_mat[NumberOfSupportedCameras];
QLabel *cam_work_mat[NumberOfSupportedCameras];
QToolButton *cam_toolButton_mat[NumberOfSupportedCameras];
db_label * display_lable_mat[NumberOfSupportedCameras][2];
QLabel *label_timecost_mat[NumberOfSupportedCameras];
QLCDNumber *lcdNumber_total_mat[NumberOfSupportedCameras];
QLabel *label_jd_no_mat[NumberOfSupportedCameras];
QLCDNumber *lcdNumber_ok_mat[NumberOfSupportedCameras];
QLCDNumber *lcdNumber_ng_mat[NumberOfSupportedCameras];
QTimer* m_pTimer_Cam_mat[NumberOfSupportedCameras]; //相机重启定时器
QLabel* label_cap_speed_mat[NumberOfSupportedCameras];
QLabel* cam_status_mat[NumberOfSupportedCameras];
QLabel* cam_work_mat[NumberOfSupportedCameras];
QToolButton* cam_toolButton_mat[NumberOfSupportedCameras];
db_label* display_lable_mat[NumberOfSupportedCameras][2];
QLabel* label_timecost_mat[NumberOfSupportedCameras];
QLCDNumber* lcdNumber_total_mat[NumberOfSupportedCameras];
QLabel* label_jd_no_mat[NumberOfSupportedCameras];
QLCDNumber* lcdNumber_ok_mat[NumberOfSupportedCameras];
QLCDNumber* lcdNumber_ng_mat[NumberOfSupportedCameras];
QLCDNumber* lcdNumber_kick_mat[NumberOfSupportedCameras];
QLabel *label_reslut_mat[NumberOfSupportedCameras];
QToolButton *rotate_mat[NumberOfSupportedCameras];
QLabel *label_ng_mat[NumberOfSupportedCameras];
QLabel* label_reslut_mat[NumberOfSupportedCameras];
QToolButton* rotate_mat[NumberOfSupportedCameras];
QLabel* label_ng_mat[NumberOfSupportedCameras];
struct widget_info
{
@ -191,32 +191,32 @@ public:
SaveThread saveThread;
void record_output_statistic(qint64 cur_quantity, int Kick[NumberOfSupportedCameras], int shift);
QTimer *m_pTimer;
QTimer *m_delay; //换班防止连击
QTimer* m_pTimer;
QTimer* m_delay; //换班防止连击
QTimer* m_sendMsg_delay; // 停止工作后发送最新数据给远程端
QTimer *m_op_delay; //操作员权限剩余时间
QTimer *m_admin_delay; //操作员权限剩余时间
QTimer *clean_pTimer; //定时清理任务
QSignalMapper *image_lable_DBsignalMapper0;
QSignalMapper *image_lable_DBsignalMapper1;
QSignalMapper *image_lable_TPsignalMapper0;
QSignalMapper *image_lable_TPsignalMapper1;
QSignalMapper *label_ng_signalMapper;
QSignalMapper *pTimer_Cam_signalMapper;
QSignalMapper *toolButton_cam_signalMapper;
QSignalMapper *RotateReleased_signalMapper;
QTimer* m_op_delay; //操作员权限剩余时间
QTimer* m_admin_delay; //操作员权限剩余时间
QTimer* clean_pTimer; //定时清理任务
QSignalMapper* image_lable_DBsignalMapper0;
QSignalMapper* image_lable_DBsignalMapper1;
QSignalMapper* image_lable_TPsignalMapper0;
QSignalMapper* image_lable_TPsignalMapper1;
QSignalMapper* label_ng_signalMapper;
QSignalMapper* pTimer_Cam_signalMapper;
QSignalMapper* toolButton_cam_signalMapper;
QSignalMapper* RotateReleased_signalMapper;
int total_production_number;
int production_number[NumberOfSupportedCameras];
int OpenWithUserID[NumberOfSupportedCameras];
int ok[NumberOfSupportedCameras], ng[NumberOfSupportedCameras];
#ifdef __UDPSend
private:
private:
threadSend sThread;
threadReceive *rThread;
threadReceive* rThread;
#endif
#ifdef __TCPSend
private:
private:
threadSendTCP tcpSendThread;
#endif
public slots:

34
Cigarette/common.cpp
Unescape Escape View File

@ -7,17 +7,17 @@
#include <Commdlg.h>
#include <tchar.h>
int string_split(std::string str, std::string pattern,std::vector<std::string> &out)
int string_split(std::string str, std::string pattern, std::vector<std::string>& out)
{
std::string::size_type pos;
int cnt = 0;
str += pattern;
int size = str.size();
for (int i = 0; i<size; i++)
for (int i = 0; i < size; i++)
{
pos = str.find(pattern, i);
if (pos<size)
if (pos < size)
{
cnt++;
std::string s = str.substr(i, pos - i);
@ -28,7 +28,7 @@ int string_split(std::string str, std::string pattern,std::vector<std::string> &
return cnt;
}
std::string format(const char *pszFmt, ...)
std::string format(const char* pszFmt, ...)
{
std::string str;
va_list args;
@ -44,7 +44,7 @@ std::string format(const char *pszFmt, ...)
return str;
}
void DrawSelectRects(cv::Mat input,DisplayLabelConf &t_DisplayLabelConf,int Cnt)
void DrawSelectRects(cv::Mat input, DisplayLabelConf& t_DisplayLabelConf, int Cnt)
{
if (t_DisplayLabelConf.Flag[Cnt] & DisplayLabel_Type_Bit) {
if (t_DisplayLabelConf.leftButtonDownFlag) {
@ -76,9 +76,9 @@ 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,
std::vector<std::vector<std::pair<int, cv::Rect> > >& VecRects,
int VecCnt,
DisplayLabelConf &t_DisplayLabelConf,
DisplayLabelConf& t_DisplayLabelConf,
int LabelCnt
)
{
@ -92,27 +92,27 @@ bool CheckSelectRects(
for (int i = 0; i < VecRects[VecCnt].size(); i++)
{
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 CheckRect = cv::Rect(
cv::Point(
t_DisplayLabelConf.RectVet[LabelCnt][j].TL.x* input.cols,
t_DisplayLabelConf.RectVet[LabelCnt][j].TL.y* input.rows
t_DisplayLabelConf.RectVet[LabelCnt][j].TL.x * input.cols,
t_DisplayLabelConf.RectVet[LabelCnt][j].TL.y * input.rows
),
cv::Point(
t_DisplayLabelConf.RectVet[LabelCnt][j].BR.x* input.cols,
t_DisplayLabelConf.RectVet[LabelCnt][j].BR.y* input.rows
t_DisplayLabelConf.RectVet[LabelCnt][j].BR.x * input.cols,
t_DisplayLabelConf.RectVet[LabelCnt][j].BR.y * input.rows
)
);
cv::Rect tempRect = (LocalRect & CheckRect);
if(LocalRect == tempRect)
if (LocalRect == tempRect)
{
find = true;
}
}
if(!find)
if (!find)
{
return true;
}
@ -183,7 +183,7 @@ void pathConvert_Double2Single(std::string& s) {
while (start < s.length()) {
int pos = s.find('\\', start);
if (pos == -1)break;
s.replace(pos, 1,"/");
s.replace(pos, 1, "/");
start = pos + 1;
}
}
@ -348,7 +348,7 @@ std::string SelectDirIFD()
// We are just going to print out the
// name of the file for sample sake.
PWSTR pszFilePath = NULL;
hr = psiResult->GetDisplayName(SIGDN_FILESYSPATH,&pszFilePath);
hr = psiResult->GetDisplayName(SIGDN_FILESYSPATH, &pszFilePath);
if (SUCCEEDED(hr))
{
folderpath = LPWSTR2LPSTR(pszFilePath);
@ -367,7 +367,7 @@ std::string SelectDirIFD()
std::string UTF8ToGBK(std::string utf8_str) {
// 获得临时变量的大小
int wchar_len = MultiByteToWideChar(CP_UTF8, 0, utf8_str.c_str(), -1, NULL, 0);
wchar_t *wchar_buf = new wchar_t[wchar_len];
wchar_t* wchar_buf = new wchar_t[wchar_len];
MultiByteToWideChar(CP_UTF8, 0, utf8_str.c_str(), -1, wchar_buf, wchar_len);
// 获得临时变量的大小

198
Cigarette/common.h
Unescape Escape View File

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

6
Cigarette/db_label.cpp
Unescape Escape View File

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

4
Cigarette/db_label.h
Unescape Escape View File

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

15
Cigarette/debugthread.h
Unescape Escape View File

@ -11,19 +11,18 @@
#include "balluffcamera.h"
#include "hikcamera.h"
extern SyncQueue<cv::Mat> *g_debug_queue[NumberOfSupportedCameras]; //相机调试模式图像队列
extern SyncQueue<cv::Mat>* g_debug_queue[NumberOfSupportedCameras]; //相机调试模式图像队列
extern DisplayLabelConf g_display_label_conf[NumberOfSupportedCameras];
extern SingleCamInfoStruct SingleCamInfo[NumberOfSupportedCameras];
extern int rotationAngle[NumberOfSupportedCameras]; //图片旋转角度
extern bool isNeedRotate[NumberOfSupportedCameras];
class DebugThread : public QThread
{
Q_OBJECT
signals:
void notify(int Num,int Cnt,cv::Mat);
void notify(int Num, int Cnt, cv::Mat);
public:
DebugThread(QObject *parent = 0): QThread(parent)
DebugThread(QObject* parent = 0) : QThread(parent)
{
}
@ -34,7 +33,7 @@ public:
quit();
wait();
}
void init(SyncQueue<cv::Mat> *ptr,int Num)
void init(SyncQueue<cv::Mat>* ptr, int Num)
{
local_camera_number = Num;
b_quit = false;
@ -63,13 +62,13 @@ protected:
cv::cvtColor(image, image, CV_BGR2RGB); //灰度图像转为彩色图像
}
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(image, image, rotationAngle[local_camera_number]);
}
}
//sleep(100);
emit notify(local_camera_number,0,image);
emit notify(local_camera_number, 0, image);
}
#ifdef DRAW_RECT
std::lock_guard<std::mutex> locker2(g_display_label_conf[local_camera_number].lock);
@ -89,7 +88,7 @@ public:
int local_camera_number;
int local_classid;
bool b_quit;
SyncQueue<cv::Mat> *p_debug_queue;
SyncQueue<cv::Mat>* p_debug_queue;
DisplayLabelConf local_DisplayLabelConf;
};

7
Cigarette/dialogin.cpp
Unescape Escape View File

@ -1,16 +1,13 @@
#include "dialogin.hpp"
#include "dialogin.hpp"
#include <QCryptographicHash>
#include <qdebug.h>
#include <qmessagebox.h>
extern bool g_op_mode; //是否操作员模式
extern QString g_op_pswd; //操作员密码
Dialogin::Dialogin(QWidget * parent) : QDialog(parent) {
Dialogin::Dialogin(QWidget* parent) : QDialog(parent) {
ui.setupUi(this);
m_pswd = "";
this->setWindowFlags(Qt::FramelessWindowHint);

8
Cigarette/dialogin.hpp
Unescape Escape View File

@ -1,17 +1,17 @@
#pragma once
#pragma once
#include <QDialog>
#include "ui_dialogin.h"
class Dialogin : public QDialog {
Q_OBJECT
signals :
signals:
void enter_op();
public:
Dialogin(QWidget * parent = Q_NULLPTR);
Dialogin(QWidget* parent = Q_NULLPTR);
~Dialogin();
private slots :
private slots:
void on_pushButton_close_released();
void on_pushButton_clr_released();
void on_pushButton_ok_released();

44
Cigarette/dialogsetup.cpp
Unescape Escape View File

@ -26,12 +26,12 @@ void task_osk()
system("start /b C:\\Windows\\system32\\osk.exe");
}
DialogSetup::DialogSetup(QWidget * parent) : QDialog(parent) {
DialogSetup::DialogSetup(QWidget* parent) : QDialog(parent) {
ui.setupUi(this);
InitPtrMat();
this->setWindowFlags(Qt::FramelessWindowHint);//窗口可移动
for(int i=0;i<NumberOfSupportedCameras;i++)
for (int i = 0; i < NumberOfSupportedCameras; i++)
{
lineEdit_expo_mat[i]->setValidator(new QIntValidator(0, 1000000, this));
lineEdit_expo_mat[i]->setText(QString::number(g_sys_conf.expo[i]));
@ -120,7 +120,7 @@ DialogSetup::DialogSetup(QWidget * parent) : QDialog(parent) {
}
else {
QString dirPath = "D:/image";
QDir *dirinfo = new QDir(dirPath);
QDir* dirinfo = new QDir(dirPath);
if (!dirinfo->exists())
delete dirinfo, dirinfo = nullptr;
//ui.comboBox_save_pics_path->clear();
@ -194,8 +194,8 @@ void DialogSetup::on_pushButton_exit_released()
void DialogSetup::on_pushButton_desktop_released()
{
CoInitialize(0);
IShellDispatch4 * pdisp = NULL;
CoCreateInstance(CLSID_Shell, NULL, CLSCTX_ALL, __uuidof(IShellDispatch4), (void **)&pdisp);
IShellDispatch4* pdisp = NULL;
CoCreateInstance(CLSID_Shell, NULL, CLSCTX_ALL, __uuidof(IShellDispatch4), (void**)&pdisp);
pdisp->ToggleDesktop(); // 这句是用来切换桌面的
pdisp->Release();
CoUninitialize();
@ -203,7 +203,7 @@ void DialogSetup::on_pushButton_desktop_released()
void DialogSetup::on_pushButton_expo_released()
{
for(int i=0;i<NumberOfSupportedCameras;i++)
for (int i = 0; i < NumberOfSupportedCameras; i++)
{
g_sys_conf.expo[i] = (lineEdit_expo_mat[i]->text()).toInt();
g_sys_conf.gain[i] = (lineEdit_gain_mat[i]->text()).toInt();
@ -237,7 +237,7 @@ void DialogSetup::on_checkBox_auto_work_clicked(bool checked)
void DialogSetup::on_pushButton_filter_released()
{
for(int i=0;i<NumberOfSupportedCameras;i++)
for (int i = 0; i < NumberOfSupportedCameras; i++)
{
g_sys_conf.filter[i] = (lineEdit_filter_mat[i]->text()).toInt();
}
@ -318,7 +318,7 @@ void DialogSetup::on_pushButton_save_released()
{
g_sys_conf.save = 2;
}
for(int i=0;i<NumberOfSupportedCameras;i++)
for (int i = 0; i < NumberOfSupportedCameras; i++)
{
g_sys_conf.expo[i] = (lineEdit_expo_mat[i]->text()).toInt();
g_sys_conf.gain[i] = (lineEdit_gain_mat[i]->text()).toInt();
@ -590,7 +590,7 @@ void DialogSetup::write_config()
sprintf(buf, "USERID1=%d\n", g_sys_conf.UserID[0]);
cfg_file.write(buf, strlen(buf));
memset(buf, 0, 256);
sprintf(buf, "NO1=%d|%d|%d\n", g_sys_conf.no[0][0],g_sys_conf.no[0][1],g_sys_conf.no[0][2]);
sprintf(buf, "NO1=%d|%d|%d\n", g_sys_conf.no[0][0], g_sys_conf.no[0][1], g_sys_conf.no[0][2]);
cfg_file.write(buf, strlen(buf));
memset(buf, 0, 256);
sprintf(buf, "SHOOT1=%d\n", g_sys_conf.shoot[0]);
@ -612,7 +612,7 @@ void DialogSetup::write_config()
sprintf(buf, "USERID2=%d\n", g_sys_conf.UserID[1]);
cfg_file.write(buf, strlen(buf));
memset(buf, 0, 256);
sprintf(buf, "NO2=%d|%d|%d\n", g_sys_conf.no[1][0],g_sys_conf.no[1][1],g_sys_conf.no[1][2]);
sprintf(buf, "NO2=%d|%d|%d\n", g_sys_conf.no[1][0], g_sys_conf.no[1][1], g_sys_conf.no[1][2]);
cfg_file.write(buf, strlen(buf));
memset(buf, 0, 256);
sprintf(buf, "SHOOT2=%d\n", g_sys_conf.shoot[1]);
@ -634,7 +634,7 @@ void DialogSetup::write_config()
sprintf(buf, "USERID3=%d\n", g_sys_conf.UserID[2]);
cfg_file.write(buf, strlen(buf));
memset(buf, 0, 256);
sprintf(buf, "NO3=%d|%d|%d\n", g_sys_conf.no[2][0],g_sys_conf.no[2][1],g_sys_conf.no[2][2]);
sprintf(buf, "NO3=%d|%d|%d\n", g_sys_conf.no[2][0], g_sys_conf.no[2][1], g_sys_conf.no[2][2]);
cfg_file.write(buf, strlen(buf));
memset(buf, 0, 256);
sprintf(buf, "SHOOT3=%d\n", g_sys_conf.shoot[2]);
@ -656,7 +656,7 @@ void DialogSetup::write_config()
sprintf(buf, "USERID4=%d\n", g_sys_conf.UserID[3]);
cfg_file.write(buf, strlen(buf));
memset(buf, 0, 256);
sprintf(buf, "NO4=%d|%d|%d\n", g_sys_conf.no[3][0],g_sys_conf.no[3][1],g_sys_conf.no[3][2]);
sprintf(buf, "NO4=%d|%d|%d\n", g_sys_conf.no[3][0], g_sys_conf.no[3][1], g_sys_conf.no[3][2]);
cfg_file.write(buf, strlen(buf));
memset(buf, 0, 256);
sprintf(buf, "SHOOT4=%d\n", g_sys_conf.shoot[3]);
@ -678,7 +678,7 @@ void DialogSetup::write_config()
sprintf(buf, "USERID5=%d\n", g_sys_conf.UserID[4]);
cfg_file.write(buf, strlen(buf));
memset(buf, 0, 256);
sprintf(buf, "NO5=%d|%d|%d\n", g_sys_conf.no[4][0],g_sys_conf.no[4][1],g_sys_conf.no[4][2]);
sprintf(buf, "NO5=%d|%d|%d\n", g_sys_conf.no[4][0], g_sys_conf.no[4][1], g_sys_conf.no[4][2]);
cfg_file.write(buf, strlen(buf));
memset(buf, 0, 256);
sprintf(buf, "SHOOT5=%d\n", g_sys_conf.shoot[4]);
@ -700,7 +700,7 @@ void DialogSetup::write_config()
sprintf(buf, "USERID6=%d\n", g_sys_conf.UserID[5]);
cfg_file.write(buf, strlen(buf));
memset(buf, 0, 256);
sprintf(buf, "NO6=%d|%d|%d\n", g_sys_conf.no[5][0],g_sys_conf.no[5][1],g_sys_conf.no[5][2]);
sprintf(buf, "NO6=%d|%d|%d\n", g_sys_conf.no[5][0], g_sys_conf.no[5][1], g_sys_conf.no[5][2]);
cfg_file.write(buf, strlen(buf));
memset(buf, 0, 256);
sprintf(buf, "SHOOT6=%d\n", g_sys_conf.shoot[5]);
@ -722,7 +722,7 @@ void DialogSetup::write_config()
sprintf(buf, "USERID7=%d\n", g_sys_conf.UserID[6]);
cfg_file.write(buf, strlen(buf));
memset(buf, 0, 256);
sprintf(buf, "NO7=%d|%d|%d\n", g_sys_conf.no[6][0],g_sys_conf.no[6][1],g_sys_conf.no[6][2]);
sprintf(buf, "NO7=%d|%d|%d\n", g_sys_conf.no[6][0], g_sys_conf.no[6][1], g_sys_conf.no[6][2]);
cfg_file.write(buf, strlen(buf));
memset(buf, 0, 256);
sprintf(buf, "SHOOT7=%d\n", g_sys_conf.shoot[6]);
@ -744,7 +744,7 @@ void DialogSetup::write_config()
sprintf(buf, "USERID8=%d\n", g_sys_conf.UserID[7]);
cfg_file.write(buf, strlen(buf));
memset(buf, 0, 256);
sprintf(buf, "NO8=%d|%d|%d\n", g_sys_conf.no[7][0],g_sys_conf.no[7][1],g_sys_conf.no[7][2]);
sprintf(buf, "NO8=%d|%d|%d\n", g_sys_conf.no[7][0], g_sys_conf.no[7][1], g_sys_conf.no[7][2]);
cfg_file.write(buf, strlen(buf));
memset(buf, 0, 256);
sprintf(buf, "SHOOT8=%d\n", g_sys_conf.shoot[7]);
@ -801,17 +801,17 @@ void DialogSetup::on_pushButton_config_released()
{
if (m_camera_glue)delete m_camera_glue;
m_camera_glue = new camera_glue(this);
connect(m_camera_glue, &camera_glue::sendMsgToDialogSetup,this, &DialogSetup::recMsgFromDialogConfig);
connect(this, &DialogSetup::sendMsgToConfig,m_camera_glue, &camera_glue::recMsgFromDialogSetup);
connect(m_camera_glue, &camera_glue::sendMsgToDialogSetup, this, &DialogSetup::recMsgFromDialogConfig);
connect(this, &DialogSetup::sendMsgToConfig, m_camera_glue, &camera_glue::recMsgFromDialogSetup);
m_camera_glue->show();
m_camera_glue->move(this->geometry().center() - m_camera_glue->rect().center());//移动父窗口中心位置
emit sendMsgToConfig(g_sys_conf.no);
}
void DialogSetup::recMsgFromDialogConfig(int ptr[][3])
{
for(int i=0;i<NumberOfSupportedCameras;i++)
for(int j=0;j<3;j++)
g_sys_conf.no[i][j]=ptr[i][j];
for (int i = 0; i < NumberOfSupportedCameras; i++)
for (int j = 0; j < 3; j++)
g_sys_conf.no[i][j] = ptr[i][j];
}
void DialogSetup::on_pushButton_change_released()
{
@ -821,7 +821,7 @@ void DialogSetup::on_pushButton_change_released()
connect(this, &DialogSetup::sendMsgToShift, m_change_shift, &change_shift::recMsgFromDialogSetup);
m_change_shift->show();
m_change_shift->move(this->geometry().center() - m_change_shift->rect().center());
emit sendMsgToShift (g_sys_conf.shiftA, g_sys_conf.shiftB, g_sys_conf.shiftC);
emit sendMsgToShift(g_sys_conf.shiftA, g_sys_conf.shiftB, g_sys_conf.shiftC);
}
void DialogSetup::on_pushButton_statistic_released()
{

28
Cigarette/dialogsetup.hpp
Unescape Escape View File

@ -1,16 +1,16 @@
#pragma once
#pragma once
#include <QDialog>
#include "ui_dialogsetup.h"
#include "basecamera.h"
#include <qdebug.h>
#include <common.h>
#include <camera_glue.h>
#include <output_statistic.h>
#include <change_shift.h>
#include "common.h"
#include "camera_glue.h"
#include "output_statistic.h"
#include "change_shift.h"
class DialogSetup : public QDialog {
Q_OBJECT
signals :
signals:
void system_exit();
void sendMsgToShift(QTime timeA, QTime timeB, QTime timeC);
void sendMsgToOutput();
@ -19,7 +19,7 @@ signals :
void _testimg();
void _testimgs();
#endif
private slots :
private slots:
void on_toolButton_keyboard_released();
void on_pushButton_exit_released();
void on_pushButton_save_released();
@ -53,11 +53,11 @@ private slots :
void on_pushButton_testimgs_released();
#endif
public:
DialogSetup(QWidget * parent = Q_NULLPTR);
DialogSetup(QWidget* parent = Q_NULLPTR);
~DialogSetup();
QLineEdit *lineEdit_expo_mat[NumberOfSupportedCameras];
QLineEdit *lineEdit_gain_mat[NumberOfSupportedCameras];
QLineEdit *lineEdit_filter_mat[NumberOfSupportedCameras];
QLineEdit* lineEdit_expo_mat[NumberOfSupportedCameras];
QLineEdit* lineEdit_gain_mat[NumberOfSupportedCameras];
QLineEdit* lineEdit_filter_mat[NumberOfSupportedCameras];
void InitPtrMat();
static void write_pswd();
static void write_pswd_op();
@ -65,9 +65,9 @@ public:
static void write_conf_path();
public:
camera_glue *m_camera_glue=NULL;
change_shift *m_change_shift=NULL;
output_statistic *m_output_statistic=NULL;
camera_glue* m_camera_glue = NULL;
change_shift* m_change_shift = NULL;
output_statistic* m_output_statistic = NULL;
private:
Ui::DialogSetup ui;
};

4
Cigarette/dialogsetuppasswd.cpp
Unescape Escape View File

@ -1,4 +1,4 @@
#include "dialogsetuppasswd.hpp"
#include "dialogsetuppasswd.hpp"
#include <QCryptographicHash>
@ -9,7 +9,7 @@
extern bool g_admin_mode; //是否管理员模式
extern QString g_admin_pswd; //管理员密码
DialogSetupPasswd::DialogSetupPasswd(QWidget * parent) : QDialog(parent) {
DialogSetupPasswd::DialogSetupPasswd(QWidget* parent) : QDialog(parent) {
ui.setupUi(this);
m_pswd = "";
this->setWindowFlags(Qt::FramelessWindowHint);

8
Cigarette/dialogsetuppasswd.hpp
Unescape Escape View File

@ -1,17 +1,17 @@
#pragma once
#pragma once
#include <QDialog>
#include "ui_dialogsetuppasswd.h"
class DialogSetupPasswd : public QDialog {
Q_OBJECT
signals :
signals:
void enter_admin();
public:
DialogSetupPasswd(QWidget * parent = Q_NULLPTR);
DialogSetupPasswd(QWidget* parent = Q_NULLPTR);
~DialogSetupPasswd();
private slots :
private slots:
void on_pushButton_close_released();
void on_pushButton_clr_released();
void on_pushButton_ok_released();

86
Cigarette/exportData.cpp
Unescape Escape View File

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

50
Cigarette/exportData.h
Unescape Escape View File

@ -18,45 +18,45 @@ using namespace tinyxml2;
class _XMLExportDataInfo {
public:
// 总的统计数据
// 总的统计数据
long long cameraTotal;
int TotalCheckNum; // 总检测数量
int TotalKickNum; // 总剔除数量
double PassRate; // 合格率
double KickRate; // 剔除率
// 各相机数据
int TotalCheckNum; // 总检测数量
int TotalKickNum; // 总剔除数量
double PassRate; // 合格率
double KickRate; // 剔除率
// 各相机数据
int cameraId;
int shotCounts; // 拍摄张数
int checkNum; // 各相机检测个数
int okNum; // 各相机ok数量
int ngNum; // 各相机ng数量
int kickNum; // 各相机实际剔除数量（单通道剔除时为总剔除数量）
QString AcquisitionSpeed; // 各相机采集速度
QString jdNum; // 各相机胶点识别个数
QString DetectSpeed; // 各相机检测速度(识别时间)
int shotCounts; // 拍摄张数
int checkNum; // 各相机检测个数
int okNum; // 各相机ok数量
int ngNum; // 各相机ng数量
int kickNum; // 各相机实际剔除数量（单通道剔除时为总剔除数量）
QString AcquisitionSpeed; // 各相机采集速度
QString jdNum; // 各相机胶点识别个数
QString DetectSpeed; // 各相机检测速度(识别时间)
_XMLExportDataInfo() {
// 总的统计数据
TotalCheckNum = 0; // 总检测数量
TotalKickNum = 0; // 总剔除数量
PassRate = 0.0; // 合格率
KickRate = 0.0; // 剔除率
// 总的统计数据
TotalCheckNum = 0; // 总检测数量
TotalKickNum = 0; // 总剔除数量
PassRate = 0.0; // 合格率
KickRate = 0.0; // 剔除率
cameraId = -1;
jdNum = QString("0,0,0");
// 各相机数据
// 各相机数据
shotCounts = 0;
checkNum = 0;
okNum = 0;
ngNum = 0;
kickNum = 0; // 各相机实际剔除数量（单通道剔除时为总剔除数量）
AcquisitionSpeed = "0"; // 各相机采集速度
DetectSpeed = "0"; // 各相机检测速度
kickNum = 0; // 各相机实际剔除数量（单通道剔除时为总剔除数量）
AcquisitionSpeed = "0"; // 各相机采集速度
DetectSpeed = "0"; // 各相机检测速度
}
};
class _ExportDataInfo
{
struct JdPoint //创建点的数据
struct JdPoint //创建点的数据
{
string x;
string y;
@ -128,7 +128,7 @@ protected:
void check_save_dir(std::string dir_path);
public:
bool b_quit;
tinyxml2::XMLDocument *pDocument[NumberOfSupportedCameras];
tinyxml2::XMLDocument* pDocument[NumberOfSupportedCameras];
//int flag;
HINTERNET hint = NULL;

2
Cigarette/hikcamera.cpp
Unescape Escape View File

@ -24,7 +24,7 @@ int HIKCamera::Enumerate()
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)
{

2
Cigarette/hikcamera.h
Unescape Escape View File

@ -6,7 +6,7 @@
#define HIKClassID 0x03
class HIKCamera: public BaseCamera
class HIKCamera : public BaseCamera
{
public:
HIKCamera(int DeviceNum);

4
Cigarette/main.cpp
Unescape Escape View File

@ -7,10 +7,10 @@
#include "CryptoToolLib.h"
#endif
int main(int argc, char *argv[])
int main(int argc, char* argv[])
{
#if defined LICENSE_VERIFY
if(!VerifyLicense())
if (!VerifyLicense())
{
exit(0);
}

4
Cigarette/output_statistic.cpp
Unescape Escape View File

@ -9,11 +9,11 @@ extern ConfPath g_conf_path;
#define output_init(a, b)\
textBrowser_mat[a] = ui.textBrowser_##b;
output_statistic::output_statistic(QDialog *parent)
output_statistic::output_statistic(QDialog* parent)
: QDialog(parent)
{
ui.setupUi(this);
this->setWindowFlags(windowFlags()&~Qt::WindowContextHelpButtonHint);
this->setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
#if defined(NumberOfSupportedCameras) && (NumberOfSupportedCameras > 0)
output_init(0, 1);

2
Cigarette/output_statistic.h
Unescape Escape View File

@ -9,7 +9,7 @@ class output_statistic : public QDialog
Q_OBJECT
public:
output_statistic(QDialog *parent = Q_NULLPTR);
output_statistic(QDialog* parent = Q_NULLPTR);
~output_statistic();
private:

8
Cigarette/plc_item.h
Unescape Escape View File

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

46
Cigarette/plcsetup.cpp
Unescape Escape View File

@ -10,7 +10,7 @@
#include "PLCDevice.h"
#define PLC_ITEM_FILE "plc.txt"
extern PLCDevice * m_PLCDevice;
extern PLCDevice* m_PLCDevice;
extern ConfPath g_conf_path;
extern bool g_plc_dialog_open; //是否打开plc配置对话框
@ -19,7 +19,7 @@ void task_osk_()
system("start /b C:\\Windows\\system32\\osk.exe");
}
PlcSetup::PlcSetup(QWidget * parent) : QDialog(parent) {
PlcSetup::PlcSetup(QWidget* parent) : QDialog(parent) {
ui.setupUi(this);
this->setWindowFlags(Qt::FramelessWindowHint);
read_plc_items();
@ -27,7 +27,7 @@ PlcSetup::PlcSetup(QWidget * parent) : QDialog(parent) {
ui.tableWidget->setRowCount(m_plc_items.size());
QStringList header_list;
header_list << QStringLiteral("功能描述") << QStringLiteral("读数值")
<< QStringLiteral("读操作") << QStringLiteral("写数值") << QStringLiteral("写操作") << QStringLiteral("保存") << QStringLiteral("备注") ;
<< QStringLiteral("读操作") << QStringLiteral("写数值") << QStringLiteral("写操作") << QStringLiteral("保存") << QStringLiteral("备注");
ui.tableWidget->setHorizontalHeaderLabels(header_list);
ui.tableWidget->setColumnWidth(0, 200);
ui.tableWidget->setColumnWidth(1, 100);
@ -41,21 +41,21 @@ PlcSetup::PlcSetup(QWidget * parent) : QDialog(parent) {
{
ui.tableWidget->setItem(i, 0, new QTableWidgetItem(QString::fromLocal8Bit(m_plc_items[i].func_desc.c_str())));
//ui.tableWidget->setItem(i, 1, new QTableWidgetItem(QString::number(m_plc_items[i].address)));
QPushButton * pBtnR = new QPushButton();
QPushButton* pBtnR = new QPushButton();
pBtnR->setText(QStringLiteral("读"));
connect(pBtnR, SIGNAL(clicked(bool)), this, SLOT(click_read()));
ui.tableWidget->setCellWidget(i, 2, pBtnR);
QLineEdit *edit = new QLineEdit();
QLineEdit* edit = new QLineEdit();
edit->setValidator(new QIntValidator(0, 100000, this));
ui.tableWidget->setCellWidget(i, 3, edit);
QPushButton * pBtnW = new QPushButton();
QPushButton* pBtnW = new QPushButton();
pBtnW->setText(QStringLiteral("写"));
connect(pBtnW, SIGNAL(clicked(bool)), this, SLOT(click_write()));
ui.tableWidget->setCellWidget(i, 4, pBtnW);
QPushButton * pBtnS = new QPushButton();
QPushButton* pBtnS = new QPushButton();
pBtnS->setText(QStringLiteral("保存"));
connect(pBtnS, SIGNAL(clicked(bool)), this, SLOT(click_save()));
ui.tableWidget->setCellWidget(i, 5, pBtnS);
@ -74,7 +74,7 @@ PlcSetup::~PlcSetup() {
void PlcSetup::click_read()
{
QPushButton *pushButton_ = dynamic_cast<QPushButton*>(this->sender());
QPushButton* pushButton_ = dynamic_cast<QPushButton*>(this->sender());
if (NULL == pushButton_)
{
return;
@ -88,7 +88,7 @@ void PlcSetup::click_read()
int addr = m_plc_items[row].address;
uint8_t dest[4];
uint16_t * dest16 = (uint16_t *)dest;
uint16_t* dest16 = (uint16_t*)dest;
memset(dest, 0, 4);
if (addr > 0)
{
@ -98,7 +98,7 @@ void PlcSetup::click_read()
ui.tableWidget->setItem(row, 1, new QTableWidgetItem(QString::number(dest[0])));
}
else { //读取DWORD值，4字节
int ret = m_PLCDevice->read_short_from_plc( addr, 2, dest16);
int ret = m_PLCDevice->read_short_from_plc(addr, 2, dest16);
//printf("%x ", dest16[0]);
//printf("%x \n", dest16[1]);
//printf("%d \n", dest16[0] + (dest16[1] << 16));
@ -109,7 +109,7 @@ void PlcSetup::click_read()
void PlcSetup::click_write()
{
QPushButton *pushButton_ = dynamic_cast<QPushButton*>(this->sender());
QPushButton* pushButton_ = dynamic_cast<QPushButton*>(this->sender());
if (NULL == pushButton_)
{
return;
@ -122,11 +122,11 @@ void PlcSetup::click_write()
//std::cout << "row:" << row << "\tcol:" << column << std::endl;
int addr = m_plc_items[row].address;
QWidget *widget=ui.tableWidget->cellWidget(row,3);
QLineEdit *edit=(QLineEdit*)widget;
QWidget* widget = ui.tableWidget->cellWidget(row, 3);
QLineEdit* edit = (QLineEdit*)widget;
QString d = edit->text();
uint8_t dest[4];
uint16_t * dest16 = (uint16_t *)dest;
uint16_t* dest16 = (uint16_t*)dest;
memset(dest, 0, 4);
if (d.length() > 0)
{
@ -136,11 +136,11 @@ void PlcSetup::click_write()
if (addr < 40000) //写入线圈值 bit
{
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字节
dest16[0] = (data & 0xffff);
dest16[1] = (data>>16);
dest16[1] = (data >> 16);
int ret = m_PLCDevice->write_short_2_plc(addr, 2, dest16);
}
}
@ -150,7 +150,7 @@ void PlcSetup::click_write()
void PlcSetup::click_save()
{
QPushButton *pushButton_ = dynamic_cast<QPushButton*>(this->sender());
QPushButton* pushButton_ = dynamic_cast<QPushButton*>(this->sender());
if (NULL == pushButton_)
{
return;
@ -163,11 +163,11 @@ void PlcSetup::click_save()
//std::cout << "row:" << row << "\tcol:" << column << std::endl;
int addr = m_plc_items[row].address;
QWidget *widget = ui.tableWidget->cellWidget(row, 3);
QLineEdit *edit = (QLineEdit*)widget;
QWidget* widget = ui.tableWidget->cellWidget(row, 3);
QLineEdit* edit = (QLineEdit*)widget;
QString d = edit->text();
uint8_t dest[4];
uint16_t * dest16 = (uint16_t *)dest;
uint16_t* dest16 = (uint16_t*)dest;
memset(dest, 0, 4);
if (d.length() > 0)
{
@ -177,7 +177,7 @@ void PlcSetup::click_save()
if (addr < 40000) //写入线圈值 bit
{
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字节
dest16[0] = (data & 0xffff);
@ -209,7 +209,7 @@ void PlcSetup::on_toolButton_batch_read_released()
{
int addr = m_plc_items[i].address;
uint8_t dest[4];
uint16_t * dest16 = (uint16_t *)dest;
uint16_t* dest16 = (uint16_t*)dest;
memset(dest, 0, 4);
if (addr > 0)
{
@ -219,7 +219,7 @@ void PlcSetup::on_toolButton_batch_read_released()
ui.tableWidget->setItem(i, 1, new QTableWidgetItem(QString::number(dest[0])));
}
else { //读取DWORD值，4字节
int ret = m_PLCDevice->read_short_from_plc( addr, 2, dest16);
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))));
}
}

6
Cigarette/plcsetup.hpp
Unescape Escape View File

@ -1,4 +1,4 @@
#pragma once
#pragma once
#include <QDialog>
#include <QPushButton>
#include "ui_plcsetup.h"
@ -14,10 +14,10 @@ class PlcSetup : public QDialog {
Q_OBJECT
public:
PlcSetup(QWidget * parent = Q_NULLPTR);
PlcSetup(QWidget* parent = Q_NULLPTR);
~PlcSetup();
QTimer *m_pTimer;
QTimer* m_pTimer;
void read_plc_items();
void save_plc_items();

4
Cigarette/savethread.h
Unescape Escape View File

@ -12,7 +12,7 @@
#include <opencv2/opencv.hpp>
#include <opencv2/imgproc/types_c.h>
extern SyncQueue<std::pair<std::string, cv::Mat>>* g_save_queue; //ͼÏñ±£´æ¶ÓÁÐ
extern SyncQueue<std::pair<std::string, cv::Mat>>* g_save_queue; //图像保存队列
class SaveThread : public QThread
{
@ -21,7 +21,7 @@ signals:
void sendDataToExport(QString filePath);
public:
SaveThread(QObject *parent = 0): QThread(parent)
SaveThread(QObject* parent = 0) : QThread(parent)
{
}

35
Cigarette/syncworkthread.cpp
Unescape Escape View File

@ -8,17 +8,18 @@
#include "exportData.h"
#include <QMap>
extern AlgJd alg_jd[NumberOfSupportedCameras]; //检测胶点的AI算法
extern AlgJd alg_jd[NumberOfSupportedCameras]; //检测胶点的AI算法
extern ConfPath g_conf_path;
extern SysConf g_sys_conf; //系统配置参数
extern SysConf g_sys_conf; //系统配置参数
extern DisplayLabelConf g_display_label_conf[NumberOfSupportedCameras];
extern int rotationAngle[NumberOfSupportedCameras]; //图片旋转角度
extern int rotationAngle[NumberOfSupportedCameras]; //图片旋转角度
extern bool isNeedRotate[NumberOfSupportedCameras];
extern int work_camera_nums;
extern SingleCamInfoStruct SingleCamInfo[NumberOfSupportedCameras];
extern SyncQueue<std::pair<std::string, cv::Mat> >* g_save_queue; //图片保存队列
extern SyncQueue<std::pair<int, cv::Mat>>* g_image_queue[NumberOfSupportedCameras]; //int表示一个目标拍了几张
extern SyncQueue<std::pair<std::string, cv::Mat> >* g_save_queue; //图片保存队列
extern SyncQueue<std::pair<int, cv::Mat>>* g_image_queue[NumberOfSupportedCameras]; //int表示一个目标拍了几张
#ifdef __UDPSend
extern SyncQueue<_UDPSendInfo>* UDP_Info_queue;
#endif
@ -70,16 +71,19 @@ void SyncWorkThread::run()
bool IsNGForAll = false;
int merge_index;
cv::Rect roi;
int j = 0; // 实际工作的相机标识，element_vec中可能有相机没在工作
for (int i = 0; i < element_vec.size(); i++)//每个相机的图轮流遍历
int j = 0; // 实际工作的相机标识，element_vec中可能有相机没在工作
for (int i = 0; i < element_vec.size(); i++)//每个相机的图轮流遍历
{
if (!SingleCamInfo[i].Detect || !SingleCamInfo[i].IsOpen || SingleCamInfo[i].OffLine)
continue;
local_camera_number = i;
int isWork = element_vec[i].first;
std::pair<int, cv::Mat> element;
element = element_vec[i];
int unit_count = element.first;
cv::Mat image = element.second;
{//不要删掉这个括号，用来定义锁的作用域
{//不要删掉这个括号，用来定义锁的作用域
std::lock_guard<std::mutex> locker(g_sys_conf.lock);
local_SysConf.save = g_sys_conf.save;
local_SysConf.shoot[local_camera_number] = g_sys_conf.shoot[local_camera_number];
@ -110,12 +114,12 @@ void SyncWorkThread::run()
#endif
if (!image.data)
{
continue; //图像为空，跳过
continue; //图像为空，跳过
}
cv::Mat merge_image = cv::Mat::zeros(512 * work_camera_nums, 640 * g_sys_conf.shoot[i], CV_8UC3);
if (image.channels() == 1)
{
cv::cvtColor(image, image, CV_BGR2RGB); //灰度图像转为彩色图像
cv::cvtColor(image, image, CV_BGR2RGB); //灰度图像转为彩色图像
}
cv::resize(image, image, cv::Size(640, 512 * unit_count));
if (local_SysConf.shoot[local_camera_number] == unit_count)
@ -177,21 +181,21 @@ void SyncWorkThread::run()
ng_reason_maps[1] = "less_than_setting";
ng_reason_maps[2] = "too_diff_from_model";
ng_reason_maps[3] = "out_of_setting_range";
for (int index = 0; index < unit_count; index++){
for (int index = 0; index < unit_count; index++) {
if (vec_results[index].size() < local_SysConf.no[local_camera_number][index])
{
IsNG |= true;
ngReason = 1;
}
//if (vec_results[index].size() != 1)IsNG |= true;//反向训练
//if (vec_results[index].size() != 1)IsNG |= true;//反向训练
if (local_SysConf.ConfThreshold == 0)
{
IsNG = false;
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();
QString file_name;
merge_index = j * unit_count + index + 1;
@ -303,7 +307,6 @@ void SyncWorkThread::run()
#ifdef SYNC_CAMERA
if (!g_debug_mode)
{
if(isWork != 0)
emit display_check_total(local_camera_number, ++frame_total[local_camera_number]);
//exportDataInfo.cameraTotal = frame_total;
emit notify(local_camera_number, 0, image1);
@ -316,7 +319,7 @@ void SyncWorkThread::run()
else
{
#ifdef SYNC_CAMERA
//保证不错位
//保证不错位
if (!g_debug_mode)
{
if (local_SysConf.MisMatchAct == 1)//as ng

18
Cigarette/threadReceive.cpp
Unescape Escape View File

@ -16,30 +16,30 @@ void threadReceive::stop()
// wait();
}
void threadReceive::init(std::string IP,int port)
void threadReceive::init(std::string IP, int port)
{
ip = QString::fromStdString(IP);
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);
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);
}
void threadReceive::processPendingDatagram()
{
// 拥有等待的数据报
// 拥有等待的数据报
while (mSocket->hasPendingDatagrams())
{
QByteArray datagram;
// 让datagram的大小为等待处理的数据报的大小，这样才能接收到完整的数据
// 让datagram的大小为等待处理的数据报的大小，这样才能接收到完整的数据
datagram.resize(mSocket->pendingDatagramSize());
// 接收数据报，将其存放到datagram中
// 接收数据报，将其存放到datagram中
mSocket->readDatagram(datagram.data(), datagram.size());
QString data = datagram;
@ -51,14 +51,14 @@ void threadReceive::fileprocessPendingDatagram()
{
QString filename;
std::fstream file;
// 拥有等待的数据报
// 拥有等待的数据报
while (filemSocket->hasPendingDatagrams())
{
QByteArray datagram;
// 让datagram的大小为等待处理的数据报的大小，这样才能接收到完整的数据
// 让datagram的大小为等待处理的数据报的大小，这样才能接收到完整的数据
datagram.resize(filemSocket->pendingDatagramSize());
// 接收数据报，将其存放到datagram中
// 接收数据报，将其存放到datagram中
filemSocket->readDatagram(datagram.data(), datagram.size());
QString data = datagram;

6
Cigarette/threadReceive.h
Unescape Escape View File

@ -28,7 +28,7 @@ public:
wait();
}
void stop();
void init(std::string IP,int port);
void init(std::string IP, int port);
void start_work();
private slots:
@ -40,6 +40,6 @@ signals:
public:
std::atomic_bool isLoop = { 0 };
QUdpSocket *mSocket;
QUdpSocket *filemSocket;
QUdpSocket* mSocket;
QUdpSocket* filemSocket;
};

48
Cigarette/threadSend.cpp
Unescape Escape View File

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

22
Cigarette/threadSend.h
Unescape Escape View File

@ -41,14 +41,14 @@ public:
{
FrameID = 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;
JD = QString("0,0,0");
timecost = QString("0ms");;
for (int i = 0; i < NumberOfSupportedCameras; i++)ok[i] = 0;
for (int i = 0; i < NumberOfSupportedCameras; i++)ng[i] = 0;
speed = QString(" ");
for(int i=0;i<NumberOfSupportedCameras;i++)Kick[i]=0;
for (int i = 0; i < NumberOfSupportedCameras; i++)Kick[i] = 0;
}
};
@ -77,20 +77,20 @@ protected:
void run();
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 sendData(_UDPSendInfo *UDPSendInfo,int port);
void sendData(_UDPSendInfo* UDPSendInfo, int port);
void sendData(QString data, int port);
void sendImage(_UDPSendInfo *UDPSendInfo,int port);
void sendSpeed(_UDPSendInfo *UDPSendInfo,int port);
void sendKick(_UDPSendInfo *UDPSendInfo,int port);
void sendOK(_UDPSendInfo *UDPSendInfo,int port);
void sendNG(_UDPSendInfo *UDPSendInfo,int port);
void sendTotal(_UDPSendInfo *UDPSendInfo,int port);
void sendImage(_UDPSendInfo* UDPSendInfo, int port);
void sendSpeed(_UDPSendInfo* UDPSendInfo, int port);
void sendKick(_UDPSendInfo* UDPSendInfo, int port);
void sendOK(_UDPSendInfo* UDPSendInfo, int port);
void sendNG(_UDPSendInfo* UDPSendInfo, int port);
void sendTotal(_UDPSendInfo* UDPSendInfo, int port);
void sendFile(QString FilePath, int port);
public:
SyncQueue<_UDPSendInfo> *Local_UDP_Info_queue;
SyncQueue<_UDPSendInfo>* Local_UDP_Info_queue;
std::atomic_bool isLoop = { 0 };
QUdpSocket mSocket;
};

5
Cigarette/threadSendTCP.cpp
Unescape Escape View File

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

2
Cigarette/threadSendTCP.h
Unescape Escape View File

@ -51,5 +51,5 @@ public:
public:
SyncQueue<_TCPSendInfo>* Local_TCP_Info_queue;
std::atomic_bool isLoop = { 0 };
QTcpSocket *mySocket;
QTcpSocket* mySocket;
};

2592
Cigarette/tinyxml2.cpp
View File

File diff suppressed because it is too large Load Diff

1038
Cigarette/tinyxml2.h
View File

File diff suppressed because it is too large Load Diff

48
Cigarette/workthread.cpp
Unescape Escape View File

@ -8,16 +8,16 @@
#include "exportData.h"
#include <QMap>
extern AlgJd alg_jd[NumberOfSupportedCameras]; //检测胶点的AI算法
extern AlgJd alg_jd[NumberOfSupportedCameras]; //检测胶点的AI算法
extern ConfPath g_conf_path;
extern SysConf g_sys_conf; //系统配置参数
extern SysConf g_sys_conf; //系统配置参数
extern DisplayLabelConf g_display_label_conf[NumberOfSupportedCameras];
extern int rotationAngle[NumberOfSupportedCameras]; //图片旋转角度
extern int rotationAngle[NumberOfSupportedCameras]; //图片旋转角度
extern bool isNeedRotate[NumberOfSupportedCameras];
extern SyncQueue<std::pair<std::string, cv::Mat> >* g_save_queue; //图片保存队列
extern SyncQueue<std::pair<int, cv::Mat>>* g_image_queue[NumberOfSupportedCameras]; //int表示一个目标拍了几张
extern SyncQueue<std::pair<std::string, cv::Mat> >* g_save_queue; //图片保存队列
extern SyncQueue<std::pair<int, cv::Mat>>* g_image_queue[NumberOfSupportedCameras]; //int表示一个目标拍了几张
#ifdef __UDPSend
extern SyncQueue<_UDPSendInfo>* UDP_Info_queue;
#endif
@ -58,10 +58,10 @@ void WorkThread::stop()
void WorkThread::run()
{
try{
try {
uint32_t result_index = 0;
while (!b_quit) {
{//不要删掉这个括号，用来定义锁的作用域
{//不要删掉这个括号，用来定义锁的作用域
std::lock_guard<std::mutex> locker(g_sys_conf.lock);
local_SysConf.save = g_sys_conf.save;
local_SysConf.shoot[local_camera_number] = g_sys_conf.shoot[local_camera_number];
@ -98,11 +98,11 @@ void WorkThread::run()
#endif
if (!image.data)
{
continue; //图像为空，跳过
continue; //图像为空，跳过
}
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)
{
@ -124,14 +124,15 @@ void WorkThread::run()
std::vector<cv::Mat> vec_out;
std::vector<std::vector<std::pair<int, cv::Rect> > > vec_results;
QDateTime ts_start = QDateTime::currentDateTime();
if(unit_count == 1){
if (unit_count == 1) {
std::vector<std::pair<int, cv::Rect> > results;
cv::Mat imagein,imageout;
cv::Mat imagein, imageout;
imagein = vec_in[0];
alg_jd[local_camera_number].detect(imagein, imageout, results);
vec_out.push_back(imageout.clone());
vec_results.push_back(results);
}else{
}
else {
alg_jd[local_camera_number].detect_batch(vec_in, vec_out, vec_results);
}
QDateTime ts_jd = QDateTime::currentDateTime();
@ -164,20 +165,20 @@ void WorkThread::run()
ng_reason_maps[1] = "less_than_setting";
ng_reason_maps[2] = "too_diff_from_model";
ng_reason_maps[3] = "out_of_setting_range";
for(int index=0;index<unit_count;index++)
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;
ngReason = 1;
}
//if (vec_results[index].size() != 1)IsNG |= true;//反向训练
//if (vec_results[index].size() != 1)IsNG |= true;//反向训练
if (local_SysConf.ConfThreshold == 0)
{
IsNG = false;
ngReason = 0;
}
if (local_SysConf.save == 2)//三张照片分别存储
if (local_SysConf.save == 2)//三张照片分别存储
{
cv::Mat m = vec_in[index].clone();
QString file_name = g_conf_path.save_pics_path + "/ALL/" +
@ -197,18 +198,19 @@ void WorkThread::run()
}
}
if (unit_count >= 2){
if (unit_count >= 2) {
image1 = vec_out[(result_index) % 2].clone();
#ifdef DRAW_RECT
IsNG|=CheckSelectRects(image1,vec_results,(result_index) % 2,local_DisplayLabelConf,0);
IsNG |= CheckSelectRects(image1, vec_results, (result_index) % 2, local_DisplayLabelConf, 0);
if (IsNG) {
ngReason = 2;
}
#endif
}else {
}
else {
image1 = vec_out[0].clone();
#ifdef DRAW_RECT
IsNG|=CheckSelectRects(image1,vec_results,0,local_DisplayLabelConf,0);
IsNG |= CheckSelectRects(image1, vec_results, 0, local_DisplayLabelConf, 0);
if (IsNG) {
ngReason = 2;
}
@ -222,7 +224,7 @@ void WorkThread::run()
image2 = vec_out[2].clone();
#ifdef DRAW_RECT
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) {
ngReason = 3;
}
@ -252,7 +254,7 @@ void WorkThread::run()
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();
QString file_name = g_conf_path.save_pics_path + "/ng/" +
@ -298,7 +300,7 @@ void WorkThread::run()
#ifndef SYNC_CAMERA
else
{
//保证不错位
//保证不错位
if (!g_debug_mode)
{
if (local_SysConf.MisMatchAct == 1)//as ng

12
Cigarette/workthread.h
Unescape Escape View File

@ -13,23 +13,23 @@ class WorkThread : public QThread
Q_OBJECT
#ifndef SYNC_CAMERA
signals:
void notify(int Num,int Cnt,cv::Mat);
void display_timecost(int Num,int ms);
void display_check_total(int Num,long no);
void display_jd_no(int Num,QString jd_no);
void notify(int Num, int Cnt, cv::Mat);
void display_timecost(int Num, int ms);
void display_check_total(int Num, long no);
void display_jd_no(int Num, QString jd_no);
void event_ok(int Num);
void event_ng(int Num);
#endif
public:
WorkThread(QObject *parent = 0): QThread(parent)
WorkThread(QObject* parent = 0) : QThread(parent)
{
}
~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 stop();
protected:

Write Preview
Loading…
Cancel
Save