cameramanager.h 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670
  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 <libuvc.h>
  24. #include <libusb.h>
  25. //#include <unrooted_android.h>
  26. #include <QSemaphore>
  27. #include <QQuickImageProvider>
  28. #include <QQmlImageProviderBase>
  29. #include <QImage>
  30. #include <pthread.h>
  31. //海康
  32. #include <MvCameraControl.h>
  33. //https://github.com/saki4510t/UVCCamera/pulls
  34. //https://gitee.com/dengly/UVCCamera
  35. //USBCamera: https://blog.csdn.net/hanshiying007/article/details/124118486
  36. #define CameraType 2 //0-QCamera , 1-OPENCV, 2-libuvc
  37. #define movY_f "f55" //多图移动,正向
  38. #define movY_b "b55" //多图移动,反向
  39. #define focux_f "f4" //单步对焦,正向
  40. #define focus_b "b4" //单步对焦,反向
  41. #define m_foucus_step_max 5
  42. #define focus_step_max 30
  43. //性能提升
  44. //https://blog.csdn.net/u012915226/article/details/115733359
  45. //https://blog.csdn.net/u012915226/article/details/121745861?spm=1001.2014.3001.5501
  46. //https://blog.csdn.net/aggs1990/article/details/125694175
  47. //自定义QVideoSink
  48. //https://blog.csdn.net/aggs1990/article/details/125361203?spm=1001.2014.3001.5501
  49. //github: 模块
  50. //https://github.com/erikmwerner/QUVCView/blob/master/uvccapture.cpp
  51. namespace Qt6QCamera {
  52. // 定义一个包含信号的发送类
  53. class SenderCustom : public QObject {
  54. Q_OBJECT
  55. public:
  56. // 定义一个信号,无参数
  57. signals:
  58. void signalToSend(const cv::Mat& frame);
  59. void signalQStr(const QString &qst);
  60. public:
  61. void sendSignal(const cv::Mat& frame) {
  62. emit signalToSend(frame); // 发送信号
  63. }
  64. void sendQStr(const QString &qst){
  65. signalQStr(qst);
  66. }
  67. };
  68. //
  69. class ImageProvider : public QQuickImageProvider{
  70. public:
  71. ImageProvider();
  72. QImage requestImage(const QString &id, QSize *size, const QSize &requestedSize);
  73. QPixmap requestPixmap(const QString &id, QSize *size, const QSize &requestedSize);
  74. void updateImage(QImage i_image);
  75. private:
  76. QImage qml_img;
  77. };
  78. class FPSTimer : public QObject
  79. {
  80. Q_OBJECT
  81. public:
  82. explicit FPSTimer(QObject *parent = nullptr);
  83. public slots:
  84. void incrementFrame() { m_frame_count++; }
  85. void setInterval(int interval);
  86. void setRunning(bool running);
  87. bool isRunning();
  88. signals:
  89. void fpsUpdated(double);
  90. private slots:
  91. void onTimerTimeout();
  92. private:
  93. QTimer* m_timer = nullptr;
  94. QElapsedTimer* m_elapsed_timer = nullptr;
  95. int m_interval = 1000;
  96. int m_frame_count = 0;
  97. };
  98. //
  99. // Frames
  100. //
  101. //! Frames listener.
  102. class Frames :public QObject//, public QQuickImageProvider //QObject //
  103. {
  104. Q_OBJECT
  105. QML_ELEMENT
  106. Q_PROPERTY( QVideoSink* videoSink READ videoSink WRITE setVideoSink NOTIFY videoSinkChanged )
  107. Q_PROPERTY( qreal angle READ angle NOTIFY angleChanged )
  108. Q_PROPERTY( qreal xScale READ xScale NOTIFY xScaleChanged )
  109. Q_PROPERTY( qreal yScale READ yScale NOTIFY yScaleChanged )
  110. Q_PROPERTY( QString formatString READ formatString NOTIFY formatStringChanged )
  111. Q_PROPERTY( QString fpsString READ fpsString NOTIFY fpsStringChanged )
  112. Q_PROPERTY( QString qulityString READ qulityString NOTIFY qulityStringChanged )
  113. Q_PROPERTY( bool auto_clicked READ auto_clicked WRITE setChange NOTIFY btnStatusChanged )
  114. Q_PROPERTY( bool camera_sw READ camera_sw WRITE setCameraSw NOTIFY cameraStaChanged )
  115. public:
  116. struct UVCCaptureDescriptor {
  117. uint16_t vendorID;
  118. uint16_t productID;
  119. uint16_t UVC_level;
  120. QString serial;
  121. QString manufacturer;
  122. QString productName;
  123. uvc_device_t* dev;
  124. };
  125. struct UVCCaptureProperties {
  126. uvc_frame_format format;
  127. QString formatString;
  128. QRect frameRect;
  129. int frameInterval;
  130. unsigned int bufferSize;
  131. UVCCaptureProperties():
  132. format(UVC_FRAME_FORMAT_YUYV),
  133. formatString("YUYV"),
  134. frameRect(QRect(0,0,640,480)),
  135. frameInterval(333333),
  136. bufferSize(0){}
  137. };
  138. //< matrix to store the current frame
  139. public:
  140. static void registerQmlType();
  141. explicit Frames(QObject * parent = nullptr);
  142. ~Frames() override;
  143. //! Set sink of video output.
  144. void setVideoSink( QVideoSink * newVideoSink );
  145. bool isDecoding() { return m_decoding; }
  146. //! \return Sink of video output.
  147. QVideoSink* videoSink() const { return m_videoSink; }
  148. //! set btn
  149. void setChange(bool stat_t);
  150. //! 相机状态
  151. void setCameraSw(bool stat_cam);
  152. //! \return Rotation angle.
  153. qreal angle() const;
  154. //! \return X scale factor.
  155. qreal xScale() const;
  156. //! \return Y scale factor
  157. qreal yScale() const;
  158. //! \return Format of video frame as string.
  159. QString formatString() const;
  160. //! \return FPS as string.
  161. QString fpsString() const;
  162. QString qulityString() const;
  163. bool auto_clicked() const;
  164. bool camera_sw() const;
  165. void saveImage();
  166. Q_INVOKABLE void captureImage();
  167. inline ImageProvider *getImageProvider() { return m_pImgProvider; }
  168. //ImageProvider* imageProvider() const;
  169. static void ImageCallBackEx(unsigned char * pData, MV_FRAME_OUT_INFO_EX* pFrameInfo, void* pUser);
  170. bool createFolder(const QString &path) {
  171. QDir dir(path);
  172. if (dir.exists()) {
  173. LOG("文件夹已存在:{}",path.toStdString());
  174. return true;
  175. }
  176. if (dir.mkpath(".")) {
  177. LOG("文件夹创建成功:{}",path.toStdString());
  178. return true;
  179. } else {
  180. ERROR("文件夹创建失败:{}",path.toStdString());
  181. return false;
  182. }
  183. }
  184. signals:
  185. //! Video sink changed.
  186. void videoSinkChanged();
  187. void angleChanged();
  188. void xScaleChanged();
  189. void yScaleChanged();
  190. void formatStringChanged();
  191. void fpsStringChanged();
  192. void qulityStringChanged();
  193. void frameAvailable(const QVideoFrame &frame);
  194. void uvcframeAvailable(const cv::Mat& frame);
  195. void frameReady(QImage image);
  196. void btnStatusChanged();
  197. void sendFocusFlag(QString flag_sta);
  198. void cameraStaChanged(bool sta_cam);
  199. void serial_data(const QByteArray &m_byte);
  200. void signal_stitch();
  201. //hikrobot
  202. void startGrabbing(bool sta_cam);
  203. void signalGrabing(unsigned char * nData);
  204. void callQmlRefeshImg();
  205. void signal_m1s();
  206. void dataUpload(const QByteArray &data); //到mqtt
  207. void signal_photoerr();
  208. void stopGrabbing(bool sta_cam);
  209. void signal_photo_saved();
  210. void signal_wait_upload(const QString &path);
  211. public slots:
  212. void onMovDone(){
  213. if(!camera_sw()){
  214. ERROR("Camera error!");
  215. setCameraSw(false);
  216. return;
  217. }
  218. m_qulityString = m_opencvfunc.Tenengrad(m_frame);
  219. LOG("onMovDone:{}",m_qulityString.toStdString());
  220. emit serial_data(m_json.ImageFunc(m_qulityString.toDouble()));
  221. emit qulityStringChanged();
  222. #if 0
  223. m_qulityString = m_opencvfunc.Tenengrad(m_frame);
  224. emit qulityStringChanged();
  225. LOG("onMovDone...{}",m_qulityString.toStdString());
  226. if(param::ptlist.size()>0)
  227. {
  228. if(image_qulity_num<m_foucus_step_max){
  229. image_qulity.append(m_qulityString.toDouble());
  230. image_qulity_num++;
  231. emit serial_data(m_json.MotorMove("movy","f4","1"));
  232. if(image_qulity_num==m_foucus_step_max){
  233. max_image_qulity = *std::max_element(image_qulity.begin(), image_qulity.end());
  234. }
  235. }
  236. LOG("max_image_qulity:{}@{}",image_qulity_num,max_image_qulity);
  237. if(image_qulity_num>=m_foucus_step_max){
  238. //如果当前清晰度大于最大清晰度
  239. if(m_qulityString.toDouble() > max_image_qulity)
  240. {
  241. image_qulity.clear();
  242. image_qulity_num = 0;
  243. param::camera_tc = 1;
  244. return;
  245. }
  246. if(max_image_qulity<200.0&&max_image_qulity-m_qulityString.toDouble()>0.0&&max_image_qulity-m_qulityString.toDouble()<5.0)
  247. {
  248. image_qulity.clear();
  249. image_qulity_num = 0;
  250. param::camera_tc = 1;
  251. return;
  252. }
  253. if(max_image_qulity>200.0&&max_image_qulity-m_qulityString.toDouble()>0.0&&max_image_qulity-m_qulityString.toDouble()<20.0)
  254. {
  255. image_qulity.clear();
  256. image_qulity_num = 0;
  257. param::camera_tc = 1;
  258. return;
  259. }
  260. if(max_image_qulity>600.0&&max_image_qulity-m_qulityString.toDouble()>0.0&&max_image_qulity-m_qulityString.toDouble()<50.0)
  261. {
  262. image_qulity.clear();
  263. image_qulity_num = 0;
  264. param::camera_tc = 1;
  265. return;
  266. }
  267. if(image_qulity_num==m_foucus_step_max*2+5)
  268. {
  269. image_qulity_num = 0;
  270. image_qulity.clear();
  271. emit serial_data(m_json.MotorMove("movy","b4","1"));
  272. return;
  273. }
  274. image_qulity_num++;
  275. //如果当前清晰度小于最大清晰度,反向运动寻找清晰位置 f4
  276. if(image_qulity_num>m_foucus_step_max&&max_image_qulity-m_qulityString.toDouble()>3.0){
  277. emit serial_data(m_json.MotorMove("movy","b4","1"));
  278. }
  279. }
  280. }
  281. //m_qulityString = m_opencvfunc.Laplacian(m_frame);
  282. else{
  283. #if 1
  284. if(image_qulity_num < MAX_STEP){
  285. image_qulity_num ++;
  286. emit serial_data(m_json.MotorMove("movy","b4","1"));
  287. qDebug() << image_qulity_num << " m_qulityString:" << m_qulityString << " size:" <<image_qulity.size();
  288. image_qulity.append(m_qulityString.toDouble());
  289. if(image_qulity_num==MAX_STEP){
  290. max_image_qulity = *std::max_element(image_qulity.begin(), image_qulity.end());
  291. image_qulity.clear(); //清除缓存
  292. }
  293. }
  294. //如果最大清晰度约等于当前清晰度或小于当前清晰度,继续往前
  295. if(image_qulity_num==MAX_STEP&&max_image_qulity-m_qulityString.toDouble()<=2.0){
  296. LOG("清晰度无明显变化,继续遍历!");
  297. image_qulity_num=0;
  298. image_qulity.clear();
  299. emit serial_data(m_json.MotorMove("movy","b4","1"));
  300. return;
  301. }
  302. // 计算索引位置
  303. //size_t max_index = std::distance(image_qulity.begin(), max_image_qulity);
  304. LOG("max_image_qulity:{} <> m_qulityString:{}",max_image_qulity,m_qulityString.toStdString());
  305. if(image_qulity_num >= MAX_STEP){
  306. image_qulity.append(m_qulityString.toDouble());
  307. //如果当前清晰度大于最大清晰度
  308. if(m_qulityString.toDouble() > max_image_qulity)
  309. {
  310. image_qulity.clear();
  311. image_qulity_num = 0;
  312. param::camera_tc = 1;
  313. return;
  314. }
  315. if(image_qulity_num>MAX_STEP&&max_image_qulity-m_qulityString.toDouble()<=3.0){
  316. image_qulity.clear();
  317. image_qulity_num = 0;
  318. param::camera_tc = 1;
  319. return;
  320. }
  321. image_qulity_num++;
  322. if(max_image_qulity<200.0&&max_image_qulity-m_qulityString.toDouble()>0.0&&max_image_qulity-m_qulityString.toDouble()<5.0)
  323. {
  324. image_qulity.clear();
  325. image_qulity_num = 0;
  326. param::camera_tc = 1;
  327. return;
  328. }
  329. if(max_image_qulity>200.0&&max_image_qulity-m_qulityString.toDouble()>0.0&&max_image_qulity-m_qulityString.toDouble()<20.0)
  330. {
  331. image_qulity.clear();
  332. image_qulity_num = 0;
  333. param::camera_tc = 1;
  334. return;
  335. }
  336. if(max_image_qulity>600.0&&max_image_qulity-m_qulityString.toDouble()>0.0&&max_image_qulity-m_qulityString.toDouble()<50.0)
  337. {
  338. image_qulity.clear();
  339. image_qulity_num = 0;
  340. param::camera_tc = 1;
  341. return;
  342. }
  343. #if 0
  344. //如果最新清晰度小于上一个清晰度,表示已超过最大清晰度位置
  345. if(image_qulity.last()-image_qulity[image_qulity.size()-2] < -2.0)
  346. {
  347. //
  348. emit serial_data(m_json.MotorMove("movy","b4","1"));
  349. QTimer::singleShot(500,[this](){
  350. LOG("500ms!");
  351. image_qulity.clear();
  352. image_qulity_num = 0;
  353. param::camera_tc = 1;
  354. return;
  355. });
  356. }
  357. #endif
  358. if(image_qulity_num==MAX_STEP*2+10)
  359. {
  360. image_qulity_num = 0;
  361. image_qulity.clear();
  362. emit serial_data(m_json.MotorMove("movy","f4","1"));
  363. return;
  364. }
  365. //如果当前清晰度小于最大清晰度,反向运动寻找清晰位置 f4
  366. if(image_qulity_num>MAX_STEP&&max_image_qulity-m_qulityString.toDouble()>3.0){
  367. emit serial_data(m_json.MotorMove("movy","f4","1"));
  368. }
  369. }
  370. #endif
  371. }
  372. #endif
  373. }
  374. void parseFrame(const cv::Mat& frame);
  375. void upload_handle(void);
  376. void handle_reult_upload(bool success, const QString &error);
  377. #if 0
  378. void sendImage(QImage frame);
  379. #endif
  380. void onFPSUpdated(double fps);
  381. private slots:
  382. //! Init camera.
  383. void initCam();
  384. //! Video frame changed.
  385. void newFrame( const QVideoFrame & frame );
  386. //void parseFrame();
  387. void handleGrab(bool sta_cam);
  388. //! 1s timer.
  389. void timer();
  390. //!
  391. void update_qulstr(QString q_str);
  392. //
  393. void readyForCapture(bool ready);
  394. void processCapturedImage(int requestId, const QImage &img);
  395. void imageSaved(int id, const QString &fileName);
  396. void displayCaptureError(int id, const QImageCapture::Error error, const QString &errorString);
  397. void displayCameraError();
  398. void processUvchandle(const QString &qst);
  399. //void sendData(QByteArray m_byte);
  400. void displayFrame(const QVideoFrame &frame);
  401. private:
  402. Q_DISABLE_COPY( Frames )
  403. //! Camera.
  404. QCamera * m_cam;
  405. //声明相机捕获对象
  406. //! Capture.
  407. QMediaCaptureSession m_capture;
  408. QImageCapture *m_imageCapture;
  409. //! Video sink of video output.
  410. //QPointer< QVideoSink > m_videoSink;
  411. QVideoSink *m_videoSink;
  412. //! Format string.
  413. QString m_formatString;
  414. //! FPS string.
  415. QString m_fpsString;
  416. //! FPS.
  417. int m_fps;
  418. //! 清晰度
  419. QString m_qulityString;
  420. //! Timer.
  421. QTimer *m_1s;
  422. //! QVideoFrame
  423. OpencvFunc m_opencvfunc;
  424. JsonFunc m_json;
  425. QFuture<void> m_processThread;
  426. QFuture<void> m_grabThread;
  427. QFutureWatcher<QImage*> watcher_uvc;
  428. QJniObject *jClass;
  429. bool camera_sta;
  430. bool m_decoding;
  431. bool m_streaming_active = false;
  432. QSharedMemory sharedMemory;
  433. QImage m_image;
  434. int stitch_des;
  435. ImageProvider *m_pImgProvider;
  436. //libuvc
  437. mutable QMutex frameMutex; // 互斥锁,用于对帧队列的访问进行同步
  438. FPSTimer* m_fps_timer = nullptr;
  439. cv::Mat m_frame;
  440. int MAX_STEP = 30;
  441. QVector<double> image_qulity;
  442. double max_image_qulity = 0.0; //最大清晰度值
  443. double max_image_sharp= 0.0;
  444. int image_qulity_num;
  445. int z_step = 0;
  446. int x_step = 0;
  447. //图片归档路径
  448. QString picture_path_floader;
  449. UVCCaptureProperties m_properties;
  450. QVector<cv::Mat> m_frame_buffer;
  451. void uvc_error_handler(uvc_error_t res) {
  452. if (res < 0) {
  453. const char* error_message = uvc_strerror(res);
  454. qCritical("libuvc error: %s", error_message);
  455. }
  456. }
  457. int testJNI();
  458. int checkPermission(void)
  459. {
  460. int ret = 0;
  461. const static char* MY_JAVA_CLASS = "GetUsbPermission";
  462. ret = QJniObject::callStaticMethod<jint>(MY_JAVA_CLASS,"checkPermission","()I");
  463. return ret;
  464. }
  465. int requestPermission(int vid, int pid);
  466. static inline QImage cvMatToQImage( const cv::Mat &inMat )
  467. {
  468. switch ( inMat.type() )
  469. {
  470. // 8-bit, 4 channel
  471. case CV_8UC4:
  472. {
  473. QImage image( inMat.data, inMat.cols, inMat.rows, inMat.step, QImage::Format_RGB32 );
  474. return image;
  475. }
  476. // 8-bit, 3 channel
  477. case CV_8UC3:
  478. {
  479. QImage image( inMat.data, inMat.cols, inMat.rows, inMat.step, QImage::Format_RGB888 );
  480. return image.rgbSwapped();
  481. }
  482. // 8-bit, 1 channel
  483. case CV_8UC1:
  484. {
  485. static QVector<QRgb> sColorTable;
  486. // only create our color table once
  487. if ( sColorTable.isEmpty() )
  488. {
  489. for ( int i = 0; i < 256; ++i )
  490. sColorTable.push_back( qRgb( i, i, i ) );
  491. }
  492. QImage image( inMat.data, inMat.cols, inMat.rows, inMat.step, QImage::Format_Indexed8 );
  493. image.setColorTable( sColorTable );
  494. return image;
  495. }
  496. default:
  497. qWarning() << "ASM::cvMatToQImage() - cv::Mat image type not handled in switch:" << inMat.type();
  498. break;
  499. }
  500. return QImage();
  501. }
  502. static cv::Mat QImageToCvMat(QImage inImage, bool inCloneImageData = true)
  503. {
  504. switch (inImage.format())
  505. {
  506. // 8-bit, 4 channel
  507. case QImage::Format_ARGB32:
  508. case QImage::Format_ARGB32_Premultiplied:
  509. {
  510. cv::Mat mat(inImage.height(), inImage.width(),
  511. CV_8UC4,
  512. const_cast<uchar*>(inImage.bits()),
  513. static_cast<size_t>(inImage.bytesPerLine())
  514. );
  515. return inCloneImageData ? mat.clone() : mat;
  516. }
  517. // 8-bit, 3 channel
  518. case QImage::Format_RGB32:
  519. {
  520. if (!inCloneImageData) {
  521. qWarning() << "QImageToCvMat() - Conversion requires cloning so we don't modify the original QImage data";
  522. }
  523. cv::Mat mat(inImage.height(), inImage.width(),
  524. CV_8UC4,
  525. const_cast<uchar*>(inImage.bits()),
  526. static_cast<size_t>(inImage.bytesPerLine())
  527. );
  528. cv::Mat matNoAlpha;
  529. cv::cvtColor(mat, matNoAlpha, cv::COLOR_BGRA2BGR); // drop the all-white alpha channel
  530. return matNoAlpha;
  531. }
  532. // 8-bit, 3 channel
  533. case QImage::Format_RGB888:
  534. {
  535. if (!inCloneImageData) {
  536. qWarning() << "QImageToCvMat() - Conversion requires cloning so we don't modify the original QImage data";
  537. }
  538. QImage swapped = inImage.rgbSwapped();
  539. cv::Mat mat(swapped.height(), swapped.width(),
  540. CV_8UC3,
  541. const_cast<uchar*>(swapped.bits()),
  542. static_cast<size_t>(swapped.bytesPerLine())
  543. );
  544. return inCloneImageData ? mat.clone() : mat;
  545. }
  546. // 8-bit, 1 channel
  547. case QImage::Format_Grayscale8:
  548. case QImage::Format_Indexed8:
  549. {
  550. cv::Mat mat(inImage.height(), inImage.width(),
  551. CV_8UC1,
  552. const_cast<uchar*>(inImage.bits()),
  553. static_cast<size_t>(inImage.bytesPerLine())
  554. );
  555. return inCloneImageData ? mat.clone() : mat;
  556. }
  557. #if QT_VERSION >= QT_VERSION_CHECK(5, 13, 0)
  558. case QImage::Format_Grayscale16:
  559. {
  560. cv::Mat mat(cv::Size(inImage.width(),inImage.height()),CV_16U,const_cast<uchar*>(inImage.bits()),cv::Mat::AUTO_STEP);
  561. return inCloneImageData ? mat.clone() : mat;
  562. }
  563. #endif
  564. default:
  565. qWarning() << "QImageToCvMat() - QImage format not handled in switch:" << inImage.format();
  566. break;
  567. }
  568. return cv::Mat();
  569. }
  570. }; // class Frames
  571. } /* namespace Qt6QCamera */
  572. Q_DECLARE_METATYPE(cv::Mat)
  573. Q_DECLARE_METATYPE(Qt6QCamera::Frames::UVCCaptureProperties)
  574. Q_DECLARE_METATYPE(Qt6QCamera::Frames::UVCCaptureDescriptor)
  575. #endif // M_FRAMES_HPP