cameramanager.h~RF16c3a91a.TMP 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684
  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. float newSharpness = evaluateSharpness(m_frame);
  219. LOG("onMovDone:{}",newSharpness);
  220. emit serial_data(m_json.ImageFunc(newSharpness));
  221. #if 0
  222. m_qulityString = m_opencvfunc.Tenengrad(m_frame);
  223. emit qulityStringChanged();
  224. LOG("onMovDone...{}",m_qulityString.toStdString());
  225. if(param::ptlist.size()>0)
  226. {
  227. if(image_qulity_num<m_foucus_step_max){
  228. image_qulity.append(m_qulityString.toDouble());
  229. image_qulity_num++;
  230. emit serial_data(m_json.MotorMove("movy","f4","1"));
  231. if(image_qulity_num==m_foucus_step_max){
  232. max_image_qulity = *std::max_element(image_qulity.begin(), image_qulity.end());
  233. }
  234. }
  235. LOG("max_image_qulity:{}@{}",image_qulity_num,max_image_qulity);
  236. if(image_qulity_num>=m_foucus_step_max){
  237. //如果当前清晰度大于最大清晰度
  238. if(m_qulityString.toDouble() > max_image_qulity)
  239. {
  240. image_qulity.clear();
  241. image_qulity_num = 0;
  242. param::camera_tc = 1;
  243. return;
  244. }
  245. if(max_image_qulity<200.0&&max_image_qulity-m_qulityString.toDouble()>0.0&&max_image_qulity-m_qulityString.toDouble()<5.0)
  246. {
  247. image_qulity.clear();
  248. image_qulity_num = 0;
  249. param::camera_tc = 1;
  250. return;
  251. }
  252. if(max_image_qulity>200.0&&max_image_qulity-m_qulityString.toDouble()>0.0&&max_image_qulity-m_qulityString.toDouble()<20.0)
  253. {
  254. image_qulity.clear();
  255. image_qulity_num = 0;
  256. param::camera_tc = 1;
  257. return;
  258. }
  259. if(max_image_qulity>600.0&&max_image_qulity-m_qulityString.toDouble()>0.0&&max_image_qulity-m_qulityString.toDouble()<50.0)
  260. {
  261. image_qulity.clear();
  262. image_qulity_num = 0;
  263. param::camera_tc = 1;
  264. return;
  265. }
  266. if(image_qulity_num==m_foucus_step_max*2+5)
  267. {
  268. image_qulity_num = 0;
  269. image_qulity.clear();
  270. emit serial_data(m_json.MotorMove("movy","b4","1"));
  271. return;
  272. }
  273. image_qulity_num++;
  274. //如果当前清晰度小于最大清晰度,反向运动寻找清晰位置 f4
  275. if(image_qulity_num>m_foucus_step_max&&max_image_qulity-m_qulityString.toDouble()>3.0){
  276. emit serial_data(m_json.MotorMove("movy","b4","1"));
  277. }
  278. }
  279. }
  280. //m_qulityString = m_opencvfunc.Laplacian(m_frame);
  281. else{
  282. #if 1
  283. if(image_qulity_num < MAX_STEP){
  284. image_qulity_num ++;
  285. emit serial_data(m_json.MotorMove("movy","b4","1"));
  286. qDebug() << image_qulity_num << " m_qulityString:" << m_qulityString << " size:" <<image_qulity.size();
  287. image_qulity.append(m_qulityString.toDouble());
  288. if(image_qulity_num==MAX_STEP){
  289. max_image_qulity = *std::max_element(image_qulity.begin(), image_qulity.end());
  290. image_qulity.clear(); //清除缓存
  291. }
  292. }
  293. //如果最大清晰度约等于当前清晰度或小于当前清晰度,继续往前
  294. if(image_qulity_num==MAX_STEP&&max_image_qulity-m_qulityString.toDouble()<=2.0){
  295. LOG("清晰度无明显变化,继续遍历!");
  296. image_qulity_num=0;
  297. image_qulity.clear();
  298. emit serial_data(m_json.MotorMove("movy","b4","1"));
  299. return;
  300. }
  301. // 计算索引位置
  302. //size_t max_index = std::distance(image_qulity.begin(), max_image_qulity);
  303. LOG("max_image_qulity:{} <> m_qulityString:{}",max_image_qulity,m_qulityString.toStdString());
  304. if(image_qulity_num >= MAX_STEP){
  305. image_qulity.append(m_qulityString.toDouble());
  306. //如果当前清晰度大于最大清晰度
  307. if(m_qulityString.toDouble() > max_image_qulity)
  308. {
  309. image_qulity.clear();
  310. image_qulity_num = 0;
  311. param::camera_tc = 1;
  312. return;
  313. }
  314. if(image_qulity_num>MAX_STEP&&max_image_qulity-m_qulityString.toDouble()<=3.0){
  315. image_qulity.clear();
  316. image_qulity_num = 0;
  317. param::camera_tc = 1;
  318. return;
  319. }
  320. image_qulity_num++;
  321. if(max_image_qulity<200.0&&max_image_qulity-m_qulityString.toDouble()>0.0&&max_image_qulity-m_qulityString.toDouble()<5.0)
  322. {
  323. image_qulity.clear();
  324. image_qulity_num = 0;
  325. param::camera_tc = 1;
  326. return;
  327. }
  328. if(max_image_qulity>200.0&&max_image_qulity-m_qulityString.toDouble()>0.0&&max_image_qulity-m_qulityString.toDouble()<20.0)
  329. {
  330. image_qulity.clear();
  331. image_qulity_num = 0;
  332. param::camera_tc = 1;
  333. return;
  334. }
  335. if(max_image_qulity>600.0&&max_image_qulity-m_qulityString.toDouble()>0.0&&max_image_qulity-m_qulityString.toDouble()<50.0)
  336. {
  337. image_qulity.clear();
  338. image_qulity_num = 0;
  339. param::camera_tc = 1;
  340. return;
  341. }
  342. #if 0
  343. //如果最新清晰度小于上一个清晰度,表示已超过最大清晰度位置
  344. if(image_qulity.last()-image_qulity[image_qulity.size()-2] < -2.0)
  345. {
  346. //
  347. emit serial_data(m_json.MotorMove("movy","b4","1"));
  348. QTimer::singleShot(500,[this](){
  349. LOG("500ms!");
  350. image_qulity.clear();
  351. image_qulity_num = 0;
  352. param::camera_tc = 1;
  353. return;
  354. });
  355. }
  356. #endif
  357. if(image_qulity_num==MAX_STEP*2+10)
  358. {
  359. image_qulity_num = 0;
  360. image_qulity.clear();
  361. emit serial_data(m_json.MotorMove("movy","f4","1"));
  362. return;
  363. }
  364. //如果当前清晰度小于最大清晰度,反向运动寻找清晰位置 f4
  365. if(image_qulity_num>MAX_STEP&&max_image_qulity-m_qulityString.toDouble()>3.0){
  366. emit serial_data(m_json.MotorMove("movy","f4","1"));
  367. }
  368. }
  369. #endif
  370. }
  371. #endif
  372. }
  373. void parseFrame(const cv::Mat& frame);
  374. void upload_handle(void);
  375. void handle_reult_upload(bool success, const QString &error);
  376. #if 0
  377. void sendImage(QImage frame);
  378. #endif
  379. void onFPSUpdated(double fps);
  380. private slots:
  381. //! Init camera.
  382. void initCam();
  383. //! Video frame changed.
  384. void newFrame( const QVideoFrame & frame );
  385. //void parseFrame();
  386. void handleGrab(bool sta_cam);
  387. //! 1s timer.
  388. void timer();
  389. //!
  390. void update_qulstr(QString q_str);
  391. //
  392. void readyForCapture(bool ready);
  393. void processCapturedImage(int requestId, const QImage &img);
  394. void imageSaved(int id, const QString &fileName);
  395. void displayCaptureError(int id, const QImageCapture::Error error, const QString &errorString);
  396. void displayCameraError();
  397. void processUvchandle(const QString &qst);
  398. //void sendData(QByteArray m_byte);
  399. void displayFrame(const QVideoFrame &frame);
  400. private:
  401. Q_DISABLE_COPY( Frames )
  402. //! Camera.
  403. QCamera * m_cam;
  404. //声明相机捕获对象
  405. //! Capture.
  406. QMediaCaptureSession m_capture;
  407. QImageCapture *m_imageCapture;
  408. //! Video sink of video output.
  409. //QPointer< QVideoSink > m_videoSink;
  410. QVideoSink *m_videoSink;
  411. //! Format string.
  412. QString m_formatString;
  413. //! FPS string.
  414. QString m_fpsString;
  415. //! FPS.
  416. int m_fps;
  417. //! 清晰度
  418. QString m_qulityString;
  419. //! Timer.
  420. QTimer *m_1s;
  421. //! QVideoFrame
  422. OpencvFunc m_opencvfunc;
  423. JsonFunc m_json;
  424. QFuture<void> m_processThread;
  425. QFuture<void> m_grabThread;
  426. QFutureWatcher<QImage*> watcher_uvc;
  427. QJniObject *jClass;
  428. bool camera_sta;
  429. bool m_decoding;
  430. bool m_streaming_active = false;
  431. QSharedMemory sharedMemory;
  432. QImage m_image;
  433. int stitch_des;
  434. ImageProvider *m_pImgProvider;
  435. //libuvc
  436. mutable QMutex frameMutex; // 互斥锁,用于对帧队列的访问进行同步
  437. FPSTimer* m_fps_timer = nullptr;
  438. cv::Mat m_frame;
  439. int MAX_STEP = 30;
  440. QVector<double> image_qulity;
  441. double max_image_qulity = 0.0; //最大清晰度值
  442. double max_image_sharp= 0.0;
  443. int image_qulity_num;
  444. int z_step = 0;
  445. int x_step = 0;
  446. //图片归档路径
  447. QString picture_path_floader;
  448. UVCCaptureProperties m_properties;
  449. QVector<cv::Mat> m_frame_buffer;
  450. void uvc_error_handler(uvc_error_t res) {
  451. if (res < 0) {
  452. const char* error_message = uvc_strerror(res);
  453. qCritical("libuvc error: %s", error_message);
  454. }
  455. }
  456. int testJNI();
  457. int checkPermission(void)
  458. {
  459. int ret = 0;
  460. const static char* MY_JAVA_CLASS = "GetUsbPermission";
  461. ret = QJniObject::callStaticMethod<jint>(MY_JAVA_CLASS,"checkPermission","()I");
  462. return ret;
  463. }
  464. int requestPermission(int vid, int pid);
  465. // 清晰度评估(Tenengrad函数)
  466. float evaluateSharpness(cv::Mat& frame) {
  467. cv::Mat gray, sobelX, sobelY;
  468. cv::cvtColor(frame, gray, cv::COLOR_BGR2GRAY);
  469. cv::Sobel(gray, sobelX, CV_16S, 1, 0);
  470. cv::Sobel(gray, sobelY, CV_16S, 0, 1);
  471. cv::Mat magnitude;
  472. cv::magnitude(sobelX, sobelY, magnitude);
  473. return cv::mean(magnitude)[0];
  474. }
  475. static inline QImage cvMatToQImage( const cv::Mat &inMat )
  476. {
  477. switch ( inMat.type() )
  478. {
  479. // 8-bit, 4 channel
  480. case CV_8UC4:
  481. {
  482. QImage image( inMat.data, inMat.cols, inMat.rows, inMat.step, QImage::Format_RGB32 );
  483. return image;
  484. }
  485. // 8-bit, 3 channel
  486. case CV_8UC3:
  487. {
  488. QImage image( inMat.data, inMat.cols, inMat.rows, inMat.step, QImage::Format_RGB888 );
  489. return image.rgbSwapped();
  490. }
  491. // 8-bit, 1 channel
  492. case CV_8UC1:
  493. {
  494. static QVector<QRgb> sColorTable;
  495. // only create our color table once
  496. if ( sColorTable.isEmpty() )
  497. {
  498. for ( int i = 0; i < 256; ++i )
  499. sColorTable.push_back( qRgb( i, i, i ) );
  500. }
  501. QImage image( inMat.data, inMat.cols, inMat.rows, inMat.step, QImage::Format_Indexed8 );
  502. image.setColorTable( sColorTable );
  503. return image;
  504. }
  505. default:
  506. qWarning() << "ASM::cvMatToQImage() - cv::Mat image type not handled in switch:" << inMat.type();
  507. break;
  508. }
  509. return QImage();
  510. }
  511. static cv::Mat QImageToCvMat(QImage inImage, bool inCloneImageData = true)
  512. {
  513. switch (inImage.format())
  514. {
  515. // 8-bit, 4 channel
  516. case QImage::Format_ARGB32:
  517. case QImage::Format_ARGB32_Premultiplied:
  518. {
  519. cv::Mat mat(inImage.height(), inImage.width(),
  520. CV_8UC4,
  521. const_cast<uchar*>(inImage.bits()),
  522. static_cast<size_t>(inImage.bytesPerLine())
  523. );
  524. return inCloneImageData ? mat.clone() : mat;
  525. }
  526. // 8-bit, 3 channel
  527. case QImage::Format_RGB32:
  528. {
  529. if (!inCloneImageData) {
  530. qWarning() << "QImageToCvMat() - Conversion requires cloning so we don't modify the original QImage data";
  531. }
  532. cv::Mat mat(inImage.height(), inImage.width(),
  533. CV_8UC4,
  534. const_cast<uchar*>(inImage.bits()),
  535. static_cast<size_t>(inImage.bytesPerLine())
  536. );
  537. cv::Mat matNoAlpha;
  538. cv::cvtColor(mat, matNoAlpha, cv::COLOR_BGRA2BGR); // drop the all-white alpha channel
  539. return matNoAlpha;
  540. }
  541. // 8-bit, 3 channel
  542. case QImage::Format_RGB888:
  543. {
  544. if (!inCloneImageData) {
  545. qWarning() << "QImageToCvMat() - Conversion requires cloning so we don't modify the original QImage data";
  546. }
  547. QImage swapped = inImage.rgbSwapped();
  548. cv::Mat mat(swapped.height(), swapped.width(),
  549. CV_8UC3,
  550. const_cast<uchar*>(swapped.bits()),
  551. static_cast<size_t>(swapped.bytesPerLine())
  552. );
  553. return inCloneImageData ? mat.clone() : mat;
  554. }
  555. // 8-bit, 1 channel
  556. case QImage::Format_Grayscale8:
  557. case QImage::Format_Indexed8:
  558. {
  559. cv::Mat mat(inImage.height(), inImage.width(),
  560. CV_8UC1,
  561. const_cast<uchar*>(inImage.bits()),
  562. static_cast<size_t>(inImage.bytesPerLine())
  563. );
  564. return inCloneImageData ? mat.clone() : mat;
  565. }
  566. #if QT_VERSION >= QT_VERSION_CHECK(5, 13, 0)
  567. case QImage::Format_Grayscale16:
  568. {
  569. cv::Mat mat(cv::Size(inImage.width(),inImage.height()),CV_16U,const_cast<uchar*>(inImage.bits()),cv::Mat::AUTO_STEP);
  570. return inCloneImageData ? mat.clone() : mat;
  571. }
  572. #endif
  573. default:
  574. qWarning() << "QImageToCvMat() - QImage format not handled in switch:" << inImage.format();
  575. break;
  576. }
  577. return cv::Mat();
  578. }
  579. }; // class Frames
  580. } /* namespace Qt6QCamera */
  581. Q_DECLARE_METATYPE(cv::Mat)
  582. Q_DECLARE_METATYPE(Qt6QCamera::Frames::UVCCaptureProperties)
  583. Q_DECLARE_METATYPE(Qt6QCamera::Frames::UVCCaptureDescriptor)
  584. #endif // M_FRAMES_HPP