|
|
#include "QVideoPlayer.h"
|
|
|
#include "VideoStream.h"
|
|
|
#include "RawFileStream.h"
|
|
|
#include "AviFileStream.h"
|
|
|
#include "GDFileStream.h"
|
|
|
#include "QRawFileConfig.h"
|
|
|
#include "Arith_Tracker.h"
|
|
|
#include <fstream>
|
|
|
#include <QHeaderView>
|
|
|
|
|
|
#include <debugExport.h>
|
|
|
#include <qmessagebox.h>
|
|
|
|
|
|
static void QPMap16BitTo8Bit(unsigned short* psh16BitData, long lDataLen, BYTE* pby8BitData)
|
|
|
{
|
|
|
if (psh16BitData == NULL || pby8BitData == NULL || lDataLen <= 0)
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
//指向直方图的数据指针
|
|
|
int* pHist = new int[65536];
|
|
|
memset(pHist, 0, 65536 * sizeof(int));
|
|
|
|
|
|
int i = 0;
|
|
|
for (i = 0; i < lDataLen; i++)
|
|
|
{
|
|
|
pHist[psh16BitData[i]]++;
|
|
|
}
|
|
|
|
|
|
//设置阈值大小为: AreaSigma*图象大小/100
|
|
|
int nSigma = int(0.05 * lDataLen);
|
|
|
int nSum = 0;
|
|
|
int nMin = 0;
|
|
|
int nMax = 0;
|
|
|
|
|
|
//求映射的最大最小值
|
|
|
for (i = 0; i < 65536; i++)
|
|
|
{
|
|
|
nSum += pHist[i];
|
|
|
if (nSum >= nSigma)
|
|
|
{
|
|
|
nMin = i;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
nSum = 0;
|
|
|
for (i = 65535; i >= 0; i--)
|
|
|
{
|
|
|
nSum += pHist[i];
|
|
|
if (nSum >= nSigma)
|
|
|
{
|
|
|
nMax = i;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
//计算对比度亮度
|
|
|
float K = (float)(256.0 / (nMax - nMin + 1));
|
|
|
if (K > 1)
|
|
|
{
|
|
|
K = 1;
|
|
|
}
|
|
|
float C = (float)(128 - K * (nMax + nMin) / 2);
|
|
|
|
|
|
//20190601，调光
|
|
|
SINT32 nBrightMean = 118;
|
|
|
SINT32 nB = 50;
|
|
|
K = (FLOAT32)(200.f / (nMax - nMin + nB));
|
|
|
C = (FLOAT32)(nBrightMean - K * (nMin + nMax) / 2);
|
|
|
|
|
|
//FLOAT32 g_iContrast = 10; //可调，0~100
|
|
|
//FLOAT32 g_iBright = 10; //可调，0~100
|
|
|
K = float(fmax(0.0f, K));
|
|
|
//K = max(0.0f, min(K, 3.0f));
|
|
|
|
|
|
//图像映射
|
|
|
for (i = 0; i < lDataLen; i++)
|
|
|
{
|
|
|
int nValue = (int)(K * psh16BitData[i] + C);
|
|
|
if (nValue < 0)
|
|
|
{
|
|
|
pby8BitData[i] = 0;
|
|
|
}
|
|
|
else if (nValue > 255)
|
|
|
{
|
|
|
pby8BitData[i] = 255;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
pby8BitData[i] = nValue;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
delete[]pHist;
|
|
|
}
|
|
|
|
|
|
QVideoPlayer::QVideoPlayer(QObject *parent)
|
|
|
: QObject(parent)
|
|
|
{
|
|
|
m_VideoStream = NULL;
|
|
|
}
|
|
|
|
|
|
QVideoPlayer::QVideoPlayer(QObject *parent, vector<QImageViewer*> ImageViwerVec,QPlayerControl* pPlayControl, QArithModule* pArithModule)
|
|
|
{
|
|
|
m_ImageViewerVec = ImageViwerVec;
|
|
|
this->m_ImageViewer = ImageViwerVec[0]; //约定第0个显示器为主显示器
|
|
|
this->m_PlayControl = pPlayControl;
|
|
|
this->timer = new QTimer(this);
|
|
|
this->config = new QRawFileConfig();
|
|
|
|
|
|
// 自动播放
|
|
|
connect(timer,&QTimer::timeout,this,&QVideoPlayer::Forward);
|
|
|
|
|
|
// 算法模块
|
|
|
m_ArithRunner = pArithModule;
|
|
|
|
|
|
|
|
|
mArithBusy = false;
|
|
|
|
|
|
// 播放控制
|
|
|
connect(m_PlayControl,&QPlayerControl::sig_Play,this,&QVideoPlayer::Play);
|
|
|
connect(m_PlayControl,&QPlayerControl::sig_Pause,this,&QVideoPlayer::Pause);
|
|
|
connect(m_PlayControl,&QPlayerControl::sig_Stop,this,&QVideoPlayer::Stop);
|
|
|
connect(m_PlayControl,&QPlayerControl::sig_Next,this,&QVideoPlayer::NextFrame);
|
|
|
connect(m_PlayControl,&QPlayerControl::sig_Pre,this,&QVideoPlayer::LastFrame);
|
|
|
connect(m_PlayControl,&QPlayerControl::sig_JumpToFrame,this,&QVideoPlayer::Jump);
|
|
|
connect(m_PlayControl, &QPlayerControl::sig_Recycle, this, &QVideoPlayer::SetRecyle);
|
|
|
connect(m_PlayControl, &QPlayerControl::sig_SkipForward, this, &QVideoPlayer::SkipForward);
|
|
|
connect(m_PlayControl, &QPlayerControl::sig_SkipBackward, this, &QVideoPlayer::SkipBackward);
|
|
|
|
|
|
|
|
|
|
|
|
// 绑定播放与算法线程处理
|
|
|
connect(this, &QVideoPlayer::sig_PlayOneFrame, m_ArithRunner, &QArithModule::ArithRun);
|
|
|
|
|
|
// 算法线程运行完成后发送信号，对结果进行处理
|
|
|
connect(m_ArithRunner, &QArithModule::resultReady, this, &QVideoPlayer::HandleArithDone); //播放器处理判断是否处理完成
|
|
|
|
|
|
// 绑定鼠标点选
|
|
|
connect(m_ImageViewer, &QImageViewer::sig_clcik, m_ArithRunner, &QArithModule::startTrack);
|
|
|
|
|
|
connect(m_ImageViewer, &QImageViewer::sig_rightClick, m_ArithRunner, &QArithModule::cancelTrack);
|
|
|
|
|
|
//GenColorTable(1000);
|
|
|
|
|
|
bRecordingFlag = false;
|
|
|
}
|
|
|
|
|
|
QVideoPlayer::~QVideoPlayer()
|
|
|
{
|
|
|
}
|
|
|
|
|
|
void QVideoPlayer::UpdateInfo()
|
|
|
{
|
|
|
// 绘制帧图像
|
|
|
DrawCurrentFrame();
|
|
|
|
|
|
// 绘制算法结果
|
|
|
DrawArithResult();
|
|
|
|
|
|
// 绘制其他标记
|
|
|
DrawPlayerInfo();
|
|
|
|
|
|
// 记录
|
|
|
if (bRecordingFlag)
|
|
|
{
|
|
|
addScenToVideo();
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
void QVideoPlayer::HandleArithDone()
|
|
|
{
|
|
|
// 标记算法空闲
|
|
|
mArithBusy = false;
|
|
|
|
|
|
// 更新界面
|
|
|
UpdateInfo();
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void QVideoPlayer::SetTableWidget(QTableWidget* pTableWidget)
|
|
|
{
|
|
|
m_TableWidget = pTableWidget;
|
|
|
}
|
|
|
|
|
|
void QVideoPlayer::SetPlotView(QPlotView* pPlotView)
|
|
|
{
|
|
|
m_PlotView = pPlotView;
|
|
|
}
|
|
|
|
|
|
void QVideoPlayer::SetArithResourceView(QResourceView* pResourceView)
|
|
|
{
|
|
|
m_ResourceView = pResourceView;
|
|
|
}
|
|
|
|
|
|
void QVideoPlayer::SetArithInfoTextWindow(QTextBrowser* textWin)
|
|
|
{
|
|
|
m_TextInfo = textWin;
|
|
|
}
|
|
|
|
|
|
void QVideoPlayer::SetCompassInfoWidget(QCompassWidget* compassView)
|
|
|
{
|
|
|
m_CompassWidget = compassView;
|
|
|
}
|
|
|
|
|
|
void QVideoPlayer::SetPanImageWidget(QPanView* panViewer)
|
|
|
{
|
|
|
m_panViewer = panViewer;
|
|
|
}
|
|
|
|
|
|
// 播放视频
|
|
|
void QVideoPlayer::Play()
|
|
|
{
|
|
|
for(int i = 0;i<m_VideoStreamVec.size();i++)
|
|
|
{
|
|
|
auto p_VideoStream = m_VideoStreamVec[i];
|
|
|
if (p_VideoStream)
|
|
|
{
|
|
|
p_VideoStream->Play();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
timer->start(1);
|
|
|
this->m_ImageViewerVec[0]->setFocus();
|
|
|
}
|
|
|
|
|
|
void QVideoPlayer::SetRecyle(bool state)
|
|
|
{
|
|
|
for(int i = 0;i<m_VideoStreamVec.size();i++)
|
|
|
{
|
|
|
auto p_VideoStream = m_VideoStreamVec[i];
|
|
|
if (p_VideoStream)
|
|
|
{
|
|
|
p_VideoStream->EnableCyclePlay(state);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
// 暂停播放
|
|
|
void QVideoPlayer::Pause()
|
|
|
{
|
|
|
for(int i = 0;i<m_VideoStreamVec.size();i++)
|
|
|
{
|
|
|
auto p_VideoStream = m_VideoStreamVec[i];
|
|
|
p_VideoStream->Pause();
|
|
|
}
|
|
|
timer->stop();
|
|
|
}
|
|
|
|
|
|
//
|
|
|
void QVideoPlayer::PlayorPause()
|
|
|
{
|
|
|
for(int i = 0;i<m_VideoStreamVec.size();i++)
|
|
|
{
|
|
|
auto p_VideoStream = m_VideoStreamVec[i];
|
|
|
|
|
|
if (p_VideoStream->GetPlayState() == PS_PLAY)
|
|
|
{
|
|
|
Pause();
|
|
|
}
|
|
|
else if (p_VideoStream->GetPlayState() == PS_PAUSE)
|
|
|
{
|
|
|
Play();
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 停止播放
|
|
|
void QVideoPlayer::Stop()
|
|
|
{
|
|
|
for(int i = 0;i < m_VideoStreamVec.size();i++)
|
|
|
{
|
|
|
auto p_VideoStream = m_VideoStreamVec[i];
|
|
|
if(p_VideoStream != nullptr)
|
|
|
p_VideoStream->Stop();
|
|
|
}
|
|
|
timer->stop();
|
|
|
}
|
|
|
|
|
|
// 前进
|
|
|
void QVideoPlayer::Forward()
|
|
|
{
|
|
|
// 算法如果处于busy，此时不应继续下一帧，直接等待下一帧直到处理完成。
|
|
|
// 主线程不应使用任何阻塞式的等待，如QMutex，否则界面会卡顿，教训！
|
|
|
if (mArithBusy)
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
for(int i = 0;i<m_VideoStreamVec.size();i++)
|
|
|
{
|
|
|
auto p_VideoStream = m_VideoStreamVec[i];
|
|
|
if(p_VideoStream != nullptr)
|
|
|
p_VideoStream->Forward();
|
|
|
}
|
|
|
|
|
|
|
|
|
ProcessFrame();
|
|
|
}
|
|
|
|
|
|
// 后退
|
|
|
void QVideoPlayer::Backward()
|
|
|
{
|
|
|
// 算法如果处于busy，此时不应继续下一帧，直接等待下一帧直到处理完成。
|
|
|
if (mArithBusy)
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
for(int i = 0;i<m_VideoStreamVec.size();i++)
|
|
|
{
|
|
|
auto p_VideoStream = m_VideoStreamVec[i];
|
|
|
p_VideoStream->Backward();
|
|
|
}
|
|
|
|
|
|
ProcessFrame();
|
|
|
}
|
|
|
|
|
|
// 跳帧
|
|
|
void QVideoPlayer::Jump(int ind)
|
|
|
{
|
|
|
for(int i = 0;i<m_VideoStreamVec.size();i++)
|
|
|
{
|
|
|
auto p_VideoStream = m_VideoStreamVec[i];
|
|
|
p_VideoStream->Goto(ind);
|
|
|
}
|
|
|
|
|
|
// 停止自动播放
|
|
|
Pause();
|
|
|
|
|
|
// 仅拖动进度条，只播放视频，不执行算法
|
|
|
//DrawCurrentFrame();
|
|
|
ProcessFrame();
|
|
|
}
|
|
|
|
|
|
// 下一帧
|
|
|
void QVideoPlayer::NextFrame()
|
|
|
{
|
|
|
if (!m_VideoStream)
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 停止自动播放
|
|
|
Pause();
|
|
|
Forward();
|
|
|
}
|
|
|
|
|
|
|
|
|
// 上一帧
|
|
|
void QVideoPlayer::LastFrame()
|
|
|
{
|
|
|
if (!m_VideoStream)
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
// 停止自动播放
|
|
|
Pause();
|
|
|
Backward();
|
|
|
}
|
|
|
|
|
|
// 设置快进倍数
|
|
|
void QVideoPlayer::SkipForward()
|
|
|
{
|
|
|
if (!m_VideoStream)
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
for(int i = 0;i<m_VideoStreamVec.size();i++)
|
|
|
{
|
|
|
auto p_VideoStream = m_VideoStreamVec[i];
|
|
|
p_VideoStream->m_skipFrameCount++;
|
|
|
}
|
|
|
|
|
|
//PrintText(m_ImageViewer, 20, 100, QString::number(m_VideoStream->m_skipFrameCount));
|
|
|
}
|
|
|
|
|
|
// 设置快退倍数
|
|
|
void QVideoPlayer::SkipBackward()
|
|
|
{
|
|
|
if (!m_VideoStream)
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
for(int i = 0;i<m_VideoStreamVec.size();i++)
|
|
|
{
|
|
|
auto p_VideoStream = m_VideoStreamVec[i];
|
|
|
p_VideoStream->m_skipFrameCount--;
|
|
|
}
|
|
|
|
|
|
//PrintText(m_ImageViewer, 20, 100, QString::number(m_VideoStream->m_skipFrameCount));
|
|
|
}
|
|
|
|
|
|
void QVideoPlayer::SetStreams(std::vector<VideoStream*> pStreamList)
|
|
|
{
|
|
|
m_VideoStreamVec = pStreamList;
|
|
|
}
|
|
|
|
|
|
void QVideoPlayer::SetImageViewers(std::vector<QImageViewer*> pImageViwerList)
|
|
|
{
|
|
|
m_ImageViewerVec = pImageViwerList;
|
|
|
}
|
|
|
|
|
|
|
|
|
void QVideoPlayer::Open(QString lpszFileName)
|
|
|
{
|
|
|
// 关闭已打开的视频流
|
|
|
for(int i = 0;i<m_VideoStreamVec.size();i++)
|
|
|
{
|
|
|
auto p_VideoStream = m_VideoStreamVec[i];
|
|
|
|
|
|
if (p_VideoStream == nullptr)
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
if(p_VideoStream->IsOpen())
|
|
|
{
|
|
|
delete p_VideoStream;//释放视频流
|
|
|
p_VideoStream = nullptr;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
m_ArithRunner->setEnable(false);// 算法停止
|
|
|
Stop();//播放器停止
|
|
|
m_PlayControl->setStream(NULL);
|
|
|
m_ArithRunner->Log_Off();//日志关闭
|
|
|
m_VideoStreamVec.clear();
|
|
|
|
|
|
|
|
|
// 打开一路，并加入视频流组
|
|
|
m_VideoStreamVec.push_back(OpenOneStream(lpszFileName));
|
|
|
|
|
|
m_VideoStream = m_VideoStreamVec[0];
|
|
|
|
|
|
|
|
|
// 保存文件名
|
|
|
m_FileFullPath = lpszFileName;
|
|
|
|
|
|
// 播放控制：设置视频流 进度条绑定第一个流
|
|
|
m_PlayControl->setStream(m_VideoStreamVec[0]);
|
|
|
m_PlayControl->setUpdatesEnabled(true);
|
|
|
|
|
|
// 清空视场
|
|
|
m_ImageViewer->InitView();
|
|
|
|
|
|
// 初始化日志
|
|
|
m_ArithRunner->Log_On(m_FileFullPath);
|
|
|
|
|
|
// 开始播放
|
|
|
Play();
|
|
|
|
|
|
m_ArithRunner->setEnable(true);// 算法开始执行
|
|
|
m_ArithRunner->m_streamVec = m_VideoStreamVec;//设置算法运行的数据流
|
|
|
if (m_VideoStreamVec[0] != nullptr)
|
|
|
{
|
|
|
m_ArithRunner->ArithInit(m_VideoStreamVec);//算法初始化
|
|
|
}
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
VideoStream* QVideoPlayer::OpenOneStream(QString lpszFileName)
|
|
|
{
|
|
|
// 打开一路
|
|
|
string extName = GetVideoFileExt(lpszFileName.toStdString());
|
|
|
VideoStream* pVid = NULL;
|
|
|
|
|
|
if(extName == "avi" || extName == "mp4" || extName == "MP4" )
|
|
|
{
|
|
|
pVid = new AviFileStream();
|
|
|
}
|
|
|
else if (extName == "GD")
|
|
|
{
|
|
|
pVid = new GDFileStream();
|
|
|
}
|
|
|
else if(extName == "raw" || extName == "xraw" || extName == "rawx" || extName == "yuv")
|
|
|
{
|
|
|
// 在当前路径下寻找raw文件默认配置
|
|
|
int first = lpszFileName.lastIndexOf("/");
|
|
|
QString fileDir = lpszFileName.left(first);
|
|
|
config->readDefaultSetings(fileDir);
|
|
|
|
|
|
bool reply = config->exec();//阻塞
|
|
|
|
|
|
if(reply == false)
|
|
|
{
|
|
|
return nullptr;
|
|
|
}
|
|
|
|
|
|
|
|
|
pVid = new RawFileStream(config->GetParaConfig());
|
|
|
|
|
|
// 例外
|
|
|
if (extName == "xraw" || extName == "rawx")
|
|
|
{
|
|
|
pVid->SetStreamType(eDSST_XRAW);
|
|
|
}
|
|
|
|
|
|
config->saveDefaultSetings(fileDir);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
return nullptr;
|
|
|
}
|
|
|
|
|
|
// 打开视频
|
|
|
//m_VideoStream->Open(lpszFileName.toStdString());
|
|
|
pVid->Open(std::string(lpszFileName.toLocal8Bit()));
|
|
|
|
|
|
return pVid;
|
|
|
}
|
|
|
|
|
|
void QVideoPlayer::ProcessFrame()
|
|
|
{
|
|
|
// 算法置于忙
|
|
|
mArithBusy = true;
|
|
|
|
|
|
// 发出播放一帧信号，通知算法运行
|
|
|
emit sig_PlayOneFrame();
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
cv::Mat QVideoPlayer::getFrame(VideoStream* pStream)
|
|
|
{
|
|
|
cv::Mat varImg;
|
|
|
if (!pStream) {
|
|
|
return varImg;
|
|
|
}
|
|
|
BYTE* pData = pStream->GetFrameImageBuffer();
|
|
|
|
|
|
if (pData == nullptr)
|
|
|
{
|
|
|
return varImg;
|
|
|
}
|
|
|
int nWidth = pStream->GetImageWidth();
|
|
|
int nHeight = pStream->GetImageHeight();
|
|
|
PIXEL_TYPE type = pStream->GetPixelType();
|
|
|
if (type == PT_RGB8)
|
|
|
{
|
|
|
varImg = cv::Mat(nHeight, nWidth, CV_8UC1, pData);
|
|
|
}
|
|
|
else if (type == PT_RGB24)
|
|
|
{
|
|
|
varImg = cv::Mat(nHeight, nWidth, CV_8UC3, pData);
|
|
|
|
|
|
if (pStream->GetStreamType() == eDSST_RAW)
|
|
|
{
|
|
|
cv::cvtColor(varImg, varImg, COLOR_BGR2RGB);
|
|
|
}
|
|
|
|
|
|
}
|
|
|
else if (type == PT_Y16DATA)
|
|
|
{
|
|
|
varImg = cv::Mat(nHeight, nWidth, CV_16UC1, pData);
|
|
|
///*> 自定义调光，以8位显示 */
|
|
|
//cv::Mat varImg1(nHeight, nWidth, CV_8UC1);
|
|
|
//QPMap16BitTo8Bit((unsigned short*)pData, nHeight * nWidth, varImg1.data);
|
|
|
//varImg = varImg1.clone();
|
|
|
}
|
|
|
else if (type == PT_UY16DATA)
|
|
|
{
|
|
|
varImg = cv::Mat(nHeight, nWidth, CV_16UC1, pData);
|
|
|
}
|
|
|
else if (type == PT_RGB32)
|
|
|
{
|
|
|
varImg = cv::Mat(nHeight, nWidth, CV_8UC4, pData);
|
|
|
}
|
|
|
else if (type == PT_YUV_UYVY)
|
|
|
{
|
|
|
|
|
|
cv::Mat src(nHeight, nWidth, CV_8UC2, pData);
|
|
|
cv::cvtColor(src, varImg, cv::COLOR_YUV2BGR_UYVY);
|
|
|
//cv::Mat varImg1(nHeight, nWidth, CV_8UC1);
|
|
|
|
|
|
//for (int i = 0; i < nHeight * nWidth; i++)
|
|
|
//{
|
|
|
// varImg1.data[i] = pData[2 * i + 1];
|
|
|
//}
|
|
|
|
|
|
//varImg = varImg1.clone();
|
|
|
|
|
|
}
|
|
|
else if (type == PT_YUV_NV12)
|
|
|
{
|
|
|
cv::Mat src(nHeight * 1.5, nWidth, CV_8UC1, pData);
|
|
|
cv::cvtColor(src, varImg, cv::COLOR_YUV2BGR_NV12);
|
|
|
}
|
|
|
|
|
|
|
|
|
return varImg;
|
|
|
}
|
|
|
|
|
|
void QVideoPlayer::DrawCurrentFrame()
|
|
|
{
|
|
|
for(int i = 0;i<m_VideoStreamVec.size();i++)
|
|
|
{
|
|
|
auto p_VideoStream = m_VideoStreamVec[i];
|
|
|
|
|
|
auto p_ImageViewer = m_ImageViewerVec[i];
|
|
|
|
|
|
if (p_VideoStream == nullptr)
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
BYTE* pData = p_VideoStream->GetFrameImageBuffer();
|
|
|
|
|
|
if (pData == nullptr)
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
int nWidth = p_VideoStream->GetImageWidth();
|
|
|
int nHeight = p_VideoStream->GetImageHeight();
|
|
|
PIXEL_TYPE type = p_VideoStream->GetPixelType();
|
|
|
|
|
|
cv::Mat mat = getFrame(p_VideoStream);
|
|
|
p_ImageViewer->DrawCVImage(mat);
|
|
|
}
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
void QVideoPlayer::DrawArithResult()
|
|
|
{
|
|
|
// 未开启任何算法，不执行绘制
|
|
|
if(nArithVer == 0 || m_VideoStream == nullptr)
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
// 更新指南针
|
|
|
UpdateCompass(m_stInputPara.stServoInfo.fServoAz, m_stInputPara.stServoInfo.fServoPt);
|
|
|
|
|
|
// 打印信息
|
|
|
PrintInfo();
|
|
|
|
|
|
// 表格
|
|
|
PrintTableInfo();
|
|
|
|
|
|
// 导引信息
|
|
|
DrawGuideRect();
|
|
|
|
|
|
// 绘制单帧检测(外部传入)
|
|
|
if (bEnableDrawFrameDetect)
|
|
|
{
|
|
|
DrawFrameDetectObjs();
|
|
|
|
|
|
//绘制小目标极值点
|
|
|
//DrawDSTPoint(m_ImageViewer);
|
|
|
}
|
|
|
|
|
|
// 绘制跟踪阶段单帧检测(跟踪模块内部检测)
|
|
|
//if (bEnableDrawTrackDet)
|
|
|
//{
|
|
|
// //DrawFrameRegionDetectObjs();
|
|
|
//}
|
|
|
|
|
|
// 绘制管道告警目标
|
|
|
DrawAlarmTarget();
|
|
|
|
|
|
// 绘制管道跟踪信息
|
|
|
DrawTrackersInfo();
|
|
|
|
|
|
// 绘制管道轨迹
|
|
|
DrawPipeAglInfo();
|
|
|
|
|
|
// 绘制引导、视场外锁定信息
|
|
|
DrawGuideRect();
|
|
|
|
|
|
|
|
|
// 扫描模式下更新全景图
|
|
|
if (m_stOutput.nSysMode == GLB_SYS_FSCAN)
|
|
|
{
|
|
|
UpdatePanImage();
|
|
|
}
|
|
|
|
|
|
// 绘制siamRPN
|
|
|
DrawAITrackerInfo();
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
void QVideoPlayer::DrawDSPResult()
|
|
|
{
|
|
|
|
|
|
}
|
|
|
|
|
|
void QVideoPlayer::DrawPlayerInfo()
|
|
|
{
|
|
|
// 录像
|
|
|
QGraphicsScene* scene = m_ImageViewer->imgScene;
|
|
|
|
|
|
if (bRecordingFlag)
|
|
|
{
|
|
|
if(m_VideoStream->GetCurrentFrameIndex() % 10 < 5)
|
|
|
scene->addEllipse(QRectF(-20, 0, 10, 10), QPen(QColor(255, 0, 0)),QBrush(QColor(255, 0, 0),Qt::SolidPattern));
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
void QVideoPlayer::PrintText(QImageViewer* view, int x, int y, QString str)
|
|
|
{
|
|
|
QGraphicsScene* scene = view->imgScene;
|
|
|
auto text = scene->addSimpleText(str);
|
|
|
|
|
|
text->setPos(x, y);
|
|
|
QFont ft; ft.setPointSize(4); ft.setBold(1);
|
|
|
text->setBrush(QBrush(QColor(255,255,0)));
|
|
|
text->setFont(ft);
|
|
|
}
|
|
|
|
|
|
void QVideoPlayer::PrintText(QImageViewer* view, int x, int y, QString str, QBrush brush)
|
|
|
{
|
|
|
QGraphicsScene* scene = view->imgScene;
|
|
|
auto text = scene->addSimpleText(str);
|
|
|
|
|
|
text->setPos(x, y);
|
|
|
QFont ft; ft.setPointSize(7); ft.setBold(1);
|
|
|
text->setBrush(brush);
|
|
|
text->setFont(ft);
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void QVideoPlayer::DrawArtRect(QImageViewer* view, QPen pen, QRect rect, QString str, bool bCenter,int minSize = 10,QColor fontColor = QColor(255,0,0))
|
|
|
{
|
|
|
QGraphicsScene* scene = view->imgScene;
|
|
|
|
|
|
int cx = rect.x() + rect.width() * 0.5;
|
|
|
int cy = rect.y() + rect.height() * 0.5;
|
|
|
int w = MAX(rect.width(), minSize);
|
|
|
int h = MAX(rect.height(), minSize);
|
|
|
|
|
|
|
|
|
scene->addLine(cx - w * 0.5, cy - h * 0.5, cx - w * 0.25, cy - h * 0.5, pen);
|
|
|
scene->addLine(cx + w * 0.25, cy - h * 0.5, cx + w * 0.5, cy - h * 0.5, pen);
|
|
|
scene->addLine(cx - w * 0.5, cy + h * 0.5, cx - w * 0.25, cy + h * 0.5, pen);
|
|
|
scene->addLine(cx + w * 0.25, cy + h * 0.5, cx + w * 0.5, cy + h * 0.5, pen);
|
|
|
|
|
|
scene->addLine(cx - w * 0.5, cy - h * 0.5, cx - w * 0.5, cy - h * 0.25, pen);
|
|
|
scene->addLine(cx - w * 0.5, cy + h * 0.25, cx - w * 0.5, cy + h * 0.5, pen);
|
|
|
scene->addLine(cx + w * 0.5, cy - h * 0.5, cx + w * 0.5, cy - h * 0.25, pen);
|
|
|
scene->addLine(cx + w * 0.5, cy + h * 0.25, cx + w * 0.5, cy + h * 0.5, pen);
|
|
|
|
|
|
|
|
|
auto text = scene->addSimpleText(str);
|
|
|
text->setPos(QPoint(rect.x() - 10, rect.y() - 10));
|
|
|
QFont ft; ft.setPointSize(8); ft.setBold(0);
|
|
|
text->setBrush(QBrush(fontColor));
|
|
|
text->setFont(ft);
|
|
|
}
|
|
|
|
|
|
void QVideoPlayer::DrawTrackersInfo()
|
|
|
{
|
|
|
QGraphicsScene* scene = m_ImageViewer->imgScene;
|
|
|
|
|
|
int num = m_stOutput.nTrackObjCnts;
|
|
|
|
|
|
for (size_t i = 0; i < num; i++)
|
|
|
{
|
|
|
auto obj = &m_stOutput.stTrackers[i];
|
|
|
|
|
|
auto SA_SizeType = m_stOutput.stTrackers[i].SA_SizeType;
|
|
|
auto fconf = m_stOutput.stTrackers[i].fConf;
|
|
|
auto src = m_stOutput.stTrackers[i].ArithSrc;
|
|
|
auto status = m_stOutput.stTrackers[i].unTrackingStatus;
|
|
|
auto lostCnt = m_stOutput.stTrackers[i].nPipeLostCnt;
|
|
|
|
|
|
auto nInPipesID = m_stOutput.stTrackers[i].nInPipesID;
|
|
|
|
|
|
|
|
|
GLB_SCEN_MODE m_type = ARIDLL_ExportTrkSceneMode(pEOTracker, obj->nInPipesID);
|
|
|
// 绘制TLD检测
|
|
|
RECT32S RC = TLD_GetBestNNRect(pEOTracker, obj->nInPipesID);
|
|
|
|
|
|
//Tracker_Ptr pTracker = ARIDLL_ExportTrackerPtr(pEOTracker, obj->nInPipesID);
|
|
|
|
|
|
|
|
|
if (m_type == GLB_SCEN_GROUND && true == bShowDebugMode)
|
|
|
{
|
|
|
//RECT32S RC = pTracker->pGroundTracker->m_pTLDTracker->TLD_GetBestNNRect();
|
|
|
//SINT32 nTLDClusterNum = pTracker->pGroundTracker->m_pTLDTracker->TLD_GetPara()->nClusterNum;
|
|
|
//for (size_t i = 0; i < nTLDClusterNum; i++)
|
|
|
{
|
|
|
//QRectF clusterRect(RC[i].x, RC[i].y, RC[i].w, RC[i].h);
|
|
|
QRectF clusterRect(RC.x, RC.y, RC.w, RC.h);
|
|
|
scene->addRect(clusterRect, QPen(QColor(255, 255, 255), 1));
|
|
|
}
|
|
|
|
|
|
//绘制AID监控框信息
|
|
|
SINT32 nNeighborCnt = 0;
|
|
|
RECT16S* RM = ARIDLL_AID_GetObservInfo(pEOTracker, obj->nInPipesID, nNeighborCnt);
|
|
|
if (NULL != RM && RM->w > 0 && RM->h > 0)
|
|
|
{
|
|
|
QRectF AIDMonitorBox(RM->x, RM->y, RM->w, RM->h);
|
|
|
scene->addRect(AIDMonitorBox, QPen(QColor(255, 255, 255), 0.5));
|
|
|
QString str = QString(_S("观测区_%1")).arg(nNeighborCnt);
|
|
|
PrintText(m_ImageViewer, RM->x, RM->y - 10, str, QBrush(Qt::white));
|
|
|
}
|
|
|
|
|
|
//绘制AID重捕框信息
|
|
|
if (MEM_TRACKING == status)
|
|
|
{
|
|
|
RECT16S* RC = ARIDLL_AID_GetRecapRect(pEOTracker, obj->nInPipesID);
|
|
|
if (NULL != RC && RC->w > 0 && RC->h > 0)
|
|
|
{
|
|
|
QRectF AIDRecapBox(RC->x, RC->y, RC->w, RC->h);
|
|
|
|
|
|
scene->addRect(AIDRecapBox, QPen(QColor(0, 0, 0), 0.8));
|
|
|
QString str = _S("重捕区");
|
|
|
PrintText(m_ImageViewer, RC->x, RC->y - 10, str, QBrush(Qt::white));
|
|
|
}
|
|
|
}
|
|
|
auto tldBox = m_stOutput.stTrackers[i].TLD_SrBox;
|
|
|
QRectF qtldBox(tldBox.x, tldBox.y, tldBox.w, tldBox.h);
|
|
|
// 绘制TLD波门
|
|
|
scene->addRect(qtldBox, QPen(QColor(0, 0, 255), 0.5));
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
if (GLB_SCEN_MODE::GLB_SCEN_SKY == m_type)
|
|
|
{
|
|
|
DrawTrackSegResults(m_ImageViewerVec[5], pEOTracker, obj->nInPipesID);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
// 绘制当前跟踪框
|
|
|
int cx = obj->nX;
|
|
|
int cy = obj->nY;
|
|
|
int w = obj->nObjW;
|
|
|
int h = obj->nObjH;
|
|
|
QRect bbox(cx - w / 2, cy - h / 2, w, h);
|
|
|
QString str;
|
|
|
QString str1;
|
|
|
if (true == bShowDebugMode)
|
|
|
{
|
|
|
str = QString::number(obj->nOutputID);
|
|
|
}
|
|
|
DrawArtRect(m_ImageViewer, QPen(QColor(255, 0, 0)), bbox, str, false,15, QColor(255,0,0));
|
|
|
|
|
|
|
|
|
// 绘制跟踪波门
|
|
|
if (true == bShowDebugMode)
|
|
|
{
|
|
|
auto sabox = m_stOutput.stTrackers[i].SA_SrBox;
|
|
|
auto kcfBox = m_stOutput.stTrackers[i].KCF_SrBox;
|
|
|
auto tldBox = m_stOutput.stTrackers[i].TLD_SrBox;
|
|
|
|
|
|
|
|
|
QRectF qsabox(sabox.x, sabox.y, sabox.w, sabox.h);
|
|
|
QRectF qkcfBox(kcfBox.x, kcfBox.y, kcfBox.w, kcfBox.h);
|
|
|
QRectF qtldBox(tldBox.x, tldBox.y, tldBox.w, tldBox.h);
|
|
|
|
|
|
|
|
|
// 绘制SA波门
|
|
|
if (SA_SizeType == SizeType::AreaTarget)
|
|
|
{
|
|
|
scene->addRect(qsabox, QPen(QBrush(QColor(255, 255, 255)), 0.3, Qt::DashLine));
|
|
|
}
|
|
|
else if (SA_SizeType == SizeType::SmallTarget)
|
|
|
{
|
|
|
scene->addRect(qsabox, QPen(QColor(0, 0, 255), 0.3, Qt::DashLine));
|
|
|
}
|
|
|
else if (SA_SizeType == SizeType::MiddleTarget)
|
|
|
{
|
|
|
scene->addRect(qsabox, QPen(QColor(25, 25, 205), 0.3, Qt::DashLine));
|
|
|
}
|
|
|
else if (SA_SizeType == SizeType::DimTarget)
|
|
|
{
|
|
|
scene->addRect(qsabox, QPen(QColor(68, 68, 205), 0.3, Qt::DashLine));
|
|
|
}
|
|
|
|
|
|
// 绘制KCF波门--黄色
|
|
|
scene->addRect(qkcfBox, QPen(QColor(255, 255, 0), 0.5));
|
|
|
|
|
|
// 绘制TLD波门
|
|
|
scene->addRect(qtldBox, QPen(QColor(0, 0, 255), 0.5));
|
|
|
|
|
|
// 显示状态字符
|
|
|
str = QString(_S("ID:%1 conf：%2,Src:%3,mem:%4")).arg(obj->nOutputID).arg(QString::number(fconf, 'f', 3)).arg(src).arg(lostCnt);
|
|
|
|
|
|
str1 = QString(_S("type:%1")).arg(obj->unClsType);
|
|
|
if (obj->nOutputID >= 2)
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
auto text = scene->addSimpleText(str);
|
|
|
auto text1 = scene->addSimpleText(str1);
|
|
|
|
|
|
if (sabox.w == 0 || sabox.h == 0)
|
|
|
{
|
|
|
text->setPos(QPoint(kcfBox.x - 10, kcfBox.y - 10));
|
|
|
text1->setPos(QPoint(kcfBox.x - 10, kcfBox.y + kcfBox.h + 10));
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
text->setPos(QPoint(sabox.x - 10, sabox.y - 10));
|
|
|
text1->setPos(QPoint(sabox.x - 10, sabox.y + sabox.h + 10));
|
|
|
}
|
|
|
QFont ft; ft.setPointSize(8);
|
|
|
text->setBrush(QBrush(QColor(Qt::red)));
|
|
|
text->setFont(ft);
|
|
|
}
|
|
|
|
|
|
if (bEnableDrawTrackDet)
|
|
|
{
|
|
|
// 查询跟踪阶段目标列表
|
|
|
DrawFrameRegionDetectObjs();
|
|
|
|
|
|
// 绘制小目标极值点
|
|
|
//POINT16S* pList = ARIDLL_GetSATracker_DSTPoint(m_ArithRunner->pEOTracker, nInPipesID);
|
|
|
|
|
|
//for (size_t i = 0; i < (640 / 16 * 512 / 16) * 2; i++)
|
|
|
//{
|
|
|
// auto p = pList[i];
|
|
|
// if (p.x > 0 && p.y > 0)
|
|
|
// {
|
|
|
// DrawCrossInImage(m_ImageViewer, QRect(p.x - 2, p.y - 2, 4, 4), QPen(QColor(100, 100, 34)));
|
|
|
// }
|
|
|
//}
|
|
|
}
|
|
|
|
|
|
if (bEnableDrawFastMatcher)
|
|
|
{
|
|
|
DrawFrameMatcherDetectObjs();
|
|
|
}
|
|
|
|
|
|
}
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
|
|
|
void QVideoPlayer::DrawLostInfo()
|
|
|
{
|
|
|
return;
|
|
|
|
|
|
}
|
|
|
|
|
|
void QVideoPlayer::DrawFrameDetectObjs()
|
|
|
{
|
|
|
QGraphicsScene* scene = m_ImageViewer->imgScene;
|
|
|
|
|
|
GLB_SCEN_MODE m_SceneType = ARIDLL_ExportSceneMode(pEOTracker);
|
|
|
|
|
|
if (GLB_SCEN_MODE::GLB_SCEN_SKY == m_SceneType)
|
|
|
{
|
|
|
int SANum = 0;
|
|
|
TARGET_OBJECT* pFrameTargetArray = ARIDLL_GetFullSATarget(pEOTracker, SANum);
|
|
|
for (size_t i = 0; i < SANum; ++i)
|
|
|
{
|
|
|
auto obj = &pFrameTargetArray[i];
|
|
|
|
|
|
int cx = obj->pfCenPos.x;
|
|
|
int cy = obj->pfCenPos.y;
|
|
|
int w = MAX(10, obj->snSize.w);
|
|
|
int h = MAX(10, obj->snSize.h);
|
|
|
//int w = obj->snSize.w;
|
|
|
//int h = obj->snSize.h;
|
|
|
|
|
|
QRectF bbox(cx - w / 2, cy - h / 2, w, h);
|
|
|
scene->addRect(bbox, QPen(QColor(255, 20, 147), 0.3));
|
|
|
}
|
|
|
}
|
|
|
int num = m_Dll_RecordInput.nInputAINum;
|
|
|
for (size_t i = 0; i < num; ++i)
|
|
|
{
|
|
|
auto obj = &m_Dll_RecordInput.stInputAI[i];
|
|
|
//int w = MAX(15, obj->snSize.w);
|
|
|
//int h = MAX(15, obj->snSize.h);
|
|
|
int w = obj->x2 - obj->x1;
|
|
|
int h = obj->y2 - obj->y1;
|
|
|
|
|
|
QRectF bbox(obj->x1, obj->y1, w, h);
|
|
|
scene->addRect(bbox, QPen(QColor(255, 147, 20), 0.3));
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void QVideoPlayer::DrawFrameRegionDetectObjs()
|
|
|
{
|
|
|
QGraphicsScene* scene = m_ImageViewer->imgScene;
|
|
|
auto obj = &m_stOutput.stTrackers[0];
|
|
|
//Tracker_Ptr pTracker = ARIDLL_ExportTrackerPtr(pEOTracker, obj->nInPipesID);
|
|
|
//if (NULL == pTracker)
|
|
|
//{
|
|
|
// return;
|
|
|
//}
|
|
|
TSky_Output* pSky_Output = GetSkyTrackerObjectStatus(pEOTracker, obj->nInPipesID);
|
|
|
// 如果是对空跟踪场景
|
|
|
if (NULL != pSky_Output)
|
|
|
{
|
|
|
QString str;
|
|
|
for (size_t i = 0; i < pSky_Output->m_nTargetNum; i++)
|
|
|
{
|
|
|
auto obj = &pSky_Output->mTarget_Array[i];
|
|
|
|
|
|
int cx = obj->pfCenPos.x;
|
|
|
int cy = obj->pfCenPos.y;
|
|
|
//int w = MAX(15, obj->snSize.w);
|
|
|
//int h = MAX(15, obj->snSize.h);
|
|
|
int w = obj->snSize.w;
|
|
|
int h = obj->snSize.h;
|
|
|
QRectF bbox(cx - w / 2, cy - h / 2, w, h);
|
|
|
scene->addRect(bbox, QPen(QColor(20, 255, 147), 0.3));
|
|
|
str = QString::number(obj->fMatchConf, 'f', 2);
|
|
|
auto text = scene->addSimpleText(str);
|
|
|
text->setPos(QPoint(bbox.x() - 3, bbox.y() - 3));
|
|
|
QFont ft; ft.setPointSize(5);
|
|
|
text->setBrush(QBrush(QColor(Qt::black)));
|
|
|
text->setFont(ft);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void QVideoPlayer::DrawFrameMatcherDetectObjs()
|
|
|
{
|
|
|
QGraphicsScene* scene = m_ImageViewer->imgScene;
|
|
|
auto obj = &m_stOutput.stTrackers[0];
|
|
|
|
|
|
TSky_Output* pSky_Output = GetSkyTrackerObjectStatus(pEOTracker, obj->nInPipesID);
|
|
|
// 如果是对空跟踪场景
|
|
|
if (NULL != pSky_Output)
|
|
|
{
|
|
|
QString str;
|
|
|
for (size_t i = 0; i < pSky_Output->m_nMatcherNum; i++)
|
|
|
{
|
|
|
MATCHER_TARGET *obj = &pSky_Output->mMatcher_Array[i];
|
|
|
|
|
|
int cx = obj->pfCenPos.x;
|
|
|
int cy = obj->pfCenPos.y;
|
|
|
//int w = MAX(15, obj->snSize.w);
|
|
|
//int h = MAX(15, obj->snSize.h);
|
|
|
int w = obj->snSize.w;
|
|
|
int h = obj->snSize.h;
|
|
|
QRectF bbox(cx - w / 2, cy - h / 2, w, h);
|
|
|
scene->addRect(bbox, QPen(QColor(0, 255, 255), 0.3));
|
|
|
str = QString::number(obj->fDetConf, 'f', 2);
|
|
|
auto text = scene->addSimpleText(str);
|
|
|
text->setPos(QPoint(bbox.x() - 3, bbox.y() - 3));
|
|
|
QFont ft; ft.setPointSize(5);
|
|
|
text->setBrush(QBrush(QColor(Qt::white)));
|
|
|
text->setFont(ft);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
void QVideoPlayer::UpdateCompass(float fAz, float fPt)
|
|
|
{
|
|
|
m_CompassWidget->updateDir(fAz, fPt);
|
|
|
}
|
|
|
|
|
|
void QVideoPlayer::DrawArithResourceOccupy()
|
|
|
{
|
|
|
|
|
|
}
|
|
|
|
|
|
void QVideoPlayer::DrawDetectionsInfo()
|
|
|
{
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
void QVideoPlayer::PrintTableInfo()
|
|
|
{
|
|
|
// 初始化表头
|
|
|
QStringList headerText;
|
|
|
headerText << _S("批号") << _S("方位")<< _S("俯仰") << _S("预测方位") << _S("预测俯仰") << _S("管道Ind") << _S("检测情况D/InFOV/ALL")<< _S("ClassID");
|
|
|
m_TableWidget->setColumnCount(headerText.count());
|
|
|
QTableWidgetItem* headerItem;
|
|
|
for (int i = 0; i < m_TableWidget->columnCount(); i++)
|
|
|
{
|
|
|
headerItem = new QTableWidgetItem(headerText.at(i));
|
|
|
QFont font = headerItem->font();
|
|
|
font.setBold(true);
|
|
|
font.setPointSize(12);
|
|
|
//headerItem->setTextColor(Qt::blue);
|
|
|
headerItem->setFont(font);
|
|
|
m_TableWidget->setHorizontalHeaderItem(i, headerItem);
|
|
|
}
|
|
|
//m_TableWidget->horizontalHeader()->setSectionResizeMode(0, QHeaderView::Stretch);
|
|
|
//m_TableWidget->horizontalHeader()->setSectionResizeMode(1, QHeaderView::Stretch);
|
|
|
|
|
|
|
|
|
ARIDLL_OBJINFO* stAlarmObjs = m_stOutput.stAlarmObjs;
|
|
|
auto* stTrackObjs = m_stOutput.stTrackers;
|
|
|
//管道信息
|
|
|
auto pPipeArray = ARIDLL_ExportPipeArrayPtr(pEOTracker);
|
|
|
//auto PipeNum = m_ArithRunner->m_stOutput.stDebugInfo.nMaxPipeNum;
|
|
|
|
|
|
|
|
|
|
|
|
int validObjNum = 0;
|
|
|
int index = 0;
|
|
|
// 输出跟踪目标
|
|
|
for (size_t i = 0; i < 10; i++)
|
|
|
{
|
|
|
auto obj = &stTrackObjs[i];
|
|
|
if (obj->nObjW == 0)
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
index = 0;
|
|
|
// 目标在管道位置，输出更多信息
|
|
|
PIPE* pPipe = &pPipeArray[obj->nInPipesID];
|
|
|
|
|
|
m_TableWidget->setItem(validObjNum, index++, new QTableWidgetItem(QString::number(obj->nOutputID)));
|
|
|
m_TableWidget->setItem(validObjNum, index++, new QTableWidgetItem(QString("%1").arg(obj->fAz)));
|
|
|
m_TableWidget->setItem(validObjNum, index++, new QTableWidgetItem(QString("%1").arg(obj->fPt)));
|
|
|
|
|
|
m_TableWidget->setItem(validObjNum, index++, new QTableWidgetItem(QString("%1").arg(pPipe->afCurrentAgl.fAz)));
|
|
|
m_TableWidget->setItem(validObjNum, index++, new QTableWidgetItem(QString("%1").arg(pPipe->afCurrentAgl.fPt)));
|
|
|
|
|
|
m_TableWidget->setItem(validObjNum, index++, new QTableWidgetItem(QString::number(obj->nInPipesID)));
|
|
|
m_TableWidget->setItem(validObjNum, index++, new QTableWidgetItem(QString("[%1 / %2 / %3]").
|
|
|
arg(pPipe->unExistCnt).arg(pPipe->unInsideFOVCnt).arg(pPipe->unTotalCnt)));
|
|
|
|
|
|
validObjNum++;
|
|
|
|
|
|
}
|
|
|
|
|
|
// 输出告警目标
|
|
|
for (size_t i = 0; i < 50; i++)
|
|
|
{
|
|
|
auto obj = &stAlarmObjs[i];
|
|
|
if (stAlarmObjs[i].nObjW == 0)
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
index = 0;
|
|
|
// 目标在管道位置，输出更多信息
|
|
|
PIPE* pPipe = &pPipeArray[obj->nInPipesID];
|
|
|
|
|
|
m_TableWidget->setItem(validObjNum, index++, new QTableWidgetItem(QString::number(obj->nOutputID)));
|
|
|
m_TableWidget->setItem(validObjNum, index++, new QTableWidgetItem(QString("%1").arg(obj->fAz)));
|
|
|
m_TableWidget->setItem(validObjNum, index++, new QTableWidgetItem(QString("%1").arg(obj->fPt)));
|
|
|
|
|
|
m_TableWidget->setItem(validObjNum, index++, new QTableWidgetItem(QString("%1").arg(pPipe->afCurrentAgl.fAz)));
|
|
|
m_TableWidget->setItem(validObjNum, index++, new QTableWidgetItem(QString("%1").arg(pPipe->afCurrentAgl.fPt)));
|
|
|
|
|
|
m_TableWidget->setItem(validObjNum, index++, new QTableWidgetItem(QString::number(obj->nInPipesID)));
|
|
|
m_TableWidget->setItem(validObjNum, index++, new QTableWidgetItem(QString("[%1 / %2 / %3]").
|
|
|
arg(pPipe->unExistCnt).arg(pPipe->unInsideFOVCnt).arg(pPipe->unTotalCnt)));
|
|
|
|
|
|
validObjNum++;
|
|
|
}
|
|
|
|
|
|
m_TableWidget->setRowCount(validObjNum);
|
|
|
}
|
|
|
|
|
|
void QVideoPlayer::PrintSkyInfo(QString str, QString strShow, ArithHandle hArithSrc, ARIDLL_OBJINFO* obj, GLB_OUTPUT out, ARIDLL_DEBUG_OUTPUT g_DbugOut)
|
|
|
{
|
|
|
////QString str1 = "<font color=\"#FF0000\">" + "1111" + "</font>";
|
|
|
|
|
|
//GLB_OUTPUT out = getGLBoutput();
|
|
|
//str = QString(_S("干扰弹：%1")).arg(out.stEvent.JMBMonitor.bJammingBombLaunch);
|
|
|
//strShow = "<font color=\"#FF0000\">" + str + "</font>";
|
|
|
//m_TextInfo->append(strShow);
|
|
|
|
|
|
|
|
|
//// 在图像上打印，用于录像
|
|
|
////int y0 = 20;
|
|
|
////if (!out.stEvent.JMBMonitor.bJammingBombLaunch)
|
|
|
////{
|
|
|
//// str = _S("抗干扰：无");
|
|
|
//// PrintText(m_ImageViewer, 0, y0, str,QBrush(Qt::green));
|
|
|
//// y0 += 20;
|
|
|
////}
|
|
|
////else
|
|
|
////{
|
|
|
//// str = _S("抗干扰：干扰弹事件");
|
|
|
//// if (out.stEvent.JMBMonitor.bReFindFlag)
|
|
|
//// {
|
|
|
//// str = _S("抗干扰：重捕模块激活……");
|
|
|
//// }
|
|
|
//// PrintText(m_ImageViewer, 0, y0, str, QBrush(Qt::red));
|
|
|
//// y0 += 20;
|
|
|
////}
|
|
|
//int y0 = 20;
|
|
|
//if (out.stEvent.JMBMonitor.bJammingBombLaunch)
|
|
|
//{
|
|
|
// str = _S("抗干扰：干扰弹事件");
|
|
|
// if (out.stEvent.JMBMonitor.bReFindFlag)
|
|
|
// {
|
|
|
// str = _S("抗干扰：重捕");
|
|
|
// }
|
|
|
// PrintText(m_ImageViewer, 0, y0, str, QBrush(Qt::red));
|
|
|
// y0 += 20;
|
|
|
//}
|
|
|
//if (out.stEvent.HLMonitor.bExplode)
|
|
|
//{
|
|
|
// str = _S("抗干扰：爆炸");
|
|
|
// PrintText(m_ImageViewer, 0, y0, str, QBrush(Qt::red));
|
|
|
// y0 += 20;
|
|
|
//}
|
|
|
//if(out.stEvent.HLMonitor.bJammingInterface)
|
|
|
//{
|
|
|
// str = _S("抗干扰：交错干扰");
|
|
|
// PrintText(m_ImageViewer, 0, y0, str, QBrush(Qt::red));
|
|
|
// y0 += 20;
|
|
|
|
|
|
//}
|
|
|
//if (out.stEvent.bSplitJamming)
|
|
|
//{
|
|
|
// str = _S("抗干扰：分裂");
|
|
|
// PrintText(m_ImageViewer, 0, y0, str, QBrush(Qt::red));
|
|
|
// y0 += 20;
|
|
|
//}
|
|
|
|
|
|
|
|
|
//
|
|
|
//str = QString("%1").arg(m_ArithRunner->m_stInputPara.unFrmId);
|
|
|
//PrintText(m_ImageViewer, 0, y0, str, QBrush(Qt::red));
|
|
|
//y0 += 20;
|
|
|
|
|
|
//if (out.stEvent.JMBMonitor.bJammingBombLaunch)
|
|
|
//{
|
|
|
// str = QString(_S("干扰计数：%1")).arg(out.stEvent.JMBMonitor.nJammingAllCnt);
|
|
|
// PrintText(m_ImageViewer, 0, y0, str, QBrush(Qt::red));
|
|
|
// y0 += 20;
|
|
|
// str = QString(_S("投放计数：%1，pos：%2，%3")).arg(out.stEvent.JMBMonitor.nLaunchBombs)
|
|
|
// .arg(out.stEvent.JMBMonitor.ptBombPoint.x).arg(out.stEvent.JMBMonitor.ptBombPoint.y);
|
|
|
// PrintText(m_ImageViewer, 0, y0, str, QBrush(Qt::red));
|
|
|
// y0 += 20;
|
|
|
//}
|
|
|
|
|
|
if (NOT_TRACKING == obj->unTrackingStatus)
|
|
|
{
|
|
|
DAT_PARAMETERS* pDAT_stPara = ARIDLL_GetDAT_stPara(hArithSrc);
|
|
|
str = _S("检测类型:") + QString("DetectGrayType:%1").arg(pDAT_stPara->nDetectGrayType);
|
|
|
strShow += "<font color=\"#FFF\">" + str + "</font><br />";
|
|
|
|
|
|
//str = _S("信噪比阈值") + QString("fgdk:%1, fDimGdk:%2").arg(param_SkyTracker->prmTSkyDet.fSmallDetectGDK).arg(param_SkyTracker->prmTSkyDet.fDimGdk);
|
|
|
//strShow += "<font color=\"#FFF\">" + str + "</font><br />";
|
|
|
|
|
|
str = _S("分割阈值") + QString("Grad:%1, GrayBright:%2, GrayDark:%3").arg(pDAT_stPara->nGradThresMin).arg(pDAT_stPara->nGrayThresMinBright).
|
|
|
arg(pDAT_stPara->nGrayThresMinDark);
|
|
|
strShow += "<font color=\"#FFF\">" + str + "</font><br />";
|
|
|
|
|
|
str = _S("降采样信息") + QString("DetRatio: %1").arg(pDAT_stPara->nDSmpScale);
|
|
|
strShow += "<font color=\"#FFF\">" + str + "</font>";
|
|
|
m_TextInfo->append(strShow);
|
|
|
}
|
|
|
else if (STABLE_TRACKING == obj->unTrackingStatus || MEM_TRACKING == obj->unTrackingStatus)
|
|
|
{
|
|
|
FLOAT32 pdObj8BkgStdArray[80] = { 0 };
|
|
|
BBOOL pbObj8BkgStatus[80] = { 0 };
|
|
|
MINMAXRECT32S mrnBkgBlks[8] = { 0 };
|
|
|
UBYTE8 ubBkgIndex = 0;
|
|
|
BBOOL bComplexEnv = FALSE;
|
|
|
BBOOL bInterferenceMem = FALSE;
|
|
|
UBYTE8 bInfrnDirection = 0;
|
|
|
|
|
|
getBKMInform(hArithSrc, obj->nInPipesID, pdObj8BkgStdArray, pbObj8BkgStatus, &ubBkgIndex,
|
|
|
&bComplexEnv, &bInterferenceMem, &bInfrnDirection, mrnBkgBlks);
|
|
|
QGraphicsScene* scene = m_ImageViewer->imgScene;
|
|
|
for (size_t i = 0; i < 8; i++)
|
|
|
{
|
|
|
// 划分为0 - 上、1 - 右上、2 - 右、3 - 右下、4 - 下、5 - 左下、6 - 左、7 - 左上8个背景区域
|
|
|
auto obj = &mrnBkgBlks[i];
|
|
|
QRectF bbox(obj->minX, obj->minY, obj->maxX - obj->minX, obj->maxY - obj->minY);
|
|
|
scene->addRect(bbox, QPen(QColor(147, 20, 255), 0.3));
|
|
|
}
|
|
|
|
|
|
TSky_Output* pSky_Output = GetSkyTrackerObjectStatus(pEOTracker, obj->nInPipesID);
|
|
|
str = _S("------------------检测信息------------------");
|
|
|
m_TextInfo->append(WHITE(str));
|
|
|
|
|
|
str = _S(" 复杂背景:") + QString("%1").arg(bComplexEnv);
|
|
|
strShow += "<font color=\"#FFF\">" + str + "</font> ";
|
|
|
|
|
|
str = _S(" 纵向杆遮挡:") + QString("%1").arg(bInterferenceMem);
|
|
|
strShow += "<font color=\"#FFF\">" + str + "</font><br />";
|
|
|
|
|
|
Param_SkyTracker* param_SkyTracker = &pSky_Output->mTrakingPara_Output;
|
|
|
|
|
|
|
|
|
str = _S("检测类型:") + QString("DetectGrayType:%1").arg(param_SkyTracker->prmTSkyDet.nDetectGrayType);
|
|
|
strShow += "<font color=\"#FFF\">" + str + "</font><br />";
|
|
|
|
|
|
str = _S("信噪比阈值") + QString("fgdk:%1, fDimGdk:%2").arg(param_SkyTracker->prmTSkyDet.fSmallDetectGDK).arg(param_SkyTracker->prmTSkyDet.fDimGdk);
|
|
|
strShow += "<font color=\"#FFF\">" + str + "</font><br />";
|
|
|
|
|
|
str = _S("分割阈值") + QString("Grad:%1, GrayBright:%2, GrayDark:%3").
|
|
|
arg(pSky_Output->mTrakingPara_Output.prmTSkyDet.fAreaDetectGradDiffThre).arg(pSky_Output->mTrakingPara_Output.prmTSkyDet.nGrayThresMinBright).
|
|
|
arg(pSky_Output->mTrakingPara_Output.prmTSkyDet.nGrayThresMinDark);
|
|
|
strShow += "<font color=\"#FFF\">" + str + "</font><br />";
|
|
|
|
|
|
DAT_PARAMETERS* pDAT_Trk_stPara = ARIDLL_GetTrkDAT_stPara(hArithSrc, obj->nInPipesID);
|
|
|
DAT_PARAMETERS* pDAT_stPara = ARIDLL_GetDAT_stPara(hArithSrc);
|
|
|
|
|
|
str = _S("降采样信息") + QString("DetRatio: %1, TrkRatio: %2").arg(pDAT_stPara->nDSmpScale).arg(pDAT_Trk_stPara->nDSmpScale);
|
|
|
strShow += "<font color=\"#FFF\">" + str + "</font>";
|
|
|
m_TextInfo->append(strShow);
|
|
|
|
|
|
|
|
|
str = _S("------------------跟踪信息------------------");
|
|
|
m_TextInfo->append(WHITE(str));
|
|
|
str = QString(_S("TST跟踪器——————————"));
|
|
|
m_TextInfo->append(WHITE(str));
|
|
|
str = QString(_S("X:%1,Y=%2,W=%3,H=%4,fObjPxlsCnt=%5").arg(QString::number(pSky_Output->ObjectStatusTST.ptPos.x, 'f', 2))
|
|
|
.arg(QString::number(pSky_Output->ObjectStatusTST.ptPos.y, 'f', 2))
|
|
|
.arg(QString::number(pSky_Output->ObjectStatusTST.sfSize.w, 'f', 2))
|
|
|
.arg(QString::number(pSky_Output->ObjectStatusTST.sfSize.h, 'f', 2))
|
|
|
.arg(QString::number(pSky_Output->ObjectStatusTST.fObjPxlsCnt, 'f', 2)));
|
|
|
m_TextInfo->append(WHITE(str));
|
|
|
|
|
|
str = QString(_S("unTotalCnt:%1,unContiLostCnt:%2,conf:%3").arg(pSky_Output->ObjectStatusTST.unTotalCnt).arg(pSky_Output->ObjectStatusTST.unContiLostCnt)
|
|
|
.arg(QString::number(pSky_Output->ObjectStatusTST.fConfidence, 'f', 3)));
|
|
|
m_TextInfo->append(str);
|
|
|
|
|
|
|
|
|
str = QString(_S("CEND跟踪器——————————"));
|
|
|
m_TextInfo->append(WHITE(str));
|
|
|
str = QString(_S("X:%1,Y=%2,W=%3,H=%4,fObjPxlsCnt=%5").arg(QString::number(pSky_Output->ObjectStatusCEND.ptPos.x, 'f', 2))
|
|
|
.arg(QString::number(pSky_Output->ObjectStatusCEND.ptPos.y, 'f', 2))
|
|
|
.arg(QString::number(pSky_Output->ObjectStatusCEND.sfSize.w, 'f', 2))
|
|
|
.arg(QString::number(pSky_Output->ObjectStatusCEND.sfSize.h, 'f', 2))
|
|
|
.arg(QString::number(pSky_Output->ObjectStatusCEND.fObjPxlsCnt, 'f', 2)));
|
|
|
m_TextInfo->append(WHITE(str));
|
|
|
|
|
|
str = QString(_S("unTotalCnt:%1,unContiLostCnt:%2,conf:%3").arg(pSky_Output->ObjectStatusCEND.unTotalCnt).arg(pSky_Output->ObjectStatusCEND.unContiLostCnt)
|
|
|
.arg(QString::number(pSky_Output->ObjectStatusCEND.fConfidence, 'f', 3)));
|
|
|
m_TextInfo->append(WHITE(str));
|
|
|
|
|
|
|
|
|
str = QString(_S("KCF跟踪器——————————"));
|
|
|
m_TextInfo->append(WHITE(str));
|
|
|
str = QString(_S("X:%1,Y=%2,W=%3,H=%4").arg(QString::number(pSky_Output->ObjectStatusKCF.ptPos.x, 'f', 2))
|
|
|
.arg(QString::number(pSky_Output->ObjectStatusKCF.ptPos.y, 'f', 2))
|
|
|
.arg(QString::number(pSky_Output->ObjectStatusKCF.sfSize.w, 'f', 2))
|
|
|
.arg(QString::number(pSky_Output->ObjectStatusKCF.sfSize.h, 'f', 2)));
|
|
|
m_TextInfo->append(WHITE(str));
|
|
|
|
|
|
str = QString(_S("unTotalCnt:%1,unContiLostCnt:%2,conf:%3").arg(pSky_Output->ObjectStatusKCF.unTotalCnt).arg(pSky_Output->ObjectStatusKCF.unContiLostCnt)
|
|
|
.arg(QString::number(pSky_Output->ObjectStatusKCF.fConfidence, 'f', 3)));
|
|
|
m_TextInfo->append(WHITE(str));
|
|
|
|
|
|
str = QString(_S("决策跟踪器——————————"));
|
|
|
str = "<font color=\"#FF0000\">" + str + "</font>";
|
|
|
m_TextInfo->append(WHITE(str));
|
|
|
str = QString(_S("X:%1,Y=%2,W=%3,H=%4,fObjPxlsCnt=%5").arg(QString::number(pSky_Output->ObjectStatusDesc.ptPos.x, 'f', 2))
|
|
|
.arg(QString::number(pSky_Output->ObjectStatusDesc.ptPos.y, 'f', 2))
|
|
|
.arg(QString::number(pSky_Output->ObjectStatusDesc.sfSize.w, 'f', 2))
|
|
|
.arg(QString::number(pSky_Output->ObjectStatusDesc.sfSize.h, 'f', 2))
|
|
|
.arg(QString::number(pSky_Output->ObjectStatusDesc.fObjPxlsCnt, 'f', 2)));
|
|
|
m_TextInfo->append(WHITE(str));
|
|
|
|
|
|
str = QString(_S("unTotalCnt:%1,unContiLostCnt:%2,conf:%3").arg(pSky_Output->ObjectStatusDesc.unTotalCnt).arg(pSky_Output->ObjectStatusDesc.unContiLostCnt)
|
|
|
.arg(QString::number(pSky_Output->ObjectStatusDesc.fConfidence, 'f', 3)));
|
|
|
m_TextInfo->append(WHITE(str));
|
|
|
}
|
|
|
|
|
|
|
|
|
//if (out.stScene.bComplexBKG)
|
|
|
//{
|
|
|
// str = QString(_S("进入复杂场景"));
|
|
|
// strShow = "<font color=\"#FF0000\">" + str + "</font>";
|
|
|
// m_TextInfo->append(strShow);
|
|
|
//}
|
|
|
//else
|
|
|
//{
|
|
|
// str = QString(_S("退出复杂场景"));
|
|
|
// strShow = "<font color=\"#FF0000\">" + str + "</font>";
|
|
|
// m_TextInfo->append(strShow);
|
|
|
//}
|
|
|
|
|
|
|
|
|
// ALARM_TARGET* TARGETLIST = ARIDLL_GetAlarmArray(m_ArithRunner->pEOTracker);
|
|
|
// BBOOL* idoccp = ARIDLL_GetIDArray(m_ArithRunner->pEOTracker);
|
|
|
|
|
|
// str = QString();
|
|
|
// for (size_t i = 0; i < GLB_ALARM_NUM; i++)
|
|
|
// {
|
|
|
// auto AlarmT = &TARGETLIST[i];
|
|
|
// str = QString("%1:ID:%2,PipesID:%3,(%4,%5),idOcc:%6").arg(i).arg(AlarmT->nBatchID_1).arg(AlarmT->nInPipesID_1)
|
|
|
// .arg(AlarmT->centerPTx).arg(AlarmT->centerPTy).arg(idoccp[i]);
|
|
|
// strShow = "<font color=\"#FF0000\">" + str + "</font>";
|
|
|
// m_TextInfo->append(strShow);
|
|
|
// }
|
|
|
}
|
|
|
|
|
|
void QVideoPlayer::PrintGroundInfo(QString str, GLB_OUTPUT out, ARIDLL_DEBUG_OUTPUT g_DbugOut)
|
|
|
{
|
|
|
str = QString(_S("对地跟踪器——————————"));
|
|
|
m_TextInfo->append(WHITE(str));
|
|
|
|
|
|
str = QString(_S("DeciStatus:%1").arg(g_DbugOut.nDecisionStatus));
|
|
|
m_TextInfo->append(WHITE(str));
|
|
|
|
|
|
str = QString(_S("[Desc输出]:XYWH(%1,%2,%3,%4)").arg(g_DbugOut.nX).arg(g_DbugOut.nY).arg(g_DbugOut.nW).arg(g_DbugOut.nH));
|
|
|
m_TextInfo->append(WHITE(str));
|
|
|
|
|
|
str = QString(_S("kcfStatus:%1,kcfRes:%2,kcfTH:%3").arg(g_DbugOut.nKcfStatus).arg(g_DbugOut.fKCFRes).arg(g_DbugOut.fLargeResTH));
|
|
|
m_TextInfo->append(WHITE(str));
|
|
|
|
|
|
str = QString(_S("kcfOcc:%1,kcfArrest:%2").arg(g_DbugOut.nOccKCFStatus).arg(g_DbugOut.nArrestKCFStatus));
|
|
|
m_TextInfo->append(WHITE(str));
|
|
|
|
|
|
str = QString(_S("AIStatus:%1,AIRes:%2,AINum:%3,AIDetTH:%4").arg(g_DbugOut.nAIStatus).arg(g_DbugOut.fAITRes).arg(g_DbugOut.nAITNum).arg(g_DbugOut.nObjNumArrestTH));
|
|
|
m_TextInfo->append(WHITE(str));
|
|
|
|
|
|
str = QString(_S("AIJam:%1,AIChange:%2").arg(g_DbugOut.nAIJamCnt).arg(g_DbugOut.nAIChangCnt));
|
|
|
m_TextInfo->append(WHITE(str));
|
|
|
|
|
|
str = QString(_S("AIOcc:%1,AIArrest:%2").arg(g_DbugOut.nOccAIStatus).arg(g_DbugOut.nArrestAIStatus));
|
|
|
m_TextInfo->append(WHITE(str));
|
|
|
|
|
|
str = QString(_S("TLDNum:%1,TLDRes:%2, LearnNum:%3").arg(g_DbugOut.nTLDNum).arg(g_DbugOut.fMaxNNConf).arg(g_DbugOut.nLearnCnt));
|
|
|
m_TextInfo->append(WHITE(str));
|
|
|
|
|
|
str = QString(_S("决策跟踪器——————————"));
|
|
|
m_TextInfo->append(WHITE(str));
|
|
|
|
|
|
str = QString(_S("X:%1，Y=%2").arg(out.ObjectStatus.ptPos.x).arg(out.ObjectStatus.ptPos.y));
|
|
|
m_TextInfo->append(WHITE(str));
|
|
|
|
|
|
str = QString(_S("unTotalCnt:%1").arg(out.ObjectStatus.unTotalCnt));
|
|
|
m_TextInfo->append(WHITE(str));
|
|
|
str = QString(_S("unContiLostCnt:%1").arg(out.ObjectStatus.unContiLostCnt));
|
|
|
m_TextInfo->append(WHITE(str));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void QVideoPlayer::PrintInfo()
|
|
|
{
|
|
|
//QGraphicsScene* scene = m_ImageViwerListVec[2]->imgScene;
|
|
|
|
|
|
//scene->clear();
|
|
|
|
|
|
GLB_OUTPUT out = ARIDLL_Export_GLB_OUTPUT(pEOTracker);
|
|
|
|
|
|
ARIDLL_INPUTPARA *pStInputPara = &m_stInputPara;
|
|
|
|
|
|
m_TextInfo->clear();
|
|
|
|
|
|
//状态
|
|
|
QString str;
|
|
|
QString strShow;
|
|
|
|
|
|
|
|
|
|
|
|
str = QString(_S("帧编号：%1,帧频：%2")).arg(pStInputPara->unFrmId).arg(pStInputPara->unFreq);
|
|
|
m_TextInfo->append(WHITE(str));
|
|
|
|
|
|
|
|
|
str = QString(_S("方位角：%1,俯仰角：%2")).arg(m_stInputPara.stServoInfo.fServoAz).arg(m_stInputPara.stServoInfo.fServoPt);
|
|
|
m_TextInfo->append(WHITE(str));
|
|
|
|
|
|
float fAglReso = pStInputPara->stCameraInfo.fAglReso < 1e-6 ?
|
|
|
FLOAT32(ANGLE(pStInputPara->stCameraInfo.fPixelSize / pStInputPara->stCameraInfo.nFocus / 1000.0f)) : pStInputPara->stCameraInfo.fAglReso;
|
|
|
|
|
|
str = QString(_S("焦距：%1,像元尺寸：%2,视频源：%3,角分辨率：%4")).arg(m_stInputPara.stCameraInfo.nFocus).arg(m_stInputPara.stCameraInfo.fPixelSize)
|
|
|
.arg(m_stInputPara.stCameraInfo.unVideoType).arg(fAglReso);
|
|
|
m_TextInfo->append(WHITE(str));
|
|
|
|
|
|
str = QString(_S("Yaw:%1,Pitch:%2,Roll:%3")).arg(m_stInputPara.stAirCraftInfo.stAtt.fYaw)
|
|
|
.arg(m_stInputPara.stAirCraftInfo.stAtt.fPitch)
|
|
|
.arg(m_stInputPara.stAirCraftInfo.stAtt.fRoll);
|
|
|
m_TextInfo->append(WHITE(str));
|
|
|
|
|
|
|
|
|
if (m_stOutput.nSysMode == GLB_SYS_WAIT)
|
|
|
str = QString(_S("系统状态:空闲 "));
|
|
|
else if (m_stOutput.nSysMode == GLB_SYS_FSCAN)
|
|
|
str = QString(_S("系统状态:扫描 "));
|
|
|
else if (m_stOutput.nSysMode == GLB_SYS_AUTO)
|
|
|
str = QString(_S("系统状态:无人值守 "));
|
|
|
else if (m_stOutput.nSysMode == GLB_SYS_STARE)
|
|
|
str = QString(_S("系统状态:凝视"));
|
|
|
|
|
|
m_TextInfo->append(WHITE(str));
|
|
|
|
|
|
|
|
|
if (m_stOutput.nStatus == GLB_STATUS_WAIT)
|
|
|
str = QString(_S("算法状态:待命 "));
|
|
|
if (m_stOutput.nStatus == GLB_STATUS_SEARCH)
|
|
|
str = QString(_S("算法状态:搜索 "));
|
|
|
else if (m_stOutput.nStatus == GLB_STATUS_TRACK)
|
|
|
str = QString(_S("算法状态:单目标跟踪 "));
|
|
|
else if (m_stOutput.nStatus == GLB_STATUS_LOST)
|
|
|
str = QString(_S("算法状态:丢失 "));
|
|
|
else if (m_stOutput.nStatus == GLB_STATUS_MOTRACK)
|
|
|
str = QString(_S("状态:多目标跟踪 "));
|
|
|
else if (m_stOutput.nStatus == GLB_STATUS_FSCAN)
|
|
|
str = QString(_S("状态:扇扫 "));
|
|
|
else if (m_stOutput.nStatus == 11)
|
|
|
str = QString(_S("状态:自动截获 "));
|
|
|
else if (m_stOutput.nStatus == 12)
|
|
|
str = QString(_S("状态:半自动截获 "));
|
|
|
else
|
|
|
str = QString(_S("状态:未知 "));
|
|
|
|
|
|
m_TextInfo->append(WHITE(str));
|
|
|
|
|
|
|
|
|
str = QString(_S("输入单帧目标：%1个")).arg(m_stDebugOutPut.nDetectObjsNum);
|
|
|
m_TextInfo->append(WHITE(str));
|
|
|
|
|
|
str = QString(_S("输出告警目标：%1个")).arg(m_stOutput.nAlarmObjCnts);
|
|
|
m_TextInfo->append(WHITE(str));
|
|
|
|
|
|
|
|
|
str = QString(_S("算法耗时：%1ms")).arg(m_stDebugOutPut.Arith_time);
|
|
|
m_TextInfo->append(WHITE(str));
|
|
|
|
|
|
// 获取主跟踪器目标的跟踪对象，依据其内部绑定的跟踪场景显示调试信息
|
|
|
ARIDLL_OBJINFO* obj = &m_stOutput.stTrackers[0];
|
|
|
|
|
|
GLB_SCEN_MODE m_type = GLB_SCEN_NONE;
|
|
|
if (GLB_STATUS_SEARCH == m_stOutput.nStatus)
|
|
|
{
|
|
|
m_type = ARIDLL_ExportSceneMode(pEOTracker);
|
|
|
}
|
|
|
else if (GLB_STATUS_TRACK == m_stOutput.nStatus)
|
|
|
{
|
|
|
m_type = ARIDLL_ExportTrkSceneMode(pEOTracker, obj->nInPipesID);
|
|
|
}
|
|
|
|
|
|
if (GLB_SCEN_MODE::GLB_SCEN_GROUND == m_type)
|
|
|
{
|
|
|
PrintGroundInfo(str, out, m_stDebugOutPut);
|
|
|
}
|
|
|
else if (GLB_SCEN_MODE::GLB_SCEN_SKY == m_type)
|
|
|
{
|
|
|
PrintSkyInfo(str, strShow, pEOTracker, obj, out, m_stDebugOutPut);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void QVideoPlayer::DrawLineInImage(QImageViewer* view, QVector<QPoint> pSet, QPen pen, bool bRectBlock)
|
|
|
{
|
|
|
if (pSet.size() == 0)
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
QRect viewRect = view->geometry();
|
|
|
QGraphicsScene* scene = view->imgScene;
|
|
|
QPainterPath path;
|
|
|
path.moveTo(pSet[0]);
|
|
|
for (size_t i = 0; i < pSet.size(); i++)
|
|
|
{
|
|
|
path.lineTo(pSet[i]);
|
|
|
|
|
|
// 在端点绘制小方块标记位置
|
|
|
QRect rc(pSet[i].x() - 3, pSet[i].y() - 3, 6, 6);
|
|
|
if (bRectBlock)
|
|
|
{
|
|
|
scene->addRect(rc, pen);
|
|
|
}
|
|
|
|
|
|
}
|
|
|
scene->addPath(path, pen);
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
void QVideoPlayer::DrawCrossInImage(QImageViewer* view, QRect rect, QPen pen)
|
|
|
{
|
|
|
QRect viewRect = view->geometry();
|
|
|
QGraphicsScene* scene = view->imgScene;
|
|
|
|
|
|
QPoint left1(rect.x(), rect.y() + rect.height() * 0.5);
|
|
|
QPoint right1(rect.x() + rect.width() * 0.3, rect.y() + rect.height() * 0.5);
|
|
|
|
|
|
QPoint left2(rect.x() + rect.width() * 0.7, rect.y() + rect.height() * 0.5);
|
|
|
QPoint right2(rect.x() + rect.width(), rect.y() + rect.height() * 0.5);
|
|
|
|
|
|
QPoint up1(rect.x() + rect.width() * 0.5, rect.y());
|
|
|
QPoint down1(rect.x() + rect.width() * 0.5, rect.y() + rect.height() * 0.3);
|
|
|
|
|
|
QPoint up2(rect.x() + rect.width() * 0.5, rect.y() + rect.height() * 0.7);
|
|
|
QPoint down2(rect.x() + rect.width() * 0.5, rect.y() + rect.height());
|
|
|
|
|
|
scene->addLine(QLine(left1, right1),pen);
|
|
|
scene->addLine(QLine(left2, right2), pen);
|
|
|
|
|
|
|
|
|
scene->addLine(QLine(up1, down1), pen);
|
|
|
scene->addLine(QLine(up2, down2), pen);
|
|
|
}
|
|
|
|
|
|
|
|
|
void QVideoPlayer::DrawSkyLine(QImageViewer* view,int y)
|
|
|
{
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
void QVideoPlayer::DrawGuideRect()
|
|
|
{
|
|
|
auto guide_Targets = ARIDLL_GetTargetGuide(pEOTracker);
|
|
|
QGraphicsScene* scene = m_ImageViewer->imgScene;
|
|
|
for (size_t i = 0; i < GUIDE_TARGET_NUM; i++)
|
|
|
{
|
|
|
auto t = &guide_Targets[i];
|
|
|
|
|
|
if (t->ID)
|
|
|
{
|
|
|
QString str = "Guide:" + QString::number(t->ID);
|
|
|
auto text = scene->addSimpleText(str);
|
|
|
text->setPos(QPoint(t->ptGuidePOS.x - 50, t->ptGuidePOS.y - 50 - 9));
|
|
|
QFont ft; ft.setPointSize(3);
|
|
|
text->setBrush(QBrush(QColor(Qt::green)));
|
|
|
text->setFont(ft);
|
|
|
|
|
|
scene->addRect(QRectF(t->ptGuidePOS.x - 50, t->ptGuidePOS.y - 50, 100, 100), QPen(QColor(255, 255, 0)));
|
|
|
}
|
|
|
}
|
|
|
auto capturebox = m_stOutput.CaptureBox;
|
|
|
if (capturebox.w && capturebox.h)
|
|
|
{
|
|
|
QRectF qcapbox(capturebox.cx - capturebox.w / 2, capturebox.cy - capturebox.h / 2, capturebox.w, capturebox.h);
|
|
|
//绘制截获波门
|
|
|
scene->addRect(qcapbox, QPen(QColor(0, 255, 0), 0.5, Qt::DashDotLine));
|
|
|
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void QVideoPlayer::DrawTrackListInfo(QImageViewer* view)
|
|
|
{
|
|
|
//DrawAglList(view, &ArithOutput.ObjAglListsNear, QPen(QColor(255, 255, 255), 0.5, Qt::DotLine));
|
|
|
//DrawAglList(view, &ArithOutput.ObjAglListsLong, QPen(QColor(255, 100, 100), 0.5, Qt::DotLine));
|
|
|
|
|
|
// 绘制轨迹预测位置
|
|
|
//POINT32F pt;
|
|
|
//ARIDLL_EORadarCalcObjX_Y(ArithOutput.ObjAglListsNear.arfPredict.afAngle.fAz, ArithOutput.ObjAglListsNear.arfPredict.afAngle.fPt, &pt);
|
|
|
//QRect rc(pt.x - 10, pt.y - 10, 20, 20);
|
|
|
//DrawCrossInImage(m_ImageViewer, rc, QPen(QColor(255, 255, 255), 1, Qt::DotLine));
|
|
|
|
|
|
//ARIDLL_EORadarCalcObjX_Y(ArithOutput.ObjAglListsLong.arfPredict.afAngle.fAz, ArithOutput.ObjAglListsLong.arfPredict.afAngle.fPt, &pt);
|
|
|
//QRect rc1(pt.x - 30, pt.y - 30, 60, 60);
|
|
|
//DrawCrossInImage(m_ImageViewer, rc1, QPen(QColor(255, 100, 100), 1, Qt::DotLine));
|
|
|
}
|
|
|
|
|
|
void QVideoPlayer::DrawDSTPoint(QImageViewer * view)
|
|
|
{
|
|
|
auto pList = ARIDLL_GetMaxPoint(pEOTracker);
|
|
|
|
|
|
for (size_t i = 0; i < (640/16 * 512/16) * 2; i++)
|
|
|
{
|
|
|
auto p = pList[i];
|
|
|
if(p.x > 0 && p.y > 0)
|
|
|
{
|
|
|
DrawCrossInImage(view,QRect(p.x - 2,p.y -2 ,4,4),QPen(QColor(100,100,34)));
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// void QVideoPlayer::GenColorTable(int nLen)
|
|
|
// {
|
|
|
// // for (size_t i = 0; i < nLen; i++)
|
|
|
// // {
|
|
|
// // int r = qrand() % 200;
|
|
|
// // int g = qrand() % 200;
|
|
|
// // int b = qrand() % 200;
|
|
|
// // m_colorTable[i] = QColor(r, g, b);
|
|
|
// // }
|
|
|
|
|
|
// }
|
|
|
|
|
|
void QVideoPlayer::addScenToVideo()
|
|
|
{
|
|
|
// 抓图
|
|
|
QPixmap pixSaveImage(nVideoWidth, nVideoHeight);
|
|
|
pixSaveImage.fill(QColor(0, 0, 0, 0));//用透明色填充
|
|
|
QPainter painterTanns(&pixSaveImage);
|
|
|
painterTanns.setRenderHint(QPainter::Antialiasing, true);
|
|
|
painterTanns.setRenderHint(QPainter::TextAntialiasing, true);
|
|
|
painterTanns.setRenderHint(QPainter::SmoothPixmapTransform, true);
|
|
|
|
|
|
auto imgScene = m_ImageViewer->scene();
|
|
|
//imgScene->render(&painterTanns);
|
|
|
|
|
|
imgScene->render(&painterTanns);
|
|
|
//m_ImageViewer->render(&painterTanns);
|
|
|
|
|
|
QImage Image = pixSaveImage.toImage();
|
|
|
|
|
|
cv::Mat src = m_ImageViewer->QImage2cvMat(Image);
|
|
|
cv::cvtColor(src, src, cv::COLOR_RGBA2RGB);
|
|
|
|
|
|
|
|
|
cvVideoWriter << src;
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
void QVideoPlayer::OnStopRecord()
|
|
|
{
|
|
|
if (!bRecordingFlag)
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
if (!cvVideoWriter.isOpened())
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
cvVideoWriter.release();
|
|
|
|
|
|
bRecordingFlag = false;
|
|
|
}
|
|
|
|
|
|
void QVideoPlayer::OnGrabImage()
|
|
|
{
|
|
|
if (m_VideoStream == nullptr)
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
// 确定拍照大小，设置大一点比较清晰
|
|
|
int nImageWidth = m_VideoStream->GetImageWidth();
|
|
|
int nImageHeight = m_VideoStream->GetImageHeight();
|
|
|
|
|
|
if (nImageWidth < 1024)
|
|
|
{
|
|
|
float r = 1024.0 / nImageWidth;
|
|
|
nImageWidth *= r;
|
|
|
nImageHeight *= r;
|
|
|
}
|
|
|
if (nImageHeight < 768)
|
|
|
{
|
|
|
float r = 768.0 / nImageHeight;
|
|
|
nImageWidth *= r;
|
|
|
nImageHeight *= r;
|
|
|
}
|
|
|
|
|
|
QDateTime current_date_time = QDateTime::currentDateTime();
|
|
|
QString current_date = current_date_time.toString("yyyyMMddhhmm");
|
|
|
|
|
|
int ind = m_FileFullPath.lastIndexOf('.');
|
|
|
|
|
|
QString FrameID = "_" + QString::number(m_VideoStream->GetCurrentFrameIndex());
|
|
|
QString recordPath = m_FileFullPath.left(ind) + FrameID + ".jpg";
|
|
|
|
|
|
QPixmap pixSaveImage(nImageWidth, nImageHeight);
|
|
|
pixSaveImage.fill(QColor(0, 0, 0, 0));//用透明色填充
|
|
|
QPainter painterTanns(&pixSaveImage);
|
|
|
painterTanns.setRenderHint(QPainter::Antialiasing, true);
|
|
|
painterTanns.setRenderHint(QPainter::TextAntialiasing, true);
|
|
|
painterTanns.setRenderHint(QPainter::SmoothPixmapTransform, true);
|
|
|
|
|
|
auto imgScene = m_ImageViewer->scene();
|
|
|
//imgScene->render(&painterTanns);
|
|
|
|
|
|
imgScene->render(&painterTanns);
|
|
|
|
|
|
QImage Image = pixSaveImage.toImage();
|
|
|
|
|
|
Image.save(recordPath);
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
void QVideoPlayer::OnStartRecord()
|
|
|
{
|
|
|
if (cvVideoWriter.isOpened())
|
|
|
{
|
|
|
cvVideoWriter.release();
|
|
|
}
|
|
|
|
|
|
if (m_VideoStream == nullptr)
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
// 确定录像大小，设置大一点比较清晰
|
|
|
nVideoWidth = m_VideoStream->GetImageWidth();
|
|
|
nVideoHeight = m_VideoStream->GetImageHeight();
|
|
|
|
|
|
if (nVideoWidth < 1024 || nVideoHeight < 768)
|
|
|
{
|
|
|
float r = 1024.0 /nVideoWidth;
|
|
|
nVideoWidth *= r;
|
|
|
nVideoHeight *= r;
|
|
|
}
|
|
|
if (nVideoHeight < 768)
|
|
|
{
|
|
|
float r = 768.0 / nVideoHeight;
|
|
|
nVideoWidth *= r;
|
|
|
nVideoHeight *= r;
|
|
|
}
|
|
|
|
|
|
QDateTime current_date_time = QDateTime::currentDateTime();
|
|
|
QString current_date = current_date_time.toString("yyyyMMddhhmm");
|
|
|
|
|
|
int ind = m_FileFullPath.lastIndexOf('.');
|
|
|
string recordPath = m_FileFullPath.left(ind).toStdString() + current_date.toStdString() + ".avi";
|
|
|
|
|
|
cvVideoWriter.open(recordPath, cv::VideoWriter::fourcc('M', 'J', 'P', 'G'),25, cv::Size(nVideoWidth, nVideoHeight),1);
|
|
|
|
|
|
if (!cvVideoWriter.isOpened())
|
|
|
{
|
|
|
QMessageBox::critical(NULL, _S("错误"), _S("无法创建录像文件"));
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 标记开始录像
|
|
|
bRecordingFlag = true;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
void QVideoPlayer::DrawAITrackerInfo()
|
|
|
{
|
|
|
auto p_GLB_AITrackOutput = &g_GLB_AITrackOutput;
|
|
|
if (p_GLB_AITrackOutput->fObjW * p_GLB_AITrackOutput->fObjH == 0)
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 绘制当前跟踪框
|
|
|
int cx = p_GLB_AITrackOutput->fX;
|
|
|
int cy = p_GLB_AITrackOutput->fY;
|
|
|
int w = MAX(15, p_GLB_AITrackOutput->fObjW);
|
|
|
int h = MAX(15, p_GLB_AITrackOutput->fObjH);
|
|
|
QRect bbox(cx - w / 2, cy - h / 2, w, h);
|
|
|
QString str;
|
|
|
if (g_GLB_AITrackOutput.type == AITrackerType::DaSaimRPN)
|
|
|
{
|
|
|
str = "siamRPN";
|
|
|
}
|
|
|
else if(g_GLB_AITrackOutput.type == AITrackerType::NanoTrack)
|
|
|
{
|
|
|
str = "NANO";
|
|
|
}
|
|
|
DrawArtRect(m_ImageViewer, QPen(QBrush(QColor(255,255,0)), 2), bbox, str, false);
|
|
|
}
|
|
|
|
|
|
|
|
|
void QVideoPlayer::UpdatePanImage()
|
|
|
{
|
|
|
if (!m_VideoStream) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
//auto panImage = m_ArithRunner->m_panParam;
|
|
|
|
|
|
//cv::Mat image(panImage.PanHeight, panImage.PanWidth, CV_8UC1, panImage.pPanImage);
|
|
|
|
|
|
//m_panViewer->showPanImage(image);
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void QVideoPlayer::DrawPipeAglInfo()
|
|
|
{
|
|
|
if (!bEnableDrawFlightPath)
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
QGraphicsScene* scene = m_ImageViewer->imgScene;
|
|
|
|
|
|
auto pPipeArray = ARIDLL_ExportPipeArrayPtr(pEOTracker);
|
|
|
|
|
|
auto PipeNum = 99;//m_stDebugOutPut.nMaxPipeNum;
|
|
|
|
|
|
//管道编号对应颜色表 by wcw04046 @ 2019/01/21
|
|
|
UBYTE8 ubClorR[10] = { 200,35,50,75,100,125,155,170,190,200 };
|
|
|
UBYTE8 ubClorG[10] = { 120,170,190,200,10,35,50,75,100,125 };
|
|
|
UBYTE8 ubClorB[10] = { 120,200,10,35,50,155,170,75,100,125 };
|
|
|
|
|
|
PIPE* pPipe = NULL;
|
|
|
//遍历管道
|
|
|
for (int P = 0; P < PipeNum; P++)
|
|
|
{
|
|
|
pPipe = &pPipeArray[P];
|
|
|
|
|
|
if (!pPipe->bOccupy)
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
// 跳过非告警管道
|
|
|
if (!pPipe->bAlarm)
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
if (!pPipe->bInsideFOV)
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
if (pPipe->bTrackingPipe)
|
|
|
{
|
|
|
////// 主跟踪目标绘制长短时预测
|
|
|
auto TrackListInfo = ARIDLL_GetTrackerHistInfo(pEOTracker, P);
|
|
|
DrawAglList(m_ImageViewer, &TrackListInfo->ObjAglListsNear, QPen(QColor(255, 255, 255), 0.5, Qt::DotLine));
|
|
|
DrawAglList(m_ImageViewer, &TrackListInfo->ObjAglListsLong, QPen(QColor(255, 100, 100), 0.5, Qt::DotLine));
|
|
|
QPen pen1(QPen(QColor(255, 255, 255), 0.5, Qt::SolidLine));
|
|
|
DrawCrossInImage(m_ImageViewer, QRect(pPipe->stMotionMod_mean.crnObjPrediRtLong.cx - 40, pPipe->stMotionMod_mean.crnObjPrediRtLong.cy - 40, 80, 80), pen1);
|
|
|
QPen pen2(QPen(QColor(255, 20, 20), 0.5, Qt::SolidLine));
|
|
|
DrawCrossInImage(m_ImageViewer, QRect(pPipe->stMotionMod_mean.crnObjPrediRtNear.cx - 25, pPipe->stMotionMod_mean.crnObjPrediRtNear.cy - 25, 50, 50), pen2);
|
|
|
}
|
|
|
else if(bEnableDrawFrameDetect)
|
|
|
{
|
|
|
int m = pPipe->ubEnd;
|
|
|
int nTargetCnt = MIN(GLB_PIPE_DEPTH_MAX, (SINT32)(pPipe->unExistCnt));
|
|
|
// 将角度转为坐标存入队列
|
|
|
QVector<QPoint>pSet;
|
|
|
|
|
|
//遍历管道目标
|
|
|
for (int i = 0; i < nTargetCnt; i++)
|
|
|
{
|
|
|
TARGET_OBJECT* pTargetObj = &pPipe->objHistoryList[m];
|
|
|
m = (m + GLB_PIPE_DEPTH_MAX - 1) % GLB_PIPE_DEPTH_MAX;
|
|
|
|
|
|
float fAz = pTargetObj->afAngle.fAz;
|
|
|
float fPt = pTargetObj->afAngle.fPt;
|
|
|
|
|
|
|
|
|
if (pTargetObj->bObject)
|
|
|
{
|
|
|
// 获取管道目标在图像中的位置
|
|
|
POINT32F pt;
|
|
|
pt = ARIDLL_GetImagePosFromStablePole(pEOTracker, pTargetObj->afAngle);
|
|
|
pSet.push_back(QPoint(pt.x, pt.y));
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (pSet.size() == 0)
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
QPen pen(QColor(ubClorR[P], ubClorG[P], ubClorB[P]));
|
|
|
// 绘制丢失管道的预测位置
|
|
|
if (pPipe->bLost)
|
|
|
{
|
|
|
DrawCrossInImage(m_ImageViewer, QRect(pPipe->ptCurrentPnt.x - 3, pPipe->ptCurrentPnt.y - 3, 9, 9), pen);
|
|
|
}
|
|
|
DrawLineInImage(m_ImageViewer, pSet, pen);
|
|
|
|
|
|
if (pPipe->bAlarm)
|
|
|
{
|
|
|
QString str = QString(_S("ID:%1,P:%2 D:%3/%4")).arg(pPipe->nAlarmBatchID_1).arg(P).arg(pPipe->unExistCnt).arg(pPipe->unTotalCnt);
|
|
|
PrintText(m_ImageViewer, pSet[0].x(), pSet[0].y() + 10, str);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
void QVideoPlayer::DrawAlarmTarget()
|
|
|
{
|
|
|
// 管道告警信息绘制开关关闭时，跳过绘制
|
|
|
if (!bEnableDrawPipeInfo)
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
QGraphicsScene* scene = m_ImageViewer->imgScene;
|
|
|
|
|
|
for (size_t i = 0; i < m_stOutput.nAlarmObjCnts; i++)
|
|
|
{
|
|
|
auto obj = m_stOutput.stAlarmObjs[i];
|
|
|
QString str = QString(_S("ID:%1,Type:%2")).arg(obj.nOutputID).arg(obj.unClsType);
|
|
|
auto cloor = QColor(0, 255, 0);
|
|
|
if(obj.nPipeLostCnt > 0)
|
|
|
{
|
|
|
cloor = QColor(20, 20, 20);
|
|
|
}
|
|
|
|
|
|
DrawArtRect(m_ImageViewer, QPen(cloor),
|
|
|
QRect(obj.nX - obj.nObjW / 2, obj.nY - obj.nObjH / 2, obj.nObjW, obj.nObjH), str, FALSE, 15, QColor(25,255,255));
|
|
|
|
|
|
}
|
|
|
auto obj = &m_stOutput.stTrackers[0];
|
|
|
//if (GLB_SCEN_MODE::GLB_SCEN_SKY == pTracker->m_type)
|
|
|
{
|
|
|
DrawDetectSegResults(m_ImageViewerVec[5], pEOTracker);
|
|
|
}
|
|
|
|
|
|
QString str = QString("%1").arg(m_stInputPara.unFrmId);
|
|
|
|
|
|
auto text = scene->addSimpleText(str);
|
|
|
text->setPos(QPoint(10, 10));
|
|
|
QFont ft; ft.setPointSize(4); ft.setBold(1);
|
|
|
text->setBrush(QBrush(QColor(Qt::blue)));
|
|
|
text->setFont(ft);
|
|
|
|
|
|
}
|
|
|
|
|
|
/*************************************************
|
|
|
// Method: convertTo3Channels
|
|
|
// Description: 将单通道图像转为三通道图像
|
|
|
// Returns: cv::Mat
|
|
|
// Parameter: binImg 单通道图像对象
|
|
|
*************************************************/
|
|
|
cv::Mat convertTo3Channels(const cv::Mat& binImg)
|
|
|
{
|
|
|
cv::Mat three_channel = cv::Mat::zeros(binImg.rows, binImg.cols, CV_8UC3);
|
|
|
vector<cv::Mat> channels;
|
|
|
for (int i = 0; i < 3; i++)
|
|
|
{
|
|
|
channels.push_back(binImg);
|
|
|
}
|
|
|
merge(channels, three_channel);
|
|
|
return three_channel;
|
|
|
}
|
|
|
|
|
|
void QVideoPlayer::DrawTrackSegResults(QImageViewer* view, ArithHandle hArithSrc, int pipeID)
|
|
|
{
|
|
|
DAT_PARAMETERS* pDAT_Trk_stPara = ARIDLL_GetTrkDAT_stPara(hArithSrc, pipeID);
|
|
|
DAT_OUTPUT* pDAT_Trk_stOutput = ARIDLL_GetTrkDAT_stOutput(hArithSrc, pipeID);
|
|
|
//DAT_OUTPUT* pDAT_stOutput = pTracker->pSkyTracker->pSATracker->pDAT_Module->getDAT_stOutput();
|
|
|
|
|
|
if (NULL == pDAT_Trk_stOutput->DAT_pBinary_Gray || NULL == pDAT_Trk_stOutput->DAT_pBinary_Mag)
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
cv::Mat TrkGrayBinary(pDAT_Trk_stOutput->snSrDSmp.h, pDAT_Trk_stOutput->snSrDSmp.w, CV_8UC1, pDAT_Trk_stOutput->DAT_pBinary_Gray);
|
|
|
cv::Mat TrkGradBinary(pDAT_Trk_stOutput->snSrDSmp.h, pDAT_Trk_stOutput->snSrDSmp.w, CV_8UC1, pDAT_Trk_stOutput->DAT_pBinary_Mag);
|
|
|
|
|
|
|
|
|
TrkGrayBinary = TrkGrayBinary * 255;
|
|
|
TrkGradBinary = TrkGradBinary * 255;
|
|
|
|
|
|
cv::resize(TrkGrayBinary, TrkGrayBinary, cv::Size(), pDAT_Trk_stPara->nDSmpScale, pDAT_Trk_stPara->nDSmpScale);
|
|
|
cv::resize(TrkGradBinary, TrkGradBinary, cv::Size(), pDAT_Trk_stPara->nDSmpScale, pDAT_Trk_stPara->nDSmpScale);
|
|
|
|
|
|
cv::Mat FuseImg(pDAT_Trk_stPara->nDSmpScale * pDAT_Trk_stOutput->snSrDSmp.h, pDAT_Trk_stPara->nDSmpScale * pDAT_Trk_stOutput->snSrDSmp.w, CV_8UC3);
|
|
|
std::vector<cv::Mat> planes;
|
|
|
cv::split(FuseImg, planes);
|
|
|
planes.at(0) = TrkGrayBinary;
|
|
|
planes.at(2) = TrkGradBinary;
|
|
|
planes.at(1) = 0;
|
|
|
cv::merge(planes, FuseImg);
|
|
|
|
|
|
//for (int nIndex = 0; nIndex < nObjsCnt; nIndex++)
|
|
|
//{
|
|
|
// cv::Rect ret(ptTargetArray[nIndex].mrnRect.minX, ptTargetArray[nIndex].mrnRect.minY, (ptTargetArray[nIndex].mrnRect.maxX - ptTargetArray[nIndex].mrnRect.minX), (ptTargetArray[nIndex].mrnRect.maxY - ptTargetArray[nIndex].mrnRect.minY));
|
|
|
// cv::rectangle(FuseImg, ret, cv::Scalar(0, 255, 0));
|
|
|
//}
|
|
|
|
|
|
//cv::imshow("分割结果:灰度(B)_梯度(R)", FuseImg);
|
|
|
//cv::imshow("灰度分割结果", TmpGrayBinary);
|
|
|
//cv::imshow("梯度分割结果", TmpGradBinary);
|
|
|
//cv::waitKey(1);
|
|
|
cv::Mat TmpGrayBinary3C = convertTo3Channels(TrkGrayBinary);
|
|
|
cv::Mat TmpGradBinary3C = convertTo3Channels(TrkGradBinary);
|
|
|
|
|
|
cv::Mat lineImage = cv::Mat(TmpGradBinary3C.rows, 6, CV_8UC3, cv::Scalar(255, 255, 255));
|
|
|
//cv::line(TmpGradBinary3C, cv::Point(0, 0), cv::Point(0, TmpGradBinary3C.rows - 1), Scalar(255, 255, 255), 2, LINE_8);
|
|
|
//cv::line(TmpGradBinary3C, cv::Point(TmpGradBinary3C.cols - 1, 0), cv::Point(TmpGradBinary3C.cols - 1, TmpGradBinary3C.rows - 1),
|
|
|
// Scalar(255, 255, 255), 2, LINE_8);
|
|
|
|
|
|
std::vector<cv::Mat> matrices = { TmpGrayBinary3C, lineImage,
|
|
|
TmpGradBinary3C, lineImage, FuseImg };
|
|
|
|
|
|
cv::Mat out;
|
|
|
cv::hconcat(matrices, out);
|
|
|
view->DrawCVImage(out);
|
|
|
}
|
|
|
|
|
|
void QVideoPlayer::DrawDetectSegResults(QImageViewer* view, ArithHandle hArithSrc)
|
|
|
{
|
|
|
//Detectors* pDetectors = ARIDLL_ExportDetectorsPtr(pEOTracker);
|
|
|
|
|
|
//DAT_PARAMETERS* pDAT_stPara = pDetectors->pDAT_Module->GetDatParm();
|
|
|
//DAT_OUTPUT* pDAT_stOutput = pDetectors->pDAT_Module->getDAT_stOutput();
|
|
|
|
|
|
DAT_PARAMETERS* pDAT_stPara = ARIDLL_GetDAT_stPara(hArithSrc);
|
|
|
DAT_OUTPUT* pDAT_stOutput = ARIDLL_GetDAT_stOutput(hArithSrc);
|
|
|
|
|
|
if (NULL == pDAT_stOutput ||
|
|
|
NULL == pDAT_stOutput->DAT_pBinary_Gray || NULL == pDAT_stOutput->DAT_pBinary_Mag)
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
|
|
|
cv::Mat DetGrayBinary(pDAT_stOutput->snSrDSmp.h, pDAT_stOutput->snSrDSmp.w, CV_8UC1, pDAT_stOutput->DAT_pBinary_Gray);
|
|
|
cv::Mat DetGradBinary(pDAT_stOutput->snSrDSmp.h, pDAT_stOutput->snSrDSmp.w, CV_8UC1, pDAT_stOutput->DAT_pBinary_Mag);
|
|
|
|
|
|
DetGrayBinary = DetGrayBinary * 255;
|
|
|
DetGradBinary = DetGradBinary * 255;
|
|
|
|
|
|
cv::resize(DetGrayBinary, DetGrayBinary, cv::Size(), pDAT_stPara->nDSmpScale, pDAT_stPara->nDSmpScale);
|
|
|
cv::resize(DetGradBinary, DetGradBinary, cv::Size(), pDAT_stPara->nDSmpScale, pDAT_stPara->nDSmpScale);
|
|
|
|
|
|
cv::Mat FuseImg(pDAT_stPara->nDSmpScale * pDAT_stOutput->snSrDSmp.h, pDAT_stPara->nDSmpScale * pDAT_stOutput->snSrDSmp.w, CV_8UC3);
|
|
|
std::vector<cv::Mat> planes;
|
|
|
cv::split(FuseImg, planes);
|
|
|
planes.at(0) = DetGrayBinary;
|
|
|
planes.at(2) = DetGradBinary;
|
|
|
planes.at(1) = 0;
|
|
|
cv::merge(planes, FuseImg);
|
|
|
|
|
|
cv::Mat DetGrayBinary3C = convertTo3Channels(DetGrayBinary);
|
|
|
cv::Mat DetGradBinary3C = convertTo3Channels(DetGradBinary);
|
|
|
|
|
|
cv::Mat lineImage = cv::Mat(DetGradBinary3C.rows, 3, CV_8UC3, cv::Scalar(255, 255, 255));
|
|
|
//cv::line(TmpGradBinary3C, cv::Point(0, 0), cv::Point(0, TmpGradBinary3C.rows - 1), Scalar(255, 255, 255), 1, LINE_8);
|
|
|
//cv::line(TmpGradBinary3C, cv::Point(TmpGradBinary3C.cols - 1, 0), cv::Point(TmpGradBinary3C.cols - 1, TmpGradBinary3C.rows - 1),
|
|
|
// Scalar(255, 255, 255), 1, LINE_8);
|
|
|
std::vector<cv::Mat> matrices = { DetGrayBinary3C, lineImage,
|
|
|
DetGradBinary3C, lineImage, FuseImg };
|
|
|
|
|
|
cv::Mat out;
|
|
|
cv::hconcat(matrices, out);
|
|
|
view->DrawCVImage(out);
|
|
|
}
|
|
|
|
|
|
void QVideoPlayer::DrawAglList(QImageViewer* view, OBJ_ANGLE_R* pObjAglLists, QPen pen)
|
|
|
{
|
|
|
QRect viewRect = view->geometry();
|
|
|
QGraphicsScene* scene = view->imgScene;
|
|
|
|
|
|
int nEnd = pObjAglLists->nEnd;
|
|
|
ANGLE_R* parHistoryList = (ANGLE_R*)pObjAglLists->parHistoryList;
|
|
|
int m = nEnd = pObjAglLists->nEnd;
|
|
|
int nListSize = pObjAglLists->nListSize;
|
|
|
|
|
|
if (nListSize == 0)
|
|
|
return;
|
|
|
|
|
|
int nStep = 1;
|
|
|
int nViewCnt = MAX(1, MIN(pObjAglLists->nCnt / nStep, nListSize));
|
|
|
FLOAT32 fAz, fPt;
|
|
|
//MSSu, 20160409: 目标轨迹按从历史到现在的方向绘制
|
|
|
if (pObjAglLists->nCnt >= nListSize)
|
|
|
{
|
|
|
m = (nEnd + 1) % nListSize;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
m = 0;
|
|
|
}
|
|
|
|
|
|
// 将角度转为坐标存入队列
|
|
|
QVector<QPoint>pSet;
|
|
|
for (int i = 0; i < nViewCnt; i += nStep)
|
|
|
{
|
|
|
fAz = parHistoryList[m].afAngle.fAz;
|
|
|
fPt = parHistoryList[m].afAngle.fPt;
|
|
|
|
|
|
POINT32F pt = ARIDLL_GetImagePosFromStablePole(pEOTracker, parHistoryList[m].afAngle);
|
|
|
|
|
|
//m = (m + nListSize + nStep) % nListSize;
|
|
|
m = (m + nListSize + 1) % nListSize;
|
|
|
|
|
|
//POINT32F pt;
|
|
|
//ARIDLL_EORadarCalcObjX_Y(fAz, fPt, &pt);
|
|
|
|
|
|
//if (i % 2)
|
|
|
{
|
|
|
QRect label(QPoint(pt.x - 1, pt.y - 1), QPoint(pt.x + 1, pt.y + 1));
|
|
|
|
|
|
auto a = scene->sceneRect();
|
|
|
if (a.contains(label))//不要绘制出界
|
|
|
{
|
|
|
pSet.push_back(QPoint(pt.x, pt.y));
|
|
|
//scene->addRect(label, QPen(QColor(212, 55, 141), 0.3));
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
DrawLineInImage(view, pSet, pen);
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
