更新同步检测功能

main
Jeffrey_Li 10 months ago
parent 03444ed917
commit 2506ac806e

@ -47,7 +47,12 @@ void CaptureThread::process( void )
#ifndef IMM_PROCESS
EventCallback eventCallback(&pEventCtrl_);
eventCallback.p_unit_queue_ = p_unit_queue;
#ifdef SYNC_CAMERA
eventCallback.p_image_sync_arr_ = p_image_sync_arr;
eventCallback.p_image_sync_queue_ = p_image_sync_queue;
#else
eventCallback.p_image_queue_ = p_image_queue;
#endif
eventCallback.p_result_wait_queue_ = p_result_wait_queue;
eventCallback.p_shooted_queue_ = p_shooted_queue;
eventCallback.p_double_queue_ = p_double_queue;

@ -17,7 +17,7 @@
#include <opencv2/opencv.hpp>
#include <common.h>
#include "common.h"
extern SingleCamInfoStruct SingleCamInfo[NumberOfSupportedCameras];
@ -115,7 +115,12 @@ public:
QTimer* m_Timer;
uint64_t m_cntGrabbedImages = 0;
uint64_t m_cntLastGrabbedImages = 0;
#ifdef SYNC_CAMERA
ImageSyncArr *p_image_sync_arr;
SyncQueue<std::vector<std::pair<int, cv::Mat>>>* p_image_sync_queue;
#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;
@ -139,7 +144,12 @@ class EventCallback : public mvIMPACT::acquire::ComponentCallback
{
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_;
#else
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_;
@ -214,7 +224,20 @@ public:
cv::Mat roi = long_image(r);
image.copyTo(roi);
}
#ifdef SYNC_CAMERA
{
std::lock_guard<std::mutex> locker(p_image_sync_arr_->lock);
p_image_sync_arr_->image_sync_arr.at(pCaptureThread->Local_Num) = std::make_pair(unit_count, long_image);
p_image_sync_arr_->collect_cnt++;
if (p_image_sync_arr_->collect_cnt == NumberOfSupportedCameras)
{
p_image_sync_queue_->put(p_image_sync_arr_->image_sync_arr);
p_image_sync_arr_->collect_cnt = 0;
}
}
#else
p_image_queue_->put(std::make_pair(unit_count, long_image));
#endif
p_shooted_queue_->put(true);
}
p_unit_queue_->clear();

@ -31,7 +31,12 @@ void CaptureThreadBasler::process(void)
pDev_->RegisterConfiguration(CfgEvent, Pylon::RegistrationMode_Append, Pylon::Cleanup_None);
CSampleImageEventHandler ImageEvent;
#ifdef SYNC_CAMERA
ImageEvent.p_image_sync_arr_ = p_image_sync_arr;
ImageEvent.p_image_sync_queue_ = p_image_sync_queue;
#else
ImageEvent.p_image_queue_ = p_image_queue;
#endif
ImageEvent.p_unit_queue_ = p_unit_queue;
ImageEvent.p_shooted_queue_ = p_shooted_queue;
ImageEvent.p_debug_queue_ = p_debug_queue;
@ -41,12 +46,17 @@ void CaptureThreadBasler::process(void)
pDev_->RegisterImageEventHandler(&ImageEvent, Pylon::RegistrationMode_Append, Pylon::Cleanup_None);
CSampleCameraEventHandler BurstEvent;
#ifdef SYNC_CAMERA
BurstEvent.p_image_sync_arr_ = p_image_sync_arr;
BurstEvent.p_image_sync_queue_ = p_image_sync_queue;
#else
BurstEvent.p_image_queue_ = p_image_queue;
#endif
BurstEvent.p_unit_queue_ = p_unit_queue;
BurstEvent.p_result_wait_queue_ = p_result_wait_queue;
BurstEvent.p_result_queue_ = p_result_queue;
BurstEvent.p_shooted_queue_ = p_shooted_queue;
BurstEvent.p_double_queue_ = p_double_queue;
BurstEvent.p_image_queue_ = p_image_queue;
BurstEvent.pDev__ = pDev_;
BurstEvent.pCaptureThreadBasler = this;

@ -111,7 +111,12 @@ private slots:
public:
int Local_Num;
int Shoot_Num;
SyncQueue<std::pair<int, cv::Mat> > *p_image_queue;
#ifdef SYNC_CAMERA
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;
@ -150,7 +155,12 @@ public:
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_;
#else
SyncQueue<std::pair<int, cv::Mat> >* p_image_queue_;
#endif
Pylon::CBaslerUniversalInstantCamera* pDev__;
CaptureThreadBasler* pCaptureThreadBasler = NULL;
// Only very short processing tasks should be performed by this method. Otherwise, the event notification will block the
@ -272,7 +282,20 @@ public:
cv::Mat roi = long_image(r);
image.copyTo(roi);
}
#ifdef SYNC_CAMERA
{
std::lock_guard<std::mutex> locker(p_image_sync_arr_->lock);
p_image_sync_arr_->image_sync_arr.at(pCaptureThreadBasler->Local_Num) = std::make_pair(unit_count, long_image);
p_image_sync_arr_->collect_cnt++;
if (p_image_sync_arr_->collect_cnt == NumberOfSupportedCameras)
{
p_image_sync_queue_->put(p_image_sync_arr_->image_sync_arr);
p_image_sync_arr_->collect_cnt = 0;
}
}
#else
p_image_queue_->put(std::make_pair(unit_count, long_image));
#endif
p_shooted_queue_->put(true);
}
p_unit_queue_->clear();
@ -289,7 +312,12 @@ 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_;
#else
SyncQueue<std::pair<int, cv::Mat> >* p_image_queue_;
#endif
SyncQueue<cv::Mat>* p_debug_queue_;
ASyncQueue<bool> *p_shooted_queue_;
Pylon::CBaslerUniversalInstantCamera* pDev__;

@ -38,7 +38,20 @@ inline void FallingGpioEventfunction(MV_EVENT_OUT_INFO* pEventInfo, void* pUser)
cv::Mat roi = long_image(r);
image.copyTo(roi);
}
#ifdef SYNC_CAMERA
{
std::lock_guard<std::mutex> locker(CaptureThreadHIKptr->p_image_sync_arr->lock);
CaptureThreadHIKptr->p_image_sync_arr->image_sync_arr.at(CaptureThreadHIKptr->Local_Num) = std::make_pair(unit_count, long_image);
CaptureThreadHIKptr->p_image_sync_arr->collect_cnt++;
if (CaptureThreadHIKptr->p_image_sync_arr->collect_cnt == NumberOfSupportedCameras)
{
CaptureThreadHIKptr->p_image_sync_queue->put(CaptureThreadHIKptr->p_image_sync_arr->image_sync_arr);
CaptureThreadHIKptr->p_image_sync_arr->collect_cnt = 0;
}
}
#else
CaptureThreadHIKptr->p_image_queue->put(std::make_pair(unit_count, long_image));
#endif
CaptureThreadHIKptr->p_shooted_queue->put(true);
}
CaptureThreadHIKptr->p_unit_queue->clear();

@ -3,7 +3,7 @@
#define CaptureThreadHIKH CaptureThreadHIKH
//-----------------------------------------------------------------------------
#include "hikcamera.h"
#include "common.h"
#include <QThread>
#include <QMutex>
#include <functional>
@ -80,7 +80,12 @@ private slots:
void fpsTimeout(void);
public:
int Local_Num;
SyncQueue<std::pair<int, cv::Mat> > *p_image_queue;
#ifdef SYNC_CAMERA
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;

@ -347,6 +347,7 @@
<ClCompile Include="PLC\PLCDevice.cpp" />
<ClCompile Include="plc_item.cpp" />
<ClCompile Include="SyncQueue.cpp" />
<ClCompile Include="syncworkthread.cpp" />
<ClCompile Include="threadReceive.cpp" />
<ClCompile Include="threadSend.cpp" />
<ClCompile Include="threadSendTCP.cpp" />

@ -260,6 +260,9 @@
<ClCompile Include="threadSendTCP.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="syncworkthread.cpp">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<CustomBuild Include="cigarette.h">
@ -355,6 +358,9 @@
<CustomBuild Include="exportData.h">
<Filter>Header Files</Filter>
</CustomBuild>
<CustomBuild Include="syncworkthread.h">
<Filter>Header Files</Filter>
</CustomBuild>
</ItemGroup>
<ItemGroup>
<ClInclude Include="GeneratedFiles\ui_cigarette.h">

@ -48,7 +48,12 @@ void *HIKCamHandle[NumberOfSupportedCameras];
CaptureThreadHIK* pHIKCaptureThread[NumberOfSupportedCameras];
SyncQueue<std::pair<std::string, cv::Mat>> *g_save_queue; //图片保存队列
#ifdef SYNC_CAMERA
ImageSyncArr g_image_sync_arr;
SyncQueue<std::vector<std::pair<int, cv::Mat>>> *g_image_sync_queue; //int±íʾһ¸öÄ¿±êÅÄÁ˼¸ÕÅ
#else
SyncQueue<std::pair<int, cv::Mat> > *g_image_queue[NumberOfSupportedCameras]; //int表示一个目标拍了几张
#endif
ASyncQueue<bool> *g_shooted_queue[NumberOfSupportedCameras]; //
ASyncQueue<bool> *g_result_wait_queue[NumberOfSupportedCameras]; //
ASyncQueue<bool> *g_double_queue[NumberOfSupportedCameras]; //
@ -156,10 +161,16 @@ Cigarette::Cigarette(QWidget *parent)
#endif
last_shift = 256;
#ifdef SYNC_CAMERA
g_image_sync_queue = new SyncQueue<std::vector<std::pair<int, cv::Mat>>>(Queue_Size);
g_image_sync_queue->name = format("sync_image");
#endif
for(int i=0;i<NumberOfSupportedCameras;i++)
{
#ifndef SYNC_CAMERA
g_image_queue[i] = new SyncQueue<std::pair<int, cv::Mat> >(Queue_Size);
g_image_queue[i]->name = format("image_%d", i);
#endif
g_result_queue[i] = new ASyncQueue<bool>(Queue_Size);
g_result_queue[i]->name = format("result_%d", i);
g_result_wait_queue[i] = new ASyncQueue<bool>(Queue_Size);
@ -315,6 +326,10 @@ Cigarette::Cigarette(QWidget *parent)
// 剔除值清0
int ret = m_PLCDevice->write_bit_2_plc(g_modbus_conf.shift, 1);//给PLC发送换班消息
#ifdef SYNC_CAMERA
CreatWorkThread(0, 0, this);
#endif
//创建相机工作线程
for (int i = 0; i < NumberOfSupportedCameras; i++)
{
@ -340,7 +355,13 @@ Cigarette::Cigarette(QWidget *parent)
QMessageBox::information(NULL, QStringLiteral("系统自检失败"), QStringLiteral("AI模型1初始化失败请检查程序完整性"), QMessageBox::Ok);
exit(-1);
}
#ifdef SYNC_CAMERA
debug_thread[i].init(g_debug_queue[i],i);
connect(&debug_thread[i], SIGNAL(notify(int,int,cv::Mat)), this, SLOT(OnNotifyHub(int,int,cv::Mat)));
debug_thread[i].start_work();
#else
CreatWorkThread(SingleCamInfo[i].CamClass, i, this);
#endif
}
else {
QDateTime ts_start = QDateTime::currentDateTime();
@ -653,6 +674,10 @@ void Cigarette::pause_work()
void Cigarette::Exit()
{
this->on_btn_pause_released();
#ifdef SYNC_CAMERA
sync_work_thread.stop();
delete g_image_sync_queue;
#endif
for(int i=0;i<NumberOfSupportedCameras;i++)
{
if(SingleCamInfo[i].Detect){
@ -662,9 +687,13 @@ void Cigarette::Exit()
cam_work_mat[i]->setStyleSheet(tr("background-color: rgb(255, 255, 0);"));
}
}
work_thread[i].stop();
debug_thread[i].stop();
#ifdef SYNC_CAMERA
#else
work_thread[i].stop();
delete g_image_queue[i];
#endif
delete g_result_queue[i];
delete g_result_wait_queue[i];
delete g_double_queue[i];
@ -2776,6 +2805,16 @@ void Cigarette::init_plc_value()
void Cigarette::CreatWorkThread(int classid,int Num,Cigarette* classptr)
{
#ifdef SYNC_CAMERA
sync_work_thread.init(g_image_sync_queue, g_result_queue[0]);
connect(&sync_work_thread, SIGNAL(notify(int,int,cv::Mat)), classptr, SLOT(OnNotifyHub(int,int,cv::Mat)));
connect(&sync_work_thread, SIGNAL(display_timecost(int,int)), classptr, SLOT(OnDisplayTimeCostHub(int,int)));
connect(&sync_work_thread, SIGNAL(display_check_total(int,long)), classptr, SLOT(OnDisplayCheckNumberHub(int,long)));
connect(&sync_work_thread, SIGNAL(display_jd_no(int,QString)), classptr, SLOT(OnDisplayJdNoHub(int,QString)));
connect(&sync_work_thread, SIGNAL(event_ok(int)), classptr, SLOT(OnOKHub(int)));
connect(&sync_work_thread, SIGNAL(event_ng(int)), classptr, SLOT(OnNGHub(int)));
sync_work_thread.start_work();
#else
work_thread[Num].init(g_image_queue[Num], g_result_queue[Num], classid, Num);
connect(&work_thread[Num], SIGNAL(notify(int,int,cv::Mat)), classptr, SLOT(OnNotifyHub(int,int,cv::Mat)));
connect(&work_thread[Num], SIGNAL(display_timecost(int,int)), classptr, SLOT(OnDisplayTimeCostHub(int,int)));
@ -2787,6 +2826,7 @@ void Cigarette::CreatWorkThread(int classid,int Num,Cigarette* classptr)
debug_thread[Num].init(g_debug_queue[Num],Num);
connect(&debug_thread[Num], SIGNAL(notify(int,int,cv::Mat)), classptr, SLOT(OnNotifyHub(int,int,cv::Mat)));
debug_thread[Num].start_work();
#endif
}
#define InitPtrMat_init(a,b)\
@ -2908,8 +2948,12 @@ bool Cigarette::ControlCamOpenOrClose(int Num,bool OpenOrClose)
pac->gain.write(g_sys_conf.gain[Num]);
}
pCaptureThread[Num] = new CaptureThread(BalluffCamera::devMgr[SingleCamInfo[Num].unfiltered_num], false, pFI[Num],Num);
#ifdef SYNC_CAMERA
pCaptureThread[Num]->p_image_sync_queue = g_image_sync_queue;
pCaptureThread[Num]->p_image_sync_arr = &g_image_sync_arr;
#else
pCaptureThread[Num]->p_image_queue = g_image_queue[Num];
#endif
pCaptureThread[Num]->p_result_queue = g_result_queue[Num];
pCaptureThread[Num]->p_result_wait_queue = g_result_wait_queue[Num];
pCaptureThread[Num]->p_double_queue = g_double_queue[Num];
@ -3024,8 +3068,12 @@ bool Cigarette::ControlCamOpenOrClose(int Num,bool OpenOrClose)
baslerCamera->BinningVertical.SetValue(2);
pBaslerCaptureThread[Num] = new CaptureThreadBasler(baslerCamera, false, Num,g_sys_conf.shoot[Num]);
pBaslerCaptureThread[Num]->p_image_queue = g_image_queue[Num];
#ifdef SYNC_CAMERA
pCaptureThread[Num]->p_image_sync_queue = g_image_sync_queue;
pCaptureThread[Num]->p_image_sync_arr = &g_image_sync_arr;
#else
pCaptureThread[Num]->p_image_queue = g_image_queue[Num];
#endif
pBaslerCaptureThread[Num]->p_result_queue = g_result_queue[Num];
pBaslerCaptureThread[Num]->p_result_wait_queue = g_result_wait_queue[Num];
pBaslerCaptureThread[Num]->p_double_queue = g_double_queue[Num];
@ -3150,7 +3198,12 @@ bool Cigarette::ControlCamOpenOrClose(int Num,bool OpenOrClose)
pHIKCaptureThread[Num] = new CaptureThreadHIK(camhandle, false,Num);
pHIKCaptureThread[Num]->p_image_queue = g_image_queue[Num];
#ifdef SYNC_CAMERA
pCaptureThread[Num]->p_image_sync_queue = g_image_sync_queue;
pCaptureThread[Num]->p_image_sync_arr = &g_image_sync_arr;
#else
pCaptureThread[Num]->p_image_queue = g_image_queue[Num];
#endif
pHIKCaptureThread[Num]->p_result_queue = g_result_queue[Num];
pHIKCaptureThread[Num]->p_debug_queue = g_debug_queue[Num];
pHIKCaptureThread[Num]->p_result_wait_queue = g_result_wait_queue[Num];

@ -10,7 +10,11 @@
#include "balluffcamera.h"
#include "baslercamera.h"
#include "hikcamera.h"
#ifdef SYNC_CAMERA
#include "syncworkthread.h"
#else
#include "workthread.h"
#endif
#include "db_label.h"
#include "common.h"
#include "modbus.h"
@ -163,7 +167,11 @@ public:
widget_info display_lable_info[NumberOfSupportedCameras][2];
widget_info rotate_info[NumberOfSupportedCameras];
#ifdef SYNC_CAMERA
SyncWorkThread sync_work_thread;
#else
WorkThread work_thread[NumberOfSupportedCameras];
#endif
DebugThread debug_thread[NumberOfSupportedCameras];
struct export_info {

@ -23,6 +23,8 @@
//#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
@ -151,6 +153,20 @@ public:
}
};
#ifdef SYNC_CAMERA
class ImageSyncArr
{
public:
std::mutex lock;
std::vector<std::pair<int, cv::Mat>> image_sync_arr = std::vector<std::pair<int, cv::Mat>>(NumberOfSupportedCameras);
uint8_t collect_cnt;
ImageSyncArr()
{
collect_cnt = 0;
}
};
#endif
//Modbus地址设置
class ModbusConf
{

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

@ -0,0 +1,43 @@
#pragma once
#include <QThread>
#include <QDebug>
#include <QDateTime>
#include <opencv2/opencv.hpp>
#include <opencv2/imgproc/types_c.h>
#include "SyncQueue.h"
#include "ASyncQueue.h"
#include "common.h"
class SyncWorkThread : public QThread
{
Q_OBJECT
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 event_ok(int Num);
void event_ng(int Num);
public:
SyncWorkThread(QObject *parent = 0): QThread(parent)
{
}
~SyncWorkThread();
void init(SyncQueue<std::vector<std::pair<int, cv::Mat>>>* image_ptr, ASyncQueue<bool>* result_ptr);
void start_work();
void stop();
protected:
void run();
public:
int local_camera_number;
SyncQueue<std::vector<std::pair<int, cv::Mat>>>* local_g_image_sync_queue;
ASyncQueue<bool>* local_g_result_queue;
bool b_quit;
long frame_total;
SysConf local_SysConf;
DisplayLabelConf local_DisplayLabelConf;
};
Loading…
Cancel
Save