#ifndef M_FRAMES_HPP #define M_FRAMES_HPP // Qt include. #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include //海康 // #pragma pack(push, 4) // #include "MvCameraControl.h" // #pragma pack(pop) #include #include #include #include #include #include #include //https://github.com/saki4510t/UVCCamera/pulls //https://gitee.com/dengly/UVCCamera //USBCamera: https://blog.csdn.net/hanshiying007/article/details/124118486 #define CameraType 2 //0-QCamera , 1-OPENCV, 2-libuvc #define movZ_f "f80" //多图移动,正向80 #define movZ_b "b80" //多图移动,反向80 #define movX_f "f80" //多图移动,正向 #define movX_b "b80" //多图移动,反向 #define focux_f "f4" //单步对焦,正向 #define focus_b "b4" //单步对焦,反向 #define m_foucus_step_max 5 #define focus_step_max 30 //自动流程录制(对焦完成后自动录像)的最长录制时长,单位ms: //超过该时长仍未收到控制板的 record_stop 指令,则自动结束录制(走与 record_stop 相同的分析/融合流程) //可通过编译选项 -DRECORD_TIMEOUT_MS=xxx 覆盖 #ifndef RECORD_TIMEOUT_MS #define RECORD_TIMEOUT_MS 10000 //10S #endif //【步进对焦】单步"记录一帧到 rawv"的最长等待时间(ms): // 主板每移动一步就等这一帧落盘后才继续,超时仍要回 focus,否则两侧一起卡死。 // 5MP 原始帧约 5MB,正常 eMMC 写入 <100ms,留足余量给磁盘抖动。 #define AF_STEP_RECORD_TIMEOUT_MS 3000 //性能提升 //https://blog.csdn.net/u012915226/article/details/115733359 //https://blog.csdn.net/u012915226/article/details/121745861?spm=1001.2014.3001.5501 //https://blog.csdn.net/aggs1990/article/details/125694175 //自定义QVideoSink //https://blog.csdn.net/aggs1990/article/details/125361203?spm=1001.2014.3001.5501 //github: 模块 //https://github.com/erikmwerner/QUVCView/blob/master/uvccapture.cpp namespace Qt6QCamera { // ==================== 录制视频流异步写盘 ==================== //取流线程只做"深拷贝入队",写盘由后台线程完成: // - 写盘不再阻塞取流,磁盘抖动/瞬时带宽不足不会直接压低录制帧率 // - 队列按内存预算限流(默认192MB),超出时丢弃新帧并计数(保实时性) // - 配合"存相机原始帧(Bayer8 5MB/帧,而非BGRA 20MB/帧)"可把写盘吞吐需求降到1/4 class RawRecordWriter : public QThread { public: explicit RawRecordWriter(QObject *parent = nullptr); ~RawRecordWriter() override; //打开文件并写入占位文件头(由UI线程调用) bool begin(const QString &path); //入队一帧(内部深拷贝,调用方可立即复用传入矩阵) void enqueue(const cv::Mat &frame, int pixelFormat); //入队一帧并等待该帧真正落盘(对焦步进握手专用): // 主板每移动一步发 movy,工控机必须先把该位置的帧写进 rawv 再回 focus, // 否则帧率/清晰度采样与磁盘写入会错位(现场表现为对焦结果漂移)。 // timeoutMs 为本帧最长等待时间,超时返回 false(调用方仍应继续握手,避免整体卡死)。 bool enqueueAndWait(const cv::Mat &frame, int pixelFormat, int timeoutMs); //排空队列+回填文件头+关闭文件,返回写入帧数;出参返回帧尺寸、行字节数与像素格式 //帧率由内部计时(begin→finish)自行换算,调用方无需关心 int finish(int &width, int &height, int &stride, int &pixelFormat); //队列内存预算(字节),超出后丢弃新帧 void setBudgetBytes(qint64 bytes); qint64 droppedFrames() const { return m_dropped.loadRelaxed(); } bool isActive() const { return m_active; } protected: void run() override; private: QMutex m_mutex; QWaitCondition m_cond; std::deque> m_queue; qint64 m_queuedBytes = 0; qint64 m_budget = 192LL * 1024 * 1024; //默认192MB bool m_stop = false; bool m_flushing = false; bool m_active = false; QFile m_file; QString m_path; int m_width = 0; int m_height = 0; int m_stride = 0; int m_pixelFormat = 0; int m_count = 0; //落盘确认计数:每入队一帧 m_enqueued+1,写线程每处理完一帧 m_written+1, //enqueueAndWait() 以 "m_written >= 本帧序号" 判定该帧已落盘 int m_enqueued = 0; int m_written = 0; QAtomicInt m_dropped = 0; QElapsedTimer m_elapsed; }; // 定义一个包含信号的发送类 class SenderCustom : public QObject { Q_OBJECT public: // 定义一个信号,无参数 signals: void signalToSend(const cv::Mat& frame); void signalQStr(const QString &qst); public: void sendSignal(const cv::Mat& frame) { emit signalToSend(frame); // 发送信号 } void sendQStr(const QString &qst){ signalQStr(qst); } }; class FPSTimer : public QObject { Q_OBJECT public: explicit FPSTimer(QObject *parent = nullptr); public slots: void incrementFrame() { m_frame_count++; } void setInterval(int interval); void setRunning(bool running); bool isRunning(); signals: void fpsUpdated(double); private slots: void onTimerTimeout(); private: QTimer* m_timer = nullptr; QElapsedTimer* m_elapsed_timer = nullptr; int m_interval = 1000; int m_frame_count = 0; }; // // Frames // struct RawFrame { int width; int height; MvGvspPixelType pixelType; QByteArray data; // 原始 buffer 拷贝 }; //! Frames listener. class Frames :public QObject//, public QQuickImageProvider //QObject // { Q_OBJECT QML_ELEMENT Q_PROPERTY( QVideoSink* videoSink READ videoSink WRITE setVideoSink NOTIFY videoSinkChanged ) Q_PROPERTY( QString formatString READ formatString NOTIFY formatStringChanged ) Q_PROPERTY( QString fpsString READ fpsString NOTIFY fpsStringChanged ) Q_PROPERTY( QString qulityString READ qulityString NOTIFY qulityStringChanged ) Q_PROPERTY( bool auto_clicked READ auto_clicked WRITE setChange NOTIFY btnStatusChanged ) Q_PROPERTY( bool camera_sw READ camera_sw WRITE setCameraSw NOTIFY cameraStaChanged ) Q_PROPERTY(QString cam_ExposureTime READ cam_ExposureTime WRITE setExposureTime NOTIFY exposureTimeChanged) //海康相机常用参数:型号展示/亮度(自动曝光目标灰度)/白平衡(自动模式+红蓝比例) Q_PROPERTY(QString cam_ModelName READ cam_ModelName NOTIFY cameraInfoChanged) Q_PROPERTY(QString cam_Brightness READ cam_Brightness WRITE setBrightness NOTIFY brightnessChanged) Q_PROPERTY(int cam_WhiteBalanceMode READ cam_WhiteBalanceMode WRITE setWhiteBalanceMode NOTIFY whiteBalanceModeChanged) Q_PROPERTY(QString cam_BalanceRatioR READ cam_BalanceRatioR WRITE setBalanceRatioR NOTIFY balanceRatioChanged) Q_PROPERTY(QString cam_BalanceRatioB READ cam_BalanceRatioB WRITE setBalanceRatioB NOTIFY balanceRatioChanged) Q_PROPERTY( bool recording READ recording NOTIFY recordingChanged ) //已录制帧数(rawv 里实际写入的帧数): 步进扫描时每步应只 +1, 用于界面核对 //"移动 N 步是否只录了 N 帧", 也用于现场判断是否有多记/漏记 Q_PROPERTY( int recordedFrames READ recordedFrames NOTIFY recordedFramesChanged ) //录制视频流的分析/融合处理中(期间挂起相机画面输出并在界面显示进度) Q_PROPERTY( bool processing READ processing NOTIFY processingChanged ) Q_PROPERTY( QString processMessage READ processMessage NOTIFY processProgressChanged ) Q_PROPERTY( int processPercent READ processPercent NOTIFY processProgressChanged ) //【融合开关按钮】直接读写真 param::fusion_enable(与 MQTT fusion_sw 同一个运行时开关)。 // 关掉时 processRecordedVideo 只保留最清晰帧、不做景深融合。按钮改的是运行时值,不写 sqlite。 Q_PROPERTY( bool fusionEnabled READ fusionEnabled WRITE setFusionEnabled NOTIFY fusionEnabledChanged ) //【临时调试开关】打开后录制结束不删除 rawv 录制文件(便于复盘/回放), // 默认关闭, 只存在内存里(不写库、重启复位), 界面上的按钮仅本机临时用。 Q_PROPERTY( bool debugKeepRecord READ debugKeepRecord WRITE setDebugKeepRecord NOTIFY debugKeepRecordChanged ) public: static void registerQmlType(); explicit Frames(QObject * parent = nullptr); ~Frames() override; //! Set sink of video output. void setVideoSink( QVideoSink * newVideoSink ); bool isDecoding() { return m_decoding; } //! \return Sink of video output. QVideoSink* videoSink() const { return m_videoSink; } //! set btn void setChange(bool stat_t); //! 相机状态 void setCameraSw(bool stat_cam); void setExposureTime(const QString &exptime); QString cam_ModelName() const; QString cam_Brightness() const; void setBrightness(const QString &val); int cam_WhiteBalanceMode() const; void setWhiteBalanceMode(int mode); QString cam_BalanceRatioR() const; void setBalanceRatioR(const QString &val); QString cam_BalanceRatioB() const; void setBalanceRatioB(const QString &val); //! \return Rotation angle. //! \return Format of video frame as string. QString formatString() const; //! \return FPS as string. QString fpsString() const; QString qulityString() const; QString cam_ExposureTime() const; bool auto_clicked() const; bool camera_sw() const; void saveImage(); Q_INVOKABLE void captureImage(); //抓图按钮:模拟MCU拍照指令(camera_tc=1),下一帧按序号保存/锐化/上传 Q_INVOKABLE void manualCapture(); //录制原始(未压缩)视频流:开始录制;停止时回填文件头并把视频流保存到文件系统 Q_INVOKABLE bool startRecord(); Q_INVOKABLE void stopRecord(); bool recording() const { return m_recording; } int recordedFrames() const { return m_recordedFrames.load(); } //融合开关(读写 param::fusion_enable,运行时生效,不落库) bool fusionEnabled() const; void setFusionEnabled(bool on); //临时调试:保留录制文件 bool debugKeepRecord() const { return m_debugKeepRecord; } void setDebugKeepRecord(bool on); //处理中标志(取流线程读取,故用原子量) bool processing() const { return m_processing.loadRelaxed() != 0; } QString processMessage() const { return m_processMessage; } int processPercent() const { return m_processPercent; } //收到控制板 record_stop 指令:停止录制 -> 清晰度分析 -> 景深融合 -> 删除录制文件 -> 上传融合图片 Q_INVOKABLE void handleRecordStop(); //inline ImageProvider *getImageProvider() { return m_pImgProvider; } //ImageProvider* imageProvider() const; static void ImageCallBackEx(unsigned char * pData, MV_FRAME_OUT_INFO_EX* pFrameInfo, void* pUser); bool createFolder(const QString &path) { QDir dir(path); if (dir.exists()) { LOG("文件夹已存在:{}",path.toStdString()); return true; } if (dir.mkpath(".")) { LOG("文件夹创建成功:{}",path.toStdString()); return true; } else { ERROR("文件夹创建失败:{}",path.toStdString()); return false; } } signals: //! Video sink changed. void videoSinkChanged(); void cameraOpenFailed(const QString &err); void formatStringChanged(); void fpsStringChanged(); void qulityStringChanged(); void exposureTimeChanged(); //相机常用参数变化(型号/亮度/白平衡) void cameraInfoChanged(); void brightnessChanged(); void whiteBalanceModeChanged(); void balanceRatioChanged(); void frameAvailable(const QVideoFrame &frame); void frameReady(QImage image); void btnStatusChanged(); void sendFocusFlag(QString flag_sta); void cameraStaChanged(bool sta_cam); void serial_data(const QByteArray &m_byte); void signal_stitch(); //hikrobot void startGrabbing(bool sta_cam); void signalGrabing(unsigned char * nData); void callQmlRefeshImg(); void signal_m1s(); void dataUpload(const QByteArray &data); //到mqtt void signal_photoerr(); void stopGrabbing(bool sta_cam); void signal_photo_saved(); void signal_wait_upload(const QString &path); void signal_cache_image(const QString &path); void signal_sharp_processed(const QString &name_sharp); //锐化/对比度后台处理完成,回主线程统一入队入库 void stepCountChanged(const QString step); void recordingChanged(); void recordedFramesChanged(); void processingChanged(); //分析/融合进度变化(主线程发出) void processProgressChanged(); //融合开关 / 调试保留录制帧 状态变化(界面按钮文字刷新) void fusionEnabledChanged(); void debugKeepRecordChanged(); //录制结束,视频流已保存到path void recordFileSaved(const QString &path); public slots: void onMovDone(const QString stepcount){ if(!camera_sw()){ ERROR("Camera error!"); setCameraSw(false); return; } cv::Mat snapshot; { // 锁内只做浅拷贝(引用计数保护数据),快速释放锁,避免阻塞取流线程写入 m_frame QMutexLocker locker(&m_frameMutex); if (m_frame.empty()) { // 取流尚未写入首帧时触发(如移动完成先于取流),不更新清晰度 LOG("onMovDone: m_frame empty, skip"); emit stepCountChanged(stepcount); return; } snapshot = m_frame; } //【录制=按串口信号存帧,不是持续录制】 // 主板移动完成后发 movy,本机才把"当前位置最近一帧"写进 rawv, // 确认落盘后再回 focus —— 主板收到 focus 才继续下一步,这就是"记录完成后恢复"。 // 取流线程不写盘,只缓存最近一帧(见 processFrameAsync)。 // 超时(磁盘抖动/满了)也照常回 focus,避免两侧互相等待卡死。 // //【顺序】先录制当前帧, 落盘完成之后再算清晰度、再回复主板: // 清晰度取"刚刚落盘的那一帧"对应的显示帧(m_afStepDisplay, 同一次取流循环写入), // 不再用"此刻最新的预览帧" —— 否则回复的清晰度可能对应下一帧, // 与 rawv 里存的那一帧不是同一张图, 主板据此选最佳位置/判波动会失真。 if(m_recording){ //【每步只录一帧】主板 af_linear_step 每步发一次 movy, 但 focus 超时补发(hmi.c)、 // 扫描状态机被重新初始化、串口重包等情况会让同一位置的 movy 再次到达; // 照单全收就会出现"移动 100 步写出 200 帧"。这里按步号去重: 同一步号只落一帧。 // 注意: 仍然照常回 focus, 否则主板等不到握手会超时补发,越补越多。 const int stepNo = stepcount.toInt(); const bool validStep = (stepNo > 0); //旧协议/异常值不做去重,避免只录到第一帧 const qint64 nowMs = QDateTime::currentMSecsSinceEpoch(); // 同一步号即判重复; 但步号 1 只在"距上次 <15s"时才算: // 新一轮扫描时主板的 g_laf.step_cnt 从 0 重新计数(hmi.c af_linear_step), // 若单纯比步号, 上一轮恰好停在 1 步就会把新一轮的第一帧吞掉。 // focus 超时补发间隔是 5s(最多 3 次), 15s 足以覆盖真正的重发。 const bool dupStep = validStep && stepNo == m_afLastStepNo && (stepNo > 1 || (nowMs - m_afLastStepMs) < 15000); if(dupStep){ LOG("onMovDone: 步{} 重复上报,跳过记帧(已录{}帧)", stepcount.toStdString(),m_recordedFrames.load()); }else{ if(validStep) { m_afLastStepNo = stepNo; m_afLastStepMs = nowMs; } cv::Mat shot; //与本次落盘帧同一时刻的显示帧 if(recordStepFrame(AF_STEP_RECORD_TIMEOUT_MS, &shot)){ LOG("onMovDone: 步{} 该位置帧已落盘(已录{}帧)", stepcount.toStdString(),m_recordedFrames.load()); }else{ WARN("onMovDone: 步{} 帧记录超时,继续握手",stepcount.toStdString()); } //录制完成后用"已落盘那一帧"算清晰度(取不到才退回最新预览帧) if(!shot.empty()) snapshot = shot; } //扫描期间看门狗语义变成"本步最长等待时间":每步续期一次 if(m_recordTimeout) m_recordTimeout->start(RECORD_TIMEOUT_MS); } //【清晰度在录制完成之后才算】上面的 recordStepFrame 内部已经等真正落盘, // 这里的 snapshot 就是刚写进 rawv 的那一帧(未录制时是最近一帧预览) m_qulityString = m_opencvfunc.Tenengrad(snapshot); LOG("onMovDone:{}",m_qulityString.toStdString()); emit serial_data(m_json.ImageFunc(m_qulityString.toDouble())); emit qulityStringChanged(); emit stepCountChanged(stepcount); } // void parseFrame(const cv::Mat& frame); Q_INVOKABLE void upload_handle(void); Q_INVOKABLE void handle_reult_upload(bool success, const QString &filePath); //filePath: 传完的文件(由上传器 finished 带回) void onFPSUpdated(double fps); private slots: //! Init camera. void initCam(); void handleGrab(bool sta_cam); //! 1s timer. void timer(); //! void update_qulstr(QString q_str); // void saveMatAsJpeg(const QVideoFrame &frame); void onSharpProcessed(const QString &name_sharp); //void sendData(QByteArray m_byte); void displayFrame(const QVideoFrame &frame); void mov_x_z_run(); void processFrameAsync(const RawFrame& frame); //录制中:把当前未压缩原始帧写入视频流文件(处理线程调用) //录制入队:frame 为相机原始帧(Bayer8 CV_8UC1 / YUYV CV_8UC2)或已转换 BGRA, //pixelFormat 见 RawPixelFormat;内部深拷贝后由后台线程写盘,不阻塞取流 //【步进对焦】把"当前位置最近一帧原始帧"写进 rawv 并等待落盘(同步) //返回 true=已落盘, false=无缓存帧/写入超时 //displayOut: 输出"与本次落盘帧同一时刻的显示帧"(BGRA, 浅拷贝共享数据, 不额外拷贝内存), // 用于录制完成后计算清晰度 —— 保证回给主板的清晰度和写进 rawv 的是同一帧。 bool recordStepFrame(int timeoutMs, cv::Mat *displayOut = nullptr); //录制超时(超过 RECORD_TIMEOUT_MS 未收到 record_stop):自动结束录制并处理视频流 void onRecordTimeout(); //*提前恢复相机取流(预热):在保存结果图片阶段就 StartGrabbing, //避免等处理全部结束(含上传)才恢复导致下次采集启动卡顿*// void warmupCamera(); //置处理中标志(挂起相机画面输出) void setProcessing(bool on); //更新处理进度(仅主线程调用) void setProcessProgress(const QString &message, int percent); private: Q_DISABLE_COPY( Frames ) //声明相机捕获对象 //! Video sink of video output. //QPointer< QVideoSink > m_videoSink; QVideoSink *m_videoSink; //! Format string. QString m_formatString; //! FPS string. QString m_fpsString; //! FPS. int m_fps; //! 清晰度 QString m_qulityString; //! Timer. QTimer *m_1s; //! QVideoFrame OpencvFunc m_opencvfunc; JsonFunc m_json; QFuture m_grabThread; //独立上传队列:与param::ptlist(拼接输入)隔离,每保存一张锐化/对比度图立即入队逐张上传 QStringList m_uploadQueue; //正在上传的文件(图片队列用):上传完成回调据此判断是哪一张传完、是否推进队列 QString m_uploadingPath; bool m_isUploading = false; //是否正在上传,防止并发启动多个上传线程 QJniObject *jClass; bool camera_sta; bool m_decoding; bool m_streaming_active = false; QImage m_image; int m_width; int m_height; //相机当前输出帧的像素格式(MvGvspPixelType),取流线程写入,状态栏显示 quint32 m_pixelType = 0; QString m_fExposureTime; //海康相机常用参数(打开相机后回读,qml回显) QString m_camModelName; QString m_camBrightness; int m_camWhiteBalanceMode = 0; //qml索引:0-关闭 1-自动一次 2-连续自动 QString m_camBalanceRatioR; QString m_camBalanceRatioB; //打开相机后读取型号/亮度/白平衡参数 void readCameraParams(); //手动写白平衡比例,selector: 0-红 1-绿 2-蓝 void applyBalanceRatio(int selector, const QString &val); //ImageProvider *m_pImgProvider; //libuvc mutable QMutex m_frameMutex; // 互斥锁,用于对帧队列的访问进行同步 FPSTimer* m_fps_timer = nullptr; cv::Mat m_frame; QSemaphore m_frameGate; // 在途帧处理任务门禁(构造初值=3),防止任务积压导致内存暴涨 QAtomicInt m_displayPending = 0; // 显示节流:UI线程未消费完上一帧时丢弃当前帧,只保留最新帧 int image_num = 1; int z_step = 0; int x_step = 0; //保护 image_num/z_step/x_step 及"取号-建名-存图-自增-移轴"整段流程, //saveMatAsJpeg 由 QtConcurrent 线程池并发调用,无锁会导致重号覆盖、序号跳变、轴重复移动 mutable QMutex m_saveMutex; //图片归档路径 QString picture_path_floader; QVector m_frame_buffer; //原始视频流录制:取流线程只把"相机原始帧"入队(Bayer8/YUYV,体积远小于BGRA), //由 RawRecordWriter 后台线程写盘,停止时回填文件头 bool m_recording = false; RawRecordWriter m_recordWriter; QString m_recordPath; int m_recordWidth = 0; int m_recordHeight = 0; int m_recordStride = 0; int m_recordFrameCount = 0; QElapsedTimer m_recordElapsed; //本次停止录制后是否丢弃录制文件(record_stop 流程处理完即删除,不再提示"已保存") bool m_recordDiscard = false; //录制性能诊断(定位录制帧率瓶颈:相机产帧/Bayer转换/写盘 各占多少) qint64 m_diagFrames = 0; //已统计帧数 qint64 m_diagWriteUsec = 0; //写盘累计耗时(us) qint64 m_diagCvtUsec = 0; //Bayer转换累计耗时(us) qint64 m_diagGapMsec = 0; //相邻帧到达间隔累计(ms,帧数-1个间隔) qint64 m_diagLastFrameMsec = 0; //保护录制状态与文件写入,startRecord/stopRecord(UI线程)与writeRecordFrame(处理线程)互斥 mutable QMutex m_recordMutex; //录制超时看门狗:自动流程录制期间启动,超时未收到 record_stop 则自动结束录制 //【步进对焦】扫描期间每个 movy 都会续期一次,即"本步最长等待时间" QTimer *m_recordTimeout = nullptr; //【录制=按串口信号存帧】任何录制期间都不逐帧写盘,rawv 里只有"主板每移动一步的一帧", // 由 onMovDone -> recordStepFrame 同步写入并等待落盘。 // 取流线程只维护最近一帧原始帧(由 m_frameMutex 保护),不做任何写盘。 // m_afStepRecord 仅表示"步进模式"(决定 startRecord 是否向主板发 record_start)。 std::atomic m_afStepRecord{false}; cv::Mat m_afStepFrame; //最近一帧相机原始帧(Bayer8/YUYV),收到 movy 时落盘 int m_afStepFmt = -1; //上面这帧的像素格式(RawPixelFormat),-1=无 //上面这帧对应的显示帧(BGRA, 与 m_afStepFrame 同一次取流循环写入): //录制完成后用它算清晰度, 保证清晰度与落盘帧同帧 cv::Mat m_afStepDisplay; //上一次已落盘的步号: 同一步号再次收到 movy 时不再写盘(见 onMovDone) int m_afLastStepNo = -1; //上面这条 movy 的到达时刻(ms), 只用于判断"步号 1"是新一轮扫描还是超时补发 qint64 m_afLastStepMs = 0; //已写入 rawv 的帧数(界面显示用, 开始录制时清零) std::atomic m_recordedFrames{0}; //临时调试开关: true 时录制结束保留 rawv 文件(默认 false, 不写库, 重启复位) bool m_debugKeepRecord = false; //融合开关的界面状态副本: param::fusion_enable 会被 MQTT/读库改, // 由 onFPSUpdated 每秒对齐一次并 emit fusionEnabledChanged,界面才不会和实际状态不一致 bool m_fusionEnabled = true; //分析/融合处理中:取流端据此挂起转换与画面输出,把CPU让给后台重计算任务 QAtomicInt m_processing = 0; //保存结果图片阶段已提前恢复取流(相机预热):1=已预热,setProcessing(false) 时不再重复 StartGrabbing QAtomicInt m_cameraWarmup = 0; QString m_processMessage; int m_processPercent = 0; //预览降帧:上次推送预览画面的时刻(ms),由多个取流处理线程读写 QAtomicInteger m_lastPreviewMs = 0; //取流暂停标志:分析/融合期间停止相机取流(SDK停流),结束后恢复取流 QAtomicInt m_grabPaused = 0; int testJNI(); int checkPermission(void) { int ret = 0; const static char* MY_JAVA_CLASS = "GetUsbPermission"; ret = QJniObject::callStaticMethod(MY_JAVA_CLASS,"checkPermission","()I"); return ret; } static inline QImage cvMatToQImage( const cv::Mat &inMat ) { switch ( inMat.type() ) { // 8-bit, 4 channel case CV_8UC4: { QImage image( inMat.data, inMat.cols, inMat.rows, inMat.step, QImage::Format_RGB32 ); return image; } // 8-bit, 3 channel case CV_8UC3: { QImage image( inMat.data, inMat.cols, inMat.rows, inMat.step, QImage::Format_RGB888 ); return image.rgbSwapped(); } // 8-bit, 1 channel case CV_8UC1: { static QVector sColorTable; // only create our color table once if ( sColorTable.isEmpty() ) { for ( int i = 0; i < 256; ++i ) sColorTable.push_back( qRgb( i, i, i ) ); } QImage image( inMat.data, inMat.cols, inMat.rows, inMat.step, QImage::Format_Indexed8 ); image.setColorTable( sColorTable ); return image; } default: WARN("ASM::cvMatToQImage() - cv::Mat image type not handled in switch: {}", static_cast(inMat.type())); break; } return QImage(); } static cv::Mat QImageToCvMat(QImage inImage, bool inCloneImageData = true) { switch (inImage.format()) { // 8-bit, 4 channel case QImage::Format_ARGB32: case QImage::Format_ARGB32_Premultiplied: { cv::Mat mat(inImage.height(), inImage.width(), CV_8UC4, const_cast(inImage.bits()), static_cast(inImage.bytesPerLine()) ); return inCloneImageData ? mat.clone() : mat; } // 8-bit, 3 channel case QImage::Format_RGB32: { if (!inCloneImageData) { WARN("QImageToCvMat() - Conversion requires cloning so we don't modify the original QImage data"); } cv::Mat mat(inImage.height(), inImage.width(), CV_8UC4, const_cast(inImage.bits()), static_cast(inImage.bytesPerLine()) ); cv::Mat matNoAlpha; cv::cvtColor(mat, matNoAlpha, cv::COLOR_BGRA2BGR); // drop the all-white alpha channel return matNoAlpha; } // 8-bit, 3 channel case QImage::Format_RGB888: { if (!inCloneImageData) { WARN("QImageToCvMat() - Conversion requires cloning so we don't modify the original QImage data"); } QImage swapped = inImage.rgbSwapped(); cv::Mat mat(swapped.height(), swapped.width(), CV_8UC3, const_cast(swapped.bits()), static_cast(swapped.bytesPerLine()) ); return inCloneImageData ? mat.clone() : mat; } // 8-bit, 1 channel case QImage::Format_Grayscale8: case QImage::Format_Indexed8: { cv::Mat mat(inImage.height(), inImage.width(), CV_8UC1, const_cast(inImage.bits()), static_cast(inImage.bytesPerLine()) ); return inCloneImageData ? mat.clone() : mat; } #if QT_VERSION >= QT_VERSION_CHECK(5, 13, 0) case QImage::Format_Grayscale16: { cv::Mat mat(cv::Size(inImage.width(),inImage.height()),CV_16U,const_cast(inImage.bits()),cv::Mat::AUTO_STEP); return inCloneImageData ? mat.clone() : mat; } #endif default: WARN("QImageToCvMat() - QImage format not handled in switch: {}", static_cast(inImage.format())); break; } return cv::Mat(); } bool IsColor(MvGvspPixelType enType) { switch(enType) { case PixelType_Gvsp_BGR8_Packed: case PixelType_Gvsp_YUV422_Packed: case PixelType_Gvsp_YUV422_YUYV_Packed: case PixelType_Gvsp_BayerGR8: case PixelType_Gvsp_BayerRG8: case PixelType_Gvsp_BayerGB8: case PixelType_Gvsp_BayerBG8: case PixelType_Gvsp_BayerGB10: case PixelType_Gvsp_BayerGB10_Packed: case PixelType_Gvsp_BayerBG10: case PixelType_Gvsp_BayerBG10_Packed: case PixelType_Gvsp_BayerRG10: case PixelType_Gvsp_BayerRG10_Packed: case PixelType_Gvsp_BayerGR10: case PixelType_Gvsp_BayerGR10_Packed: case PixelType_Gvsp_BayerGB12: case PixelType_Gvsp_BayerGB12_Packed: case PixelType_Gvsp_BayerBG12: case PixelType_Gvsp_BayerBG12_Packed: case PixelType_Gvsp_BayerRG12: case PixelType_Gvsp_BayerRG12_Packed: case PixelType_Gvsp_BayerGR12: case PixelType_Gvsp_BayerGR12_Packed: return true; default: return false; } } bool IsMono(MvGvspPixelType enType) { switch(enType) { case PixelType_Gvsp_Mono10: case PixelType_Gvsp_Mono10_Packed: case PixelType_Gvsp_Mono12: case PixelType_Gvsp_Mono12_Packed: return true; default: return false; } } //地址的转换函数 bool ConvertToHexIp(unsigned int *nHexIP, unsigned int *nDecIP) { if ( nDecIP[0] < 0 || nDecIP[0] > 255 || nDecIP[1] < 0 || nDecIP[1] > 255 || nDecIP[2] < 0 || nDecIP[2] > 255 || nDecIP[3] < 0 || nDecIP[3] > 255) { return false; } *nHexIP = (nDecIP[0] << 24) + (nDecIP[1] << 16) + (nDecIP[2] << 8) + nDecIP[3]; return true; } }; // class Frames //! 原始视频流(.rawv)播放器:逐帧读取未压缩的原始帧并推送到 QVideoSink 播放 class RawVideoPlayer : public QObject { Q_OBJECT QML_ELEMENT Q_PROPERTY( QVideoSink* videoSink READ videoSink WRITE setVideoSink NOTIFY videoSinkChanged ) Q_PROPERTY( bool playing READ playing NOTIFY playingChanged ) Q_PROPERTY( bool loaded READ loaded NOTIFY loadedChanged ) Q_PROPERTY( int position READ position NOTIFY positionChanged ) Q_PROPERTY( int frameCount READ frameCount NOTIFY frameCountChanged ) Q_PROPERTY( QString source READ source NOTIFY sourceChanged ) Q_PROPERTY( bool busy READ busy NOTIFY busyChanged ) public: explicit RawVideoPlayer(QObject *parent = nullptr); QVideoSink* videoSink() const { return m_videoSink; } void setVideoSink(QVideoSink *newVideoSink); bool playing() const { return m_playing; } bool loaded() const { return m_loaded; } int position() const { return m_position; } int frameCount() const { return m_frameCount; } QString source() const { return m_source; } bool busy() const { return m_busy; } //打开原始视频流文件,成功后可调用 play() Q_INVOKABLE bool open(const QString &path); Q_INVOKABLE void play(); Q_INVOKABLE void pause(); Q_INVOKABLE void stop(); //定位到指定帧(立即刷新画面) Q_INVOKABLE void seek(int frameIndex); Q_INVOKABLE void close(); //删除当前打开/播放的录制视频流文件(.rawv),结果图片不受影响 Q_INVOKABLE bool removeCurrentFile(); //判断文件是否为原始视频流(.rawv) Q_INVOKABLE bool isRawVideo(const QString &path) const; //分析:识别视频帧中最清晰的一帧,锐化+对比度增强后保存为图片(与视频同目录) Q_INVOKABLE void analyzeSharpestFrame(); //融合:在最清晰帧上下邻域选帧做景深融合,锐化+对比度增强后保存为图片(与视频同目录) Q_INVOKABLE void fuseVideoFrames(); signals: void videoSinkChanged(); void playingChanged(); void loadedChanged(); void positionChanged(); void frameCountChanged(); void sourceChanged(); void busyChanged(); //分析结束:path为空表示失败,成功时图片已保存到path void analyzeFinished(const QString &path); //融合结束:path为空表示失败,成功时图片已保存到path void fuseFinished(const QString &path); //当前视频流文件已被删除,path为被删除的文件路径 void fileRemoved(const QString &path); private slots: void onTick(); private: //读取并推送当前帧,失败返回false bool pushFrame(); void setBusy(bool busy); //结果图片路径,命名与拍照图片一致:<视频时间戳>z0x0[_sharp]_<序号>.jpg QString resultPath(int serial, bool sharp) const; QFile m_file; QTimer m_timer; QVideoSink *m_videoSink = nullptr; QString m_source; int m_width = 0; int m_height = 0; int m_stride = 0; int m_fps = 0; int m_frameCount = 0; int m_position = 0; //视频流内帧的像素格式(见 RawPixelFormat),0=BGRA8 兼容旧文件 int m_pixelFormat = 0; bool m_loaded = false; bool m_playing = false; //分析/融合任务进行中(进行中时不重复触发) bool m_busy = false; //同一视频内结果序号:分析结果与融合结果成对(_sharp_后缀) int m_resultSerial = 0; }; } /* namespace Qt6QCamera */ Q_DECLARE_METATYPE(cv::Mat) #endif // M_FRAMES_HPP