cameramanager.h 35 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893
  1. #ifndef M_FRAMES_HPP
  2. #define M_FRAMES_HPP
  3. // Qt include.
  4. #include <QObject>
  5. #include <QVector>
  6. #include <QMetaType>
  7. #include <QVideoSink>
  8. #include <QCamera>
  9. #include <QMediaRecorder>
  10. #include <QMediaCaptureSession>
  11. #include <QImageCapture>
  12. #include <QPointer>
  13. #include <QThread>
  14. #include <m_opencv.h>
  15. #include <m_workthread.h>
  16. #include <mqtthandler.h>
  17. #include <mserial.h>
  18. #include <ymodem.h>
  19. #include <m_json.h>
  20. #include <m_loger.h>
  21. #include <QFuture>
  22. #include <ImageStitcher.h>
  23. #include <QSemaphore>
  24. #include <QQuickImageProvider>
  25. #include <QQmlImageProviderBase>
  26. #include <QImage>
  27. #include <QFile>
  28. #include <QElapsedTimer>
  29. #include <QDateTime>
  30. #include <QVideoFrame>
  31. #include <pthread.h>
  32. //海康
  33. // #pragma pack(push, 4)
  34. // #include "MvCameraControl.h"
  35. // #pragma pack(pop)
  36. #include <MvCameraControl.h>
  37. #include <PixelType.h>
  38. #include <QMutex>
  39. #include <QWaitCondition>
  40. #include <QAtomicInt>
  41. #include <deque>
  42. #include <utility>
  43. //https://github.com/saki4510t/UVCCamera/pulls
  44. //https://gitee.com/dengly/UVCCamera
  45. //USBCamera: https://blog.csdn.net/hanshiying007/article/details/124118486
  46. #define CameraType 2 //0-QCamera , 1-OPENCV, 2-libuvc
  47. #define movZ_f "f80" //多图移动,正向80
  48. #define movZ_b "b80" //多图移动,反向80
  49. #define movX_f "f80" //多图移动,正向
  50. #define movX_b "b80" //多图移动,反向
  51. #define focux_f "f4" //单步对焦,正向
  52. #define focus_b "b4" //单步对焦,反向
  53. #define m_foucus_step_max 5
  54. #define focus_step_max 30
  55. //自动流程录制(对焦完成后自动录像)的最长录制时长,单位ms:
  56. //超过该时长仍未收到控制板的 record_stop 指令,则自动结束录制(走与 record_stop 相同的分析/融合流程)
  57. //可通过编译选项 -DRECORD_TIMEOUT_MS=xxx 覆盖
  58. #ifndef RECORD_TIMEOUT_MS
  59. #define RECORD_TIMEOUT_MS 10000 //10S
  60. #endif
  61. //【步进对焦】单步"记录一帧到 rawv"的最长等待时间(ms):
  62. // 主板每移动一步就等这一帧落盘后才继续,超时仍要回 focus,否则两侧一起卡死。
  63. // 5MP 原始帧约 5MB,正常 eMMC 写入 <100ms,留足余量给磁盘抖动。
  64. #define AF_STEP_RECORD_TIMEOUT_MS 3000
  65. //性能提升
  66. //https://blog.csdn.net/u012915226/article/details/115733359
  67. //https://blog.csdn.net/u012915226/article/details/121745861?spm=1001.2014.3001.5501
  68. //https://blog.csdn.net/aggs1990/article/details/125694175
  69. //自定义QVideoSink
  70. //https://blog.csdn.net/aggs1990/article/details/125361203?spm=1001.2014.3001.5501
  71. //github: 模块
  72. //https://github.com/erikmwerner/QUVCView/blob/master/uvccapture.cpp
  73. namespace Qt6QCamera {
  74. // ==================== 录制视频流异步写盘 ====================
  75. //取流线程只做"深拷贝入队",写盘由后台线程完成:
  76. // - 写盘不再阻塞取流,磁盘抖动/瞬时带宽不足不会直接压低录制帧率
  77. // - 队列按内存预算限流(默认192MB),超出时丢弃新帧并计数(保实时性)
  78. // - 配合"存相机原始帧(Bayer8 5MB/帧,而非BGRA 20MB/帧)"可把写盘吞吐需求降到1/4
  79. class RawRecordWriter : public QThread
  80. {
  81. public:
  82. explicit RawRecordWriter(QObject *parent = nullptr);
  83. ~RawRecordWriter() override;
  84. //打开文件并写入占位文件头(由UI线程调用)
  85. bool begin(const QString &path);
  86. //入队一帧(内部深拷贝,调用方可立即复用传入矩阵)
  87. void enqueue(const cv::Mat &frame, int pixelFormat);
  88. //入队一帧并等待该帧真正落盘(对焦步进握手专用):
  89. // 主板每移动一步发 movy,工控机必须先把该位置的帧写进 rawv 再回 focus,
  90. // 否则帧率/清晰度采样与磁盘写入会错位(现场表现为对焦结果漂移)。
  91. // timeoutMs 为本帧最长等待时间,超时返回 false(调用方仍应继续握手,避免整体卡死)。
  92. bool enqueueAndWait(const cv::Mat &frame, int pixelFormat, int timeoutMs);
  93. //排空队列+回填文件头+关闭文件,返回写入帧数;出参返回帧尺寸、行字节数与像素格式
  94. //帧率由内部计时(begin→finish)自行换算,调用方无需关心
  95. int finish(int &width, int &height, int &stride, int &pixelFormat);
  96. //队列内存预算(字节),超出后丢弃新帧
  97. void setBudgetBytes(qint64 bytes);
  98. qint64 droppedFrames() const { return m_dropped.loadRelaxed(); }
  99. bool isActive() const { return m_active; }
  100. protected:
  101. void run() override;
  102. private:
  103. QMutex m_mutex;
  104. QWaitCondition m_cond;
  105. std::deque<std::pair<cv::Mat,int>> m_queue;
  106. qint64 m_queuedBytes = 0;
  107. qint64 m_budget = 192LL * 1024 * 1024; //默认192MB
  108. bool m_stop = false;
  109. bool m_flushing = false;
  110. bool m_active = false;
  111. QFile m_file;
  112. QString m_path;
  113. int m_width = 0;
  114. int m_height = 0;
  115. int m_stride = 0;
  116. int m_pixelFormat = 0;
  117. int m_count = 0;
  118. //落盘确认计数:每入队一帧 m_enqueued+1,写线程每处理完一帧 m_written+1,
  119. //enqueueAndWait() 以 "m_written >= 本帧序号" 判定该帧已落盘
  120. int m_enqueued = 0;
  121. int m_written = 0;
  122. QAtomicInt m_dropped = 0;
  123. QElapsedTimer m_elapsed;
  124. };
  125. // 定义一个包含信号的发送类
  126. class SenderCustom : public QObject {
  127. Q_OBJECT
  128. public:
  129. // 定义一个信号,无参数
  130. signals:
  131. void signalToSend(const cv::Mat& frame);
  132. void signalQStr(const QString &qst);
  133. public:
  134. void sendSignal(const cv::Mat& frame) {
  135. emit signalToSend(frame); // 发送信号
  136. }
  137. void sendQStr(const QString &qst){
  138. signalQStr(qst);
  139. }
  140. };
  141. class FPSTimer : public QObject
  142. {
  143. Q_OBJECT
  144. public:
  145. explicit FPSTimer(QObject *parent = nullptr);
  146. public slots:
  147. void incrementFrame() { m_frame_count++; }
  148. void setInterval(int interval);
  149. void setRunning(bool running);
  150. bool isRunning();
  151. signals:
  152. void fpsUpdated(double);
  153. private slots:
  154. void onTimerTimeout();
  155. private:
  156. QTimer* m_timer = nullptr;
  157. QElapsedTimer* m_elapsed_timer = nullptr;
  158. int m_interval = 1000;
  159. int m_frame_count = 0;
  160. };
  161. //
  162. // Frames
  163. //
  164. struct RawFrame
  165. {
  166. int width;
  167. int height;
  168. MvGvspPixelType pixelType;
  169. QByteArray data; // 原始 buffer 拷贝
  170. };
  171. //! Frames listener.
  172. class Frames :public QObject//, public QQuickImageProvider //QObject //
  173. {
  174. Q_OBJECT
  175. QML_ELEMENT
  176. Q_PROPERTY( QVideoSink* videoSink READ videoSink WRITE setVideoSink NOTIFY videoSinkChanged )
  177. Q_PROPERTY( QString formatString READ formatString NOTIFY formatStringChanged )
  178. Q_PROPERTY( QString fpsString READ fpsString NOTIFY fpsStringChanged )
  179. Q_PROPERTY( QString qulityString READ qulityString NOTIFY qulityStringChanged )
  180. Q_PROPERTY( bool auto_clicked READ auto_clicked WRITE setChange NOTIFY btnStatusChanged )
  181. Q_PROPERTY( bool camera_sw READ camera_sw WRITE setCameraSw NOTIFY cameraStaChanged )
  182. Q_PROPERTY(QString cam_ExposureTime READ cam_ExposureTime WRITE setExposureTime NOTIFY exposureTimeChanged)
  183. //海康相机常用参数:型号展示/亮度(自动曝光目标灰度)/白平衡(自动模式+红蓝比例)
  184. Q_PROPERTY(QString cam_ModelName READ cam_ModelName NOTIFY cameraInfoChanged)
  185. Q_PROPERTY(QString cam_Brightness READ cam_Brightness WRITE setBrightness NOTIFY brightnessChanged)
  186. Q_PROPERTY(int cam_WhiteBalanceMode READ cam_WhiteBalanceMode WRITE setWhiteBalanceMode NOTIFY whiteBalanceModeChanged)
  187. Q_PROPERTY(QString cam_BalanceRatioR READ cam_BalanceRatioR WRITE setBalanceRatioR NOTIFY balanceRatioChanged)
  188. Q_PROPERTY(QString cam_BalanceRatioB READ cam_BalanceRatioB WRITE setBalanceRatioB NOTIFY balanceRatioChanged)
  189. Q_PROPERTY( bool recording READ recording NOTIFY recordingChanged )
  190. //已录制帧数(rawv 里实际写入的帧数): 步进扫描时每步应只 +1, 用于界面核对
  191. //"移动 N 步是否只录了 N 帧", 也用于现场判断是否有多记/漏记
  192. Q_PROPERTY( int recordedFrames READ recordedFrames NOTIFY recordedFramesChanged )
  193. //录制视频流的分析/融合处理中(期间挂起相机画面输出并在界面显示进度)
  194. Q_PROPERTY( bool processing READ processing NOTIFY processingChanged )
  195. Q_PROPERTY( QString processMessage READ processMessage NOTIFY processProgressChanged )
  196. Q_PROPERTY( int processPercent READ processPercent NOTIFY processProgressChanged )
  197. //【融合开关按钮】直接读写真 param::fusion_enable(与 MQTT fusion_sw 同一个运行时开关)。
  198. // 关掉时 processRecordedVideo 只保留最清晰帧、不做景深融合。按钮改的是运行时值,不写 sqlite。
  199. Q_PROPERTY( bool fusionEnabled READ fusionEnabled WRITE setFusionEnabled NOTIFY fusionEnabledChanged )
  200. //【临时调试开关】打开后录制结束不删除 rawv 录制文件(便于复盘/回放),
  201. // 默认关闭, 只存在内存里(不写库、重启复位), 界面上的按钮仅本机临时用。
  202. Q_PROPERTY( bool debugKeepRecord READ debugKeepRecord WRITE setDebugKeepRecord NOTIFY debugKeepRecordChanged )
  203. public:
  204. static void registerQmlType();
  205. explicit Frames(QObject * parent = nullptr);
  206. ~Frames() override;
  207. //! Set sink of video output.
  208. void setVideoSink( QVideoSink * newVideoSink );
  209. bool isDecoding() { return m_decoding; }
  210. //! \return Sink of video output.
  211. QVideoSink* videoSink() const { return m_videoSink; }
  212. //! set btn
  213. void setChange(bool stat_t);
  214. //! 相机状态
  215. void setCameraSw(bool stat_cam);
  216. void setExposureTime(const QString &exptime);
  217. QString cam_ModelName() const;
  218. QString cam_Brightness() const;
  219. void setBrightness(const QString &val);
  220. int cam_WhiteBalanceMode() const;
  221. void setWhiteBalanceMode(int mode);
  222. QString cam_BalanceRatioR() const;
  223. void setBalanceRatioR(const QString &val);
  224. QString cam_BalanceRatioB() const;
  225. void setBalanceRatioB(const QString &val);
  226. //! \return Rotation angle.
  227. //! \return Format of video frame as string.
  228. QString formatString() const;
  229. //! \return FPS as string.
  230. QString fpsString() const;
  231. QString qulityString() const;
  232. QString cam_ExposureTime() const;
  233. bool auto_clicked() const;
  234. bool camera_sw() const;
  235. void saveImage();
  236. Q_INVOKABLE void captureImage();
  237. //抓图按钮:模拟MCU拍照指令(camera_tc=1),下一帧按序号保存/锐化/上传
  238. Q_INVOKABLE void manualCapture();
  239. //录制原始(未压缩)视频流:开始录制;停止时回填文件头并把视频流保存到文件系统
  240. Q_INVOKABLE bool startRecord();
  241. Q_INVOKABLE void stopRecord();
  242. bool recording() const { return m_recording; }
  243. int recordedFrames() const { return m_recordedFrames.load(); }
  244. //融合开关(读写 param::fusion_enable,运行时生效,不落库)
  245. bool fusionEnabled() const;
  246. void setFusionEnabled(bool on);
  247. //临时调试:保留录制文件
  248. bool debugKeepRecord() const { return m_debugKeepRecord; }
  249. void setDebugKeepRecord(bool on);
  250. //处理中标志(取流线程读取,故用原子量)
  251. bool processing() const { return m_processing.loadRelaxed() != 0; }
  252. QString processMessage() const { return m_processMessage; }
  253. int processPercent() const { return m_processPercent; }
  254. //收到控制板 record_stop 指令:停止录制 -> 清晰度分析 -> 景深融合 -> 删除录制文件 -> 上传融合图片
  255. Q_INVOKABLE void handleRecordStop();
  256. //inline ImageProvider *getImageProvider() { return m_pImgProvider; }
  257. //ImageProvider* imageProvider() const;
  258. static void ImageCallBackEx(unsigned char * pData, MV_FRAME_OUT_INFO_EX* pFrameInfo, void* pUser);
  259. bool createFolder(const QString &path) {
  260. QDir dir(path);
  261. if (dir.exists()) {
  262. LOG("文件夹已存在:{}",path.toStdString());
  263. return true;
  264. }
  265. if (dir.mkpath(".")) {
  266. LOG("文件夹创建成功:{}",path.toStdString());
  267. return true;
  268. } else {
  269. ERROR("文件夹创建失败:{}",path.toStdString());
  270. return false;
  271. }
  272. }
  273. signals:
  274. //! Video sink changed.
  275. void videoSinkChanged();
  276. void cameraOpenFailed(const QString &err);
  277. void formatStringChanged();
  278. void fpsStringChanged();
  279. void qulityStringChanged();
  280. void exposureTimeChanged();
  281. //相机常用参数变化(型号/亮度/白平衡)
  282. void cameraInfoChanged();
  283. void brightnessChanged();
  284. void whiteBalanceModeChanged();
  285. void balanceRatioChanged();
  286. void frameAvailable(const QVideoFrame &frame);
  287. void frameReady(QImage image);
  288. void btnStatusChanged();
  289. void sendFocusFlag(QString flag_sta);
  290. void cameraStaChanged(bool sta_cam);
  291. void serial_data(const QByteArray &m_byte);
  292. void signal_stitch();
  293. //hikrobot
  294. void startGrabbing(bool sta_cam);
  295. void signalGrabing(unsigned char * nData);
  296. void callQmlRefeshImg();
  297. void signal_m1s();
  298. void dataUpload(const QByteArray &data); //到mqtt
  299. void signal_photoerr();
  300. void stopGrabbing(bool sta_cam);
  301. void signal_photo_saved();
  302. void signal_wait_upload(const QString &path);
  303. void signal_cache_image(const QString &path);
  304. void signal_sharp_processed(const QString &name_sharp); //锐化/对比度后台处理完成,回主线程统一入队入库
  305. void stepCountChanged(const QString step);
  306. void recordingChanged();
  307. void recordedFramesChanged();
  308. void processingChanged();
  309. //分析/融合进度变化(主线程发出)
  310. void processProgressChanged();
  311. //融合开关 / 调试保留录制帧 状态变化(界面按钮文字刷新)
  312. void fusionEnabledChanged();
  313. void debugKeepRecordChanged();
  314. //录制结束,视频流已保存到path
  315. void recordFileSaved(const QString &path);
  316. public slots:
  317. void onMovDone(const QString stepcount){
  318. if(!camera_sw()){
  319. ERROR("Camera error!");
  320. setCameraSw(false);
  321. return;
  322. }
  323. cv::Mat snapshot;
  324. {
  325. // 锁内只做浅拷贝(引用计数保护数据),快速释放锁,避免阻塞取流线程写入 m_frame
  326. QMutexLocker locker(&m_frameMutex);
  327. if (m_frame.empty()) {
  328. // 取流尚未写入首帧时触发(如移动完成先于取流),不更新清晰度
  329. LOG("onMovDone: m_frame empty, skip");
  330. emit stepCountChanged(stepcount);
  331. return;
  332. }
  333. snapshot = m_frame;
  334. }
  335. //【录制=按串口信号存帧,不是持续录制】
  336. // 主板移动完成后发 movy,本机才把"当前位置最近一帧"写进 rawv,
  337. // 确认落盘后再回 focus —— 主板收到 focus 才继续下一步,这就是"记录完成后恢复"。
  338. // 取流线程不写盘,只缓存最近一帧(见 processFrameAsync)。
  339. // 超时(磁盘抖动/满了)也照常回 focus,避免两侧互相等待卡死。
  340. //
  341. //【顺序】先录制当前帧, 落盘完成之后再算清晰度、再回复主板:
  342. // 清晰度取"刚刚落盘的那一帧"对应的显示帧(m_afStepDisplay, 同一次取流循环写入),
  343. // 不再用"此刻最新的预览帧" —— 否则回复的清晰度可能对应下一帧,
  344. // 与 rawv 里存的那一帧不是同一张图, 主板据此选最佳位置/判波动会失真。
  345. if(m_recording){
  346. //【每步只录一帧】主板 af_linear_step 每步发一次 movy, 但 focus 超时补发(hmi.c)、
  347. // 扫描状态机被重新初始化、串口重包等情况会让同一位置的 movy 再次到达;
  348. // 照单全收就会出现"移动 100 步写出 200 帧"。这里按步号去重: 同一步号只落一帧。
  349. // 注意: 仍然照常回 focus, 否则主板等不到握手会超时补发,越补越多。
  350. const int stepNo = stepcount.toInt();
  351. const bool validStep = (stepNo > 0); //旧协议/异常值不做去重,避免只录到第一帧
  352. const qint64 nowMs = QDateTime::currentMSecsSinceEpoch();
  353. // 同一步号即判重复; 但步号 1 只在"距上次 <15s"时才算:
  354. // 新一轮扫描时主板的 g_laf.step_cnt 从 0 重新计数(hmi.c af_linear_step),
  355. // 若单纯比步号, 上一轮恰好停在 1 步就会把新一轮的第一帧吞掉。
  356. // focus 超时补发间隔是 5s(最多 3 次), 15s 足以覆盖真正的重发。
  357. const bool dupStep = validStep && stepNo == m_afLastStepNo
  358. && (stepNo > 1 || (nowMs - m_afLastStepMs) < 15000);
  359. if(dupStep){
  360. LOG("onMovDone: 步{} 重复上报,跳过记帧(已录{}帧)",
  361. stepcount.toStdString(),m_recordedFrames.load());
  362. }else{
  363. if(validStep) { m_afLastStepNo = stepNo; m_afLastStepMs = nowMs; }
  364. cv::Mat shot; //与本次落盘帧同一时刻的显示帧
  365. if(recordStepFrame(AF_STEP_RECORD_TIMEOUT_MS, &shot)){
  366. LOG("onMovDone: 步{} 该位置帧已落盘(已录{}帧)",
  367. stepcount.toStdString(),m_recordedFrames.load());
  368. }else{
  369. WARN("onMovDone: 步{} 帧记录超时,继续握手",stepcount.toStdString());
  370. }
  371. //录制完成后用"已落盘那一帧"算清晰度(取不到才退回最新预览帧)
  372. if(!shot.empty()) snapshot = shot;
  373. }
  374. //扫描期间看门狗语义变成"本步最长等待时间":每步续期一次
  375. if(m_recordTimeout) m_recordTimeout->start(RECORD_TIMEOUT_MS);
  376. }
  377. //【清晰度在录制完成之后才算】上面的 recordStepFrame 内部已经等真正落盘,
  378. // 这里的 snapshot 就是刚写进 rawv 的那一帧(未录制时是最近一帧预览)
  379. m_qulityString = m_opencvfunc.Tenengrad(snapshot);
  380. LOG("onMovDone:{}",m_qulityString.toStdString());
  381. emit serial_data(m_json.ImageFunc(m_qulityString.toDouble()));
  382. emit qulityStringChanged();
  383. emit stepCountChanged(stepcount);
  384. }
  385. // void parseFrame(const cv::Mat& frame);
  386. Q_INVOKABLE void upload_handle(void);
  387. Q_INVOKABLE void handle_reult_upload(bool success, const QString &filePath); //filePath: 传完的文件(由上传器 finished 带回)
  388. void onFPSUpdated(double fps);
  389. private slots:
  390. //! Init camera.
  391. void initCam();
  392. void handleGrab(bool sta_cam);
  393. //! 1s timer.
  394. void timer();
  395. //!
  396. void update_qulstr(QString q_str);
  397. //
  398. void saveMatAsJpeg(const QVideoFrame &frame);
  399. void onSharpProcessed(const QString &name_sharp);
  400. //void sendData(QByteArray m_byte);
  401. void displayFrame(const QVideoFrame &frame);
  402. void mov_x_z_run();
  403. void processFrameAsync(const RawFrame& frame);
  404. //录制中:把当前未压缩原始帧写入视频流文件(处理线程调用)
  405. //录制入队:frame 为相机原始帧(Bayer8 CV_8UC1 / YUYV CV_8UC2)或已转换 BGRA,
  406. //pixelFormat 见 RawPixelFormat;内部深拷贝后由后台线程写盘,不阻塞取流
  407. //【步进对焦】把"当前位置最近一帧原始帧"写进 rawv 并等待落盘(同步)
  408. //返回 true=已落盘, false=无缓存帧/写入超时
  409. //displayOut: 输出"与本次落盘帧同一时刻的显示帧"(BGRA, 浅拷贝共享数据, 不额外拷贝内存),
  410. // 用于录制完成后计算清晰度 —— 保证回给主板的清晰度和写进 rawv 的是同一帧。
  411. bool recordStepFrame(int timeoutMs, cv::Mat *displayOut = nullptr);
  412. //录制超时(超过 RECORD_TIMEOUT_MS 未收到 record_stop):自动结束录制并处理视频流
  413. void onRecordTimeout();
  414. //*提前恢复相机取流(预热):在保存结果图片阶段就 StartGrabbing,
  415. //避免等处理全部结束(含上传)才恢复导致下次采集启动卡顿*//
  416. void warmupCamera();
  417. //置处理中标志(挂起相机画面输出)
  418. void setProcessing(bool on);
  419. //更新处理进度(仅主线程调用)
  420. void setProcessProgress(const QString &message, int percent);
  421. private:
  422. Q_DISABLE_COPY( Frames )
  423. //声明相机捕获对象
  424. //! Video sink of video output.
  425. //QPointer< QVideoSink > m_videoSink;
  426. QVideoSink *m_videoSink;
  427. //! Format string.
  428. QString m_formatString;
  429. //! FPS string.
  430. QString m_fpsString;
  431. //! FPS.
  432. int m_fps;
  433. //! 清晰度
  434. QString m_qulityString;
  435. //! Timer.
  436. QTimer *m_1s;
  437. //! QVideoFrame
  438. OpencvFunc m_opencvfunc;
  439. JsonFunc m_json;
  440. QFuture<void> m_grabThread;
  441. //独立上传队列:与param::ptlist(拼接输入)隔离,每保存一张锐化/对比度图立即入队逐张上传
  442. QStringList m_uploadQueue;
  443. //正在上传的文件(图片队列用):上传完成回调据此判断是哪一张传完、是否推进队列
  444. QString m_uploadingPath;
  445. bool m_isUploading = false; //是否正在上传,防止并发启动多个上传线程
  446. QJniObject *jClass;
  447. bool camera_sta;
  448. bool m_decoding;
  449. bool m_streaming_active = false;
  450. QImage m_image;
  451. int m_width;
  452. int m_height;
  453. //相机当前输出帧的像素格式(MvGvspPixelType),取流线程写入,状态栏显示
  454. quint32 m_pixelType = 0;
  455. QString m_fExposureTime;
  456. //海康相机常用参数(打开相机后回读,qml回显)
  457. QString m_camModelName;
  458. QString m_camBrightness;
  459. int m_camWhiteBalanceMode = 0; //qml索引:0-关闭 1-自动一次 2-连续自动
  460. QString m_camBalanceRatioR;
  461. QString m_camBalanceRatioB;
  462. //打开相机后读取型号/亮度/白平衡参数
  463. void readCameraParams();
  464. //手动写白平衡比例,selector: 0-红 1-绿 2-蓝
  465. void applyBalanceRatio(int selector, const QString &val);
  466. //ImageProvider *m_pImgProvider;
  467. //libuvc
  468. mutable QMutex m_frameMutex; // 互斥锁,用于对帧队列的访问进行同步
  469. FPSTimer* m_fps_timer = nullptr;
  470. cv::Mat m_frame;
  471. QSemaphore m_frameGate; // 在途帧处理任务门禁(构造初值=3),防止任务积压导致内存暴涨
  472. QAtomicInt m_displayPending = 0; // 显示节流:UI线程未消费完上一帧时丢弃当前帧,只保留最新帧
  473. int image_num = 1;
  474. int z_step = 0;
  475. int x_step = 0;
  476. //保护 image_num/z_step/x_step 及"取号-建名-存图-自增-移轴"整段流程,
  477. //saveMatAsJpeg 由 QtConcurrent 线程池并发调用,无锁会导致重号覆盖、序号跳变、轴重复移动
  478. mutable QMutex m_saveMutex;
  479. //图片归档路径
  480. QString picture_path_floader;
  481. QVector<cv::Mat> m_frame_buffer;
  482. //原始视频流录制:取流线程只把"相机原始帧"入队(Bayer8/YUYV,体积远小于BGRA),
  483. //由 RawRecordWriter 后台线程写盘,停止时回填文件头
  484. bool m_recording = false;
  485. RawRecordWriter m_recordWriter;
  486. QString m_recordPath;
  487. int m_recordWidth = 0;
  488. int m_recordHeight = 0;
  489. int m_recordStride = 0;
  490. int m_recordFrameCount = 0;
  491. QElapsedTimer m_recordElapsed;
  492. //本次停止录制后是否丢弃录制文件(record_stop 流程处理完即删除,不再提示"已保存")
  493. bool m_recordDiscard = false;
  494. //录制性能诊断(定位录制帧率瓶颈:相机产帧/Bayer转换/写盘 各占多少)
  495. qint64 m_diagFrames = 0; //已统计帧数
  496. qint64 m_diagWriteUsec = 0; //写盘累计耗时(us)
  497. qint64 m_diagCvtUsec = 0; //Bayer转换累计耗时(us)
  498. qint64 m_diagGapMsec = 0; //相邻帧到达间隔累计(ms,帧数-1个间隔)
  499. qint64 m_diagLastFrameMsec = 0;
  500. //保护录制状态与文件写入,startRecord/stopRecord(UI线程)与writeRecordFrame(处理线程)互斥
  501. mutable QMutex m_recordMutex;
  502. //录制超时看门狗:自动流程录制期间启动,超时未收到 record_stop 则自动结束录制
  503. //【步进对焦】扫描期间每个 movy 都会续期一次,即"本步最长等待时间"
  504. QTimer *m_recordTimeout = nullptr;
  505. //【录制=按串口信号存帧】任何录制期间都不逐帧写盘,rawv 里只有"主板每移动一步的一帧",
  506. // 由 onMovDone -> recordStepFrame 同步写入并等待落盘。
  507. // 取流线程只维护最近一帧原始帧(由 m_frameMutex 保护),不做任何写盘。
  508. // m_afStepRecord 仅表示"步进模式"(决定 startRecord 是否向主板发 record_start)。
  509. std::atomic<bool> m_afStepRecord{false};
  510. cv::Mat m_afStepFrame; //最近一帧相机原始帧(Bayer8/YUYV),收到 movy 时落盘
  511. int m_afStepFmt = -1; //上面这帧的像素格式(RawPixelFormat),-1=无
  512. //上面这帧对应的显示帧(BGRA, 与 m_afStepFrame 同一次取流循环写入):
  513. //录制完成后用它算清晰度, 保证清晰度与落盘帧同帧
  514. cv::Mat m_afStepDisplay;
  515. //上一次已落盘的步号: 同一步号再次收到 movy 时不再写盘(见 onMovDone)
  516. int m_afLastStepNo = -1;
  517. //上面这条 movy 的到达时刻(ms), 只用于判断"步号 1"是新一轮扫描还是超时补发
  518. qint64 m_afLastStepMs = 0;
  519. //已写入 rawv 的帧数(界面显示用, 开始录制时清零)
  520. std::atomic<int> m_recordedFrames{0};
  521. //临时调试开关: true 时录制结束保留 rawv 文件(默认 false, 不写库, 重启复位)
  522. bool m_debugKeepRecord = false;
  523. //融合开关的界面状态副本: param::fusion_enable 会被 MQTT/读库改,
  524. // 由 onFPSUpdated 每秒对齐一次并 emit fusionEnabledChanged,界面才不会和实际状态不一致
  525. bool m_fusionEnabled = true;
  526. //分析/融合处理中:取流端据此挂起转换与画面输出,把CPU让给后台重计算任务
  527. QAtomicInt m_processing = 0;
  528. //保存结果图片阶段已提前恢复取流(相机预热):1=已预热,setProcessing(false) 时不再重复 StartGrabbing
  529. QAtomicInt m_cameraWarmup = 0;
  530. QString m_processMessage;
  531. int m_processPercent = 0;
  532. //预览降帧:上次推送预览画面的时刻(ms),由多个取流处理线程读写
  533. QAtomicInteger<qint64> m_lastPreviewMs = 0;
  534. //取流暂停标志:分析/融合期间停止相机取流(SDK停流),结束后恢复取流
  535. QAtomicInt m_grabPaused = 0;
  536. int testJNI();
  537. int checkPermission(void)
  538. {
  539. int ret = 0;
  540. const static char* MY_JAVA_CLASS = "GetUsbPermission";
  541. ret = QJniObject::callStaticMethod<jint>(MY_JAVA_CLASS,"checkPermission","()I");
  542. return ret;
  543. }
  544. static inline QImage cvMatToQImage( const cv::Mat &inMat )
  545. {
  546. switch ( inMat.type() )
  547. {
  548. // 8-bit, 4 channel
  549. case CV_8UC4:
  550. {
  551. QImage image( inMat.data, inMat.cols, inMat.rows, inMat.step, QImage::Format_RGB32 );
  552. return image;
  553. }
  554. // 8-bit, 3 channel
  555. case CV_8UC3:
  556. {
  557. QImage image( inMat.data, inMat.cols, inMat.rows, inMat.step, QImage::Format_RGB888 );
  558. return image.rgbSwapped();
  559. }
  560. // 8-bit, 1 channel
  561. case CV_8UC1:
  562. {
  563. static QVector<QRgb> sColorTable;
  564. // only create our color table once
  565. if ( sColorTable.isEmpty() )
  566. {
  567. for ( int i = 0; i < 256; ++i )
  568. sColorTable.push_back( qRgb( i, i, i ) );
  569. }
  570. QImage image( inMat.data, inMat.cols, inMat.rows, inMat.step, QImage::Format_Indexed8 );
  571. image.setColorTable( sColorTable );
  572. return image;
  573. }
  574. default:
  575. WARN("ASM::cvMatToQImage() - cv::Mat image type not handled in switch: {}", static_cast<int>(inMat.type()));
  576. break;
  577. }
  578. return QImage();
  579. }
  580. static cv::Mat QImageToCvMat(QImage inImage, bool inCloneImageData = true)
  581. {
  582. switch (inImage.format())
  583. {
  584. // 8-bit, 4 channel
  585. case QImage::Format_ARGB32:
  586. case QImage::Format_ARGB32_Premultiplied:
  587. {
  588. cv::Mat mat(inImage.height(), inImage.width(),
  589. CV_8UC4,
  590. const_cast<uchar*>(inImage.bits()),
  591. static_cast<size_t>(inImage.bytesPerLine())
  592. );
  593. return inCloneImageData ? mat.clone() : mat;
  594. }
  595. // 8-bit, 3 channel
  596. case QImage::Format_RGB32:
  597. {
  598. if (!inCloneImageData) {
  599. WARN("QImageToCvMat() - Conversion requires cloning so we don't modify the original QImage data");
  600. }
  601. cv::Mat mat(inImage.height(), inImage.width(),
  602. CV_8UC4,
  603. const_cast<uchar*>(inImage.bits()),
  604. static_cast<size_t>(inImage.bytesPerLine())
  605. );
  606. cv::Mat matNoAlpha;
  607. cv::cvtColor(mat, matNoAlpha, cv::COLOR_BGRA2BGR); // drop the all-white alpha channel
  608. return matNoAlpha;
  609. }
  610. // 8-bit, 3 channel
  611. case QImage::Format_RGB888:
  612. {
  613. if (!inCloneImageData) {
  614. WARN("QImageToCvMat() - Conversion requires cloning so we don't modify the original QImage data");
  615. }
  616. QImage swapped = inImage.rgbSwapped();
  617. cv::Mat mat(swapped.height(), swapped.width(),
  618. CV_8UC3,
  619. const_cast<uchar*>(swapped.bits()),
  620. static_cast<size_t>(swapped.bytesPerLine())
  621. );
  622. return inCloneImageData ? mat.clone() : mat;
  623. }
  624. // 8-bit, 1 channel
  625. case QImage::Format_Grayscale8:
  626. case QImage::Format_Indexed8:
  627. {
  628. cv::Mat mat(inImage.height(), inImage.width(),
  629. CV_8UC1,
  630. const_cast<uchar*>(inImage.bits()),
  631. static_cast<size_t>(inImage.bytesPerLine())
  632. );
  633. return inCloneImageData ? mat.clone() : mat;
  634. }
  635. #if QT_VERSION >= QT_VERSION_CHECK(5, 13, 0)
  636. case QImage::Format_Grayscale16:
  637. {
  638. cv::Mat mat(cv::Size(inImage.width(),inImage.height()),CV_16U,const_cast<uchar*>(inImage.bits()),cv::Mat::AUTO_STEP);
  639. return inCloneImageData ? mat.clone() : mat;
  640. }
  641. #endif
  642. default:
  643. WARN("QImageToCvMat() - QImage format not handled in switch: {}", static_cast<int>(inImage.format()));
  644. break;
  645. }
  646. return cv::Mat();
  647. }
  648. bool IsColor(MvGvspPixelType enType)
  649. {
  650. switch(enType)
  651. {
  652. case PixelType_Gvsp_BGR8_Packed:
  653. case PixelType_Gvsp_YUV422_Packed:
  654. case PixelType_Gvsp_YUV422_YUYV_Packed:
  655. case PixelType_Gvsp_BayerGR8:
  656. case PixelType_Gvsp_BayerRG8:
  657. case PixelType_Gvsp_BayerGB8:
  658. case PixelType_Gvsp_BayerBG8:
  659. case PixelType_Gvsp_BayerGB10:
  660. case PixelType_Gvsp_BayerGB10_Packed:
  661. case PixelType_Gvsp_BayerBG10:
  662. case PixelType_Gvsp_BayerBG10_Packed:
  663. case PixelType_Gvsp_BayerRG10:
  664. case PixelType_Gvsp_BayerRG10_Packed:
  665. case PixelType_Gvsp_BayerGR10:
  666. case PixelType_Gvsp_BayerGR10_Packed:
  667. case PixelType_Gvsp_BayerGB12:
  668. case PixelType_Gvsp_BayerGB12_Packed:
  669. case PixelType_Gvsp_BayerBG12:
  670. case PixelType_Gvsp_BayerBG12_Packed:
  671. case PixelType_Gvsp_BayerRG12:
  672. case PixelType_Gvsp_BayerRG12_Packed:
  673. case PixelType_Gvsp_BayerGR12:
  674. case PixelType_Gvsp_BayerGR12_Packed:
  675. return true;
  676. default:
  677. return false;
  678. }
  679. }
  680. bool IsMono(MvGvspPixelType enType)
  681. {
  682. switch(enType)
  683. {
  684. case PixelType_Gvsp_Mono10:
  685. case PixelType_Gvsp_Mono10_Packed:
  686. case PixelType_Gvsp_Mono12:
  687. case PixelType_Gvsp_Mono12_Packed:
  688. return true;
  689. default:
  690. return false;
  691. }
  692. }
  693. //地址的转换函数
  694. bool ConvertToHexIp(unsigned int *nHexIP, unsigned int *nDecIP)
  695. {
  696. if ( nDecIP[0] < 0 || nDecIP[0] > 255
  697. || nDecIP[1] < 0 || nDecIP[1] > 255
  698. || nDecIP[2] < 0 || nDecIP[2] > 255
  699. || nDecIP[3] < 0 || nDecIP[3] > 255)
  700. {
  701. return false;
  702. }
  703. *nHexIP = (nDecIP[0] << 24) + (nDecIP[1] << 16) + (nDecIP[2] << 8) + nDecIP[3];
  704. return true;
  705. }
  706. }; // class Frames
  707. //! 原始视频流(.rawv)播放器:逐帧读取未压缩的原始帧并推送到 QVideoSink 播放
  708. class RawVideoPlayer : public QObject
  709. {
  710. Q_OBJECT
  711. QML_ELEMENT
  712. Q_PROPERTY( QVideoSink* videoSink READ videoSink WRITE setVideoSink NOTIFY videoSinkChanged )
  713. Q_PROPERTY( bool playing READ playing NOTIFY playingChanged )
  714. Q_PROPERTY( bool loaded READ loaded NOTIFY loadedChanged )
  715. Q_PROPERTY( int position READ position NOTIFY positionChanged )
  716. Q_PROPERTY( int frameCount READ frameCount NOTIFY frameCountChanged )
  717. Q_PROPERTY( QString source READ source NOTIFY sourceChanged )
  718. Q_PROPERTY( bool busy READ busy NOTIFY busyChanged )
  719. public:
  720. explicit RawVideoPlayer(QObject *parent = nullptr);
  721. QVideoSink* videoSink() const { return m_videoSink; }
  722. void setVideoSink(QVideoSink *newVideoSink);
  723. bool playing() const { return m_playing; }
  724. bool loaded() const { return m_loaded; }
  725. int position() const { return m_position; }
  726. int frameCount() const { return m_frameCount; }
  727. QString source() const { return m_source; }
  728. bool busy() const { return m_busy; }
  729. //打开原始视频流文件,成功后可调用 play()
  730. Q_INVOKABLE bool open(const QString &path);
  731. Q_INVOKABLE void play();
  732. Q_INVOKABLE void pause();
  733. Q_INVOKABLE void stop();
  734. //定位到指定帧(立即刷新画面)
  735. Q_INVOKABLE void seek(int frameIndex);
  736. Q_INVOKABLE void close();
  737. //删除当前打开/播放的录制视频流文件(.rawv),结果图片不受影响
  738. Q_INVOKABLE bool removeCurrentFile();
  739. //判断文件是否为原始视频流(.rawv)
  740. Q_INVOKABLE bool isRawVideo(const QString &path) const;
  741. //分析:识别视频帧中最清晰的一帧,锐化+对比度增强后保存为图片(与视频同目录)
  742. Q_INVOKABLE void analyzeSharpestFrame();
  743. //融合:在最清晰帧上下邻域选帧做景深融合,锐化+对比度增强后保存为图片(与视频同目录)
  744. Q_INVOKABLE void fuseVideoFrames();
  745. signals:
  746. void videoSinkChanged();
  747. void playingChanged();
  748. void loadedChanged();
  749. void positionChanged();
  750. void frameCountChanged();
  751. void sourceChanged();
  752. void busyChanged();
  753. //分析结束:path为空表示失败,成功时图片已保存到path
  754. void analyzeFinished(const QString &path);
  755. //融合结束:path为空表示失败,成功时图片已保存到path
  756. void fuseFinished(const QString &path);
  757. //当前视频流文件已被删除,path为被删除的文件路径
  758. void fileRemoved(const QString &path);
  759. private slots:
  760. void onTick();
  761. private:
  762. //读取并推送当前帧,失败返回false
  763. bool pushFrame();
  764. void setBusy(bool busy);
  765. //结果图片路径,命名与拍照图片一致:<视频时间戳>z0x0[_sharp]_<序号>.jpg
  766. QString resultPath(int serial, bool sharp) const;
  767. QFile m_file;
  768. QTimer m_timer;
  769. QVideoSink *m_videoSink = nullptr;
  770. QString m_source;
  771. int m_width = 0;
  772. int m_height = 0;
  773. int m_stride = 0;
  774. int m_fps = 0;
  775. int m_frameCount = 0;
  776. int m_position = 0;
  777. //视频流内帧的像素格式(见 RawPixelFormat),0=BGRA8 兼容旧文件
  778. int m_pixelFormat = 0;
  779. bool m_loaded = false;
  780. bool m_playing = false;
  781. //分析/融合任务进行中(进行中时不重复触发)
  782. bool m_busy = false;
  783. //同一视频内结果序号:分析结果与融合结果成对(_sharp_后缀)
  784. int m_resultSerial = 0;
  785. };
  786. } /* namespace Qt6QCamera */
  787. Q_DECLARE_METATYPE(cv::Mat)
  788. #endif // M_FRAMES_HPP