cameramanager.h 28 KB

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