/** @brief  Opens a video file or a capturing device or an IP video stream for video capturing.
    @overload
    Parameters are same as the constructor VideoCapture(const String& filename, int apiPreference = CAP_ANY)
    @return `true` if the file has been successfully opened
     */
    CV_WRAP virtual bool open(const String& filename, int apiPreference = CAP_ANY);

    /** @brief  Opens a camera for video capturing
    @overload
    Parameters are same as the constructor VideoCapture(int index, int apiPreference = CAP_ANY)
    @return `true` if the camera has been successfully opened.
    */
    CV_WRAP virtual bool open(int index, int apiPreference = CAP_ANY);

    /** @brief Closes video file or capturing device.
    The method is automatically called by subsequent VideoCapture::open and by VideoCapture
    destructor.
    The C function also deallocates memory and clears \*capture pointer.
     */
    CV_WRAP virtual void release();

   /** @brief Grabs, decodes and returns the next video frame.

    @param [out] image the video frame is returned here. If no frames has been grabbed the image will be empty.
    @return `false` if no frames has been grabbed

    The method/function combines VideoCapture::grab() and VideoCapture::retrieve() in one call. This is the
    most convenient method for reading video files or capturing data from decode and returns the just
    grabbed frame. If no frames has been grabbed (camera has been disconnected, or there are no more
    frames in video file), the method returns false and the function returns empty image (with %cv::Mat, test it with Mat::empty()).

    @note In @ref videoio_c "C API", functions cvRetrieveFrame() and cv.RetrieveFrame() return image stored inside the video
    capturing structure. It is not allowed to modify or release the image! You can copy the frame using
    cvCloneImage and then do whatever you want with the copy.
     */
    CV_WRAP virtual bool read(OutputArray image);

    /** @brief Sets a property in the VideoCapture.

    @param propId Property identifier from cv::VideoCaptureProperties (eg. cv::CAP_PROP_POS_MSEC, cv::CAP_PROP_POS_FRAMES, ...)
    or one from @ref videoio_flags_others
    @param value Value of the property.
    @return `true` if the property is supported by backend used by the VideoCapture instance.
    @note Even if it returns `true` this doesn't ensure that the property
    value has been accepted by the capture device. See note in VideoCapture::get()
     */
    CV_WRAP virtual bool set(int propId, double value);

    /** @brief Returns the specified VideoCapture property

    @param propId Property identifier from cv::VideoCaptureProperties (eg. cv::CAP_PROP_POS_MSEC, cv::CAP_PROP_POS_FRAMES, ...)
    or one from @ref videoio_flags_others
    @return Value for the specified property. Value 0 is returned when querying a property that is
    not supported by the backend used by the VideoCapture instance.
    
    @note Reading / writing properties involves many layers. Some unexpected result might happens
    along this chain.
    @code{.txt}
    VideoCapture -> API Backend -> Operating System -> Device Driver -> Device Hardware
    @endcode
    The returned value might be different from what really used by the device or it could be encoded
    using device dependent rules (eg. steps or percentage). Effective behaviour depends from device
    driver and API Backend
    */
    CV_WRAP virtual double get(int propId) const;

/** @brief %VideoCapture generic properties identifier.

 Reading / writing properties involves many layers. Some unexpected result might happens along this chain.
 Effective behaviour depends from device hardware, driver and API Backend.
 @sa videoio_flags_others, VideoCapture::get(), VideoCapture::set()
*/
enum VideoCaptureProperties {
       CAP_PROP_POS_MSEC       =0, //!< Current position of the video file in milliseconds.
       CAP_PROP_POS_FRAMES     =1, //!< 0-based index of the frame to be decoded/captured next.
       CAP_PROP_POS_AVI_RATIO  =2, //!< Relative position of the video file: 0=start of the film, 1=end of the film.
       CAP_PROP_FRAME_WIDTH    =3, //!< Width of the frames in the video stream.
       CAP_PROP_FRAME_HEIGHT   =4, //!< Height of the frames in the video stream.
       CAP_PROP_FPS            =5, //!< Frame rate.
       CAP_PROP_FOURCC         =6, //!< 4-character code of codec. see VideoWriter::fourcc .
       CAP_PROP_FRAME_COUNT    =7, //!< Number of frames in the video file.
       CAP_PROP_FORMAT         =8, //!< Format of the %Mat objects (see Mat::type()) returned by VideoCapture::retrieve().
                                   //!< Set value -1 to fetch undecoded RAW video streams (as Mat 8UC1).
       CAP_PROP_MODE           =9, //!< Backend-specific value indicating the current capture mode.
       CAP_PROP_BRIGHTNESS    =10, //!< Brightness of the image (only for those cameras that support).
       CAP_PROP_CONTRAST      =11, //!< Contrast of the image (only for cameras).
       CAP_PROP_SATURATION    =12, //!< Saturation of the image (only for cameras).
       CAP_PROP_HUE           =13, //!< Hue of the image (only for cameras).
       CAP_PROP_GAIN          =14, //!< Gain of the image (only for those cameras that support).
       CAP_PROP_EXPOSURE      =15, //!< Exposure (only for those cameras that support).
       CAP_PROP_CONVERT_RGB   =16, //!< Boolean flags indicating whether images should be converted to RGB. <br/>
                                   //!< *GStreamer note*: The flag is ignored in case if custom pipeline is used. It's user responsibility to interpret pipeline output.
       CAP_PROP_WHITE_BALANCE_BLUE_U =17, //!< Currently unsupported.
       CAP_PROP_RECTIFICATION =18, //!< Rectification flag for stereo cameras (note: only supported by DC1394 v 2.x backend currently).
       CAP_PROP_MONOCHROME    =19,
       CAP_PROP_SHARPNESS     =20,
       CAP_PROP_AUTO_EXPOSURE =21, //!< DC1394: exposure control done by camera, user can adjust reference level using this feature.
       CAP_PROP_GAMMA         =22,
       CAP_PROP_TEMPERATURE   =23,
       CAP_PROP_TRIGGER       =24,
       CAP_PROP_TRIGGER_DELAY =25,
       CAP_PROP_WHITE_BALANCE_RED_V =26,
       CAP_PROP_ZOOM          =27,
       CAP_PROP_FOCUS         =28,
       CAP_PROP_GUID          =29,
       CAP_PROP_ISO_SPEED     =30,
       CAP_PROP_BACKLIGHT     =32,
       CAP_PROP_PAN           =33,
       CAP_PROP_TILT          =34,
       CAP_PROP_ROLL          =35,
       CAP_PROP_IRIS          =36,
       CAP_PROP_SETTINGS      =37, //!< Pop up video/camera filter dialog (note: only supported by DSHOW backend currently. The property value is ignored)
       CAP_PROP_BUFFERSIZE    =38,
       CAP_PROP_AUTOFOCUS     =39,
       CAP_PROP_SAR_NUM       =40, //!< Sample aspect ratio: num/den (num)
       CAP_PROP_SAR_DEN       =41, //!< Sample aspect ratio: num/den (den)
       CAP_PROP_BACKEND       =42, //!< Current backend (enum VideoCaptureAPIs). Read-only property
       CAP_PROP_CHANNEL       =43, //!< Video input or Channel Number (only for those cameras that support)
       CAP_PROP_AUTO_WB       =44, //!< enable/ disable auto white-balance
       CAP_PROP_WB_TEMPERATURE=45, //!< white-balance color temperature
       CAP_PROP_CODEC_PIXEL_FORMAT =46,    //!< (read-only) codec's pixel format. 4-character code - see VideoWriter::fourcc . Subset of [AV_PIX_FMT_*](https://github.com/FFmpeg/FFmpeg/blob/master/libavcodec/raw.c) or -1 if unknown
       CAP_PROP_BITRATE       =47, //!< (read-only) Video bitrate in kbits/s
#ifndef CV_DOXYGEN
       CV__CAP_PROP_LATEST
#endif
     };

    /** @brief Initializes or reinitializes video writer.

    The method opens video writer. Parameters are the same as in the constructor
    VideoWriter::VideoWriter.
    @return `true` if video writer has been successfully initialized

    The method first calls VideoWriter::release to close the already opened file.
     */
    CV_WRAP virtual bool open(const String& filename, int fourcc, double fps,
                      Size frameSize, bool isColor = true);

    /** @overload
     */
    CV_WRAP bool open(const String& filename, int apiPreference, int fourcc, double fps,
                      Size frameSize, bool isColor = true);

    /** @overload
     */
    CV_WRAP bool open(const String& filename, int fourcc, double fps, const Size& frameSize,
                      const std::vector<int>& params);

    /** @overload
     */
    CV_WRAP bool open(const String& filename, int apiPreference, int fourcc, double fps,
                      const Size& frameSize, const std::vector<int>& params);

    /** @brief Concatenates 4 chars to a fourcc code

    @return a fourcc code

    This static method constructs the fourcc code of the codec to be used in the constructor
    VideoWriter::VideoWriter or VideoWriter::open.
     */
    CV_WRAP static int fourcc(char c1, char c2, char c3, char c4);
// FIXIT OpenCV 4.0: make inline
    int VideoWriter::fourcc(char c1, char c2, char c3, char c4)
    {
        return (c1 & 255) + ((c2 & 255) << 8) + ((c3 & 255) << 16) + ((c4 & 255) << 24);
    }

//! Macro to construct the fourcc code of the codec. Same as CV_FOURCC()
#define CV_FOURCC_MACRO(c1, c2, c3, c4) (((c1) & 255) + (((c2) & 255) << 8) + (((c3) & 255) << 16) + (((c4) & 255) << 24))

/** @brief Constructs the fourcc code of the codec function

Simply call it with 4 chars fourcc code like `CV_FOURCC('I', 'Y', 'U', 'V')`

List of codes can be obtained at [Video Codecs by FOURCC](http://www.fourcc.org/codecs.php) page.
FFMPEG backend with MP4 container natively uses other values as fourcc code:
see [ObjectType](http://mp4ra.org/#/codecs).
*/
CV_INLINE int CV_FOURCC(char c1, char c2, char c3, char c4)
{
    return CV_FOURCC_MACRO(c1, c2, c3, c4);
}
//! (Windows only) Open Codec Selection Dialog
#define CV_FOURCC_PROMPT -1
//! (Linux only) Use default codec for specified filename
#define CV_FOURCC_DEFAULT CV_FOURCC('I', 'Y', 'U', 'V')

[static] QList<QCameraInfo> QCameraInfo::availableCameras(QCamera::Position position = QCamera::UnspecifiedPosition)
Returns a list of available cameras on the system which are located at position.
If position is not specified or if the value is QCamera::UnspecifiedPosition, a list of all available cameras will be returned.

QList<QSize> QCamera::supportedViewfinderResolutions(const QCameraViewfinderSettings &settings = QCameraViewfinderSettings()) const
Returns a list of supported viewfinder resolutions.
This is a convenience function which retrieves unique resolutions from the supported settings.
If non null viewfinder settings are passed, the returned list is reduced to resolutions supported with partial settings applied.
The camera must be loaded before calling this function, otherwise the returned list is empty.

QList<QCamera::FrameRateRange> QCamera::supportedViewfinderFrameRateRanges(const QCameraViewfinderSettings &settings = QCameraViewfinderSettings()) const
Returns a list of supported viewfinder frame rate ranges.
This is a convenience function which retrieves unique frame rate ranges from the supported settings.
If non null viewfinder settings are passed, the returned list is reduced to frame rate ranges supported with partial settings applied.
The camera must be loaded before calling this function, otherwise the returned list is empty.

QList<QVideoFrame::PixelFormat> QCamera::supportedViewfinderPixelFormats(const QCameraViewfinderSettings &settings = QCameraViewfinderSettings()) const
Returns a list of supported viewfinder pixel formats.
This is a convenience function which retrieves unique pixel formats from the supported settings.
If non null viewfinder settings are passed, the returned list is reduced to pixel formats supported with partial settings applied.
The camera must be loaded before calling this function, otherwise the returned list is empty.

void MainWindow::GetCameraList()
{
    formatmeta = QMetaEnum::fromType<PixelFormat>();
    cameras = QCameraInfo::availableCameras();
    foreach(const QCameraInfo &cameraInfo, cameras)
    {
        ui->comboBox_name->addItem(cameraInfo.description());
        GetCameraInfo(cameraInfo);
        COUT << cameraInfo.description() <<cameraInfo.deviceName() << cameraInfo.orientation();
    }
}

    connect(ui->comboBox_name,SIGNAL(activated(int)),this,SLOT(slot_SetIndexCaptureCamera(int))); //Подключение сигнального слота

void MainWindow::slot_SetIndexCaptureCamera(int index) //Выбор камеры
{
    if(cap.isOpened())
    {
        timer.stop();
        cap.release();
    }
    cap.open(index,cv::CAP_DSHOW);

    if(!cap.isOpened())
    {
        COUT << cameras.at(index).description() << «Открыть не удалось»;
        return;
    }
    SetComboxValue(index); //Отображение значения по умолчанию

    timer.start(20); //Таймер запускается
}

void MainWindow::slot_CaptureImage()
{
    cv::Mat frame,image;
    cap.read(frame);
    if(frame.empty())
        return;
    emit signal_MatImage(frame);
}

    connect(&timer,&QTimer::timeout,this,&MainWindow::slot_CaptureImage); //Привязка слота сигнала таймера

    connect(this,&MainWindow::signal_MatImage,this,&MainWindow::slot_LabelShowImg);

void MainWindow::slot_LabelShowImg(cv::Mat image)
{
    cv::Mat out_image;
    cv::cvtColor(image,out_image,cv::COLOR_BGR2RGB); //Преобразуем в Qt для отображения значений RGB
    QImage qImg = QImage((const unsigned char*)(out_image.data),out_image.cols,out_image.rows,out_image.step,QImage::Format_RGB888); //Преобразовать в QImage
    ui->label_video->setPixmap(QPixmap::fromImage(qImg.mirrored(true,false)));
    ui->label_video->resize(qImg.size());
    ui->label_video->show();
    //Настройки, связанные с фотографией
    if(isSaveImage){
        QString image_name = QString("%1.png").arg(QDateTime::currentDateTime().toString("yyyy-MM-dd_HH-mm-ss"));
        if(qImg.save(image_name))
        {
            COUT << "Фотографияуспех！" << image_name;
            isSaveImage = false;
        }
        else {
            COUT << «Не удалось сохранить изображение!»  << image_name;
        }
    }
}

void MainWindow::GetCameraInfo(QCameraInfo info)
{
    QCamera * camera = new QCamera(info);
    camera->start();
    GetCameraResolution(camera);
    GetCameraFormat(camera);
    GetCameraFrameRate(camera);
    camera->stop();
    delete camera;
    camera = nullptr;
}

void MainWindow::GetCameraResolution(QCamera *camera)
{
    QStringList resolutions;
    QList<QSize> resSize = camera->supportedViewfinderResolutions();
    for(auto it : resSize)
    {
        resolutions.push_back(QString("%1X%2").arg(it.width()).arg(it.height()));
        COUT << QString("%1X%2").arg(it.width()).arg(it.height());
    }
    camerasresolution.push_back(resolutions);
}

void MainWindow::GetCameraFormat(QCamera *camera)
{
    QStringList formats;
    QList<QVideoFrame::PixelFormat> formatlist = camera->supportedViewfinderPixelFormats();

    for(auto it : formatlist)
    {
        COUT << formatmeta.valueToKey(it) ;
        formats.push_back(formatmeta.valueToKey(it));
    }
    camerasformat.push_back(formats);
}

void MainWindow::GetCameraFrameRate(QCamera *camera)
{
    QStringList frames;
    QList<QCamera::FrameRateRange> framerate = camera->supportedViewfinderFrameRateRanges();

    for(auto it : framerate)
    {
        frames.push_back(QString("%1").arg(it.minimumFrameRate));
    }
    camerasframerate.push_back(frames);
}

void MainWindow::SetComboxValue(int index)
{
    ui->comboBox_resolution->clear();
    ui->comboBox_resolution->addItems(camerasresolution.at(index));
    QString resolution = QString("%1X%2").arg(cap.get(cv::CAP_PROP_FRAME_WIDTH)).arg(cap.get(cv::CAP_PROP_FRAME_HEIGHT));
    ui->comboBox_resolution->setCurrentIndex(ui->comboBox_resolution->findText(resolution));
    COUT << "resolution:" <<resolution;

    ui->comboBox_format->clear();
    ui->comboBox_format->addItems(camerasformat.at(index));
    QString format = QString("%1").arg(cap.get(cv::CAP_PROP_FORMAT));
    COUT << "format:" << format;

    ui->comboBox_framerate->clear();
    ui->comboBox_framerate->addItems(camerasframerate.at(index));
    QString framerate = QString("%1").arg(cap.get(cv::CAP_PROP_FPS));
    ui->comboBox_framerate->setCurrentIndex(ui->comboBox_framerate->findText(framerate));
    COUT << "framerate:" << framerate;

    QString pixelformat = QString("%1").arg(cap.get(cv::CAP_PROP_CODEC_PIXEL_FORMAT));
    COUT << "pixelformat:" << pixelformat;

    QString gain = QString("%1").arg(cap.get(cv::CAP_PROP_GAIN));
    COUT << "gain:" << gain;

    ui->spinBox_brightness->setValue(DoubleToInt(cap.get(cv::CAP_PROP_BRIGHTNESS))); //Показать яркость по умолчанию
    ui->spinBox_contrast->setValue(DoubleToInt(cap.get(cv::CAP_PROP_CONTRAST))); //Показать Контраст по умолчанию
    ui->spinBox_exposure->setValue(DoubleToInt(cap.get(cv::CAP_PROP_EXPOSURE))); //Отображение контакта по умолчанию
    ui->spinBox_hue->setValue(DoubleToInt(cap.get(cv::CAP_PROP_HUE))); //Показать тон по умолчанию
    ui->spinBox_saturation->setValue(DoubleToInt(cap.get(cv::CAP_PROP_SATURATION))); //Показать насыщенность по умолчанию
    ui->spinBox_wb->setValue(DoubleToInt(cap.get(cv::CAP_PROP_WHITE_BALANCE_BLUE_U))); //Отображение баланса по умолчанию белого
    ui->spinBox_gain->setValue(DoubleToInt(cap.get(cv::CAP_PROP_GAIN))); //Показать автоматический Прирост
    ui->checkBox_autoexposure->setCheckState((cap.get(cv::CAP_PROP_AUTO_EXPOSURE))?Qt::CheckState::Checked:Qt::CheckState::Unchecked); //Будет ли автоматически связываться
    ui->checkBox_autowb->setCheckState((cap.get(cv::CAP_PROP_AUTO_WB))?Qt::CheckState::Checked:Qt::CheckState::Unchecked);
} //Нужно ли автоматически балансировать белого

    connect(ui->comboBox_resolution,SIGNAL(activated(int)),this,SLOT(slot_SetIndexCameraResolution(int)));//разрешение
    connect(ui->comboBox_framerate,SIGNAL(activated(int)),this,SLOT(slot_SetIndexCameraFrameRate(int)));//Частота кадров
    connect(ui->spinBox_brightness,SIGNAL(valueChanged(int)),this,SLOT(slot_SetCameraBrightness(int)));//яркость
    connect(ui->spinBox_contrast,SIGNAL(valueChanged(int)),this,SLOT(slot_SetCameraContrast(int)));//Контраст
    connect(ui->spinBox_exposure,SIGNAL(valueChanged(int)),this,SLOT(slot_SetCameraExposure(int)));//контакт
    connect(ui->spinBox_hue,SIGNAL(valueChanged(int)),this,SLOT(slot_SetCameraHue(int)));//тон
    connect(ui->spinBox_saturation,SIGNAL(valueChanged(int)),this,SLOT(slot_SetCameraSaturation(int)));//Насыщенность
    connect(ui->spinBox_gain,SIGNAL(valueChanged(int)),this,SLOT(slot_SetCameraGain(int)));//Прирост
    connect(ui->spinBox_wb,SIGNAL(valueChanged(int)),this,SLOT(slot_SetCameraWhilteBalance(int)));//баланс белого
    connect(ui->checkBox_autoexposure,&QCheckBox::stateChanged,this,&MainWindow::slot_SetCameraAutoExposure);//автоматическийконтакт
    connect(ui->checkBox_autowb,&QCheckBox::stateChanged,this,&MainWindow::slot_SetCameraAutoWb);//автоматическийбаланс белого
    connect(ui->pushButton_setting,&QPushButton::clicked,this,&MainWindow::slot_SetCameraPram);//OpenCvПринесите свой собственный Настройки параметров

void MainWindow::slot_SetIndexCameraResolution(int index)
{
    if(!cap.isOpened())
    {
        COUT << «Камера устройства не включена!»;
        return;
    }
    QString resolution = ui->comboBox_resolution->itemText(index);
    double width = resolution.split("X").at(0).toDouble();
    double height = resolution.split("X").at(1).toDouble();
    COUT << cap.get(cv::CAP_PROP_FRAME_WIDTH) << cap.get(cv::CAP_PROP_FRAME_HEIGHT);
    cap.set(cv::CAP_PROP_FRAME_WIDTH,width);
    cap.set(cv::CAP_PROP_FRAME_HEIGHT,height);
}

void MainWindow::slot_SetIndexCameraFrameRate(int index)
{
    if(!cap.isOpened())
    {
        COUT << «Камера устройства не включена!»;
        return;
    }
    QString framerate = ui->comboBox_framerate->itemText(index);
    cap.set(cv::CAP_PROP_FPS,framerate.toDouble());
}

void MainWindow::slot_SetCameraBrightness(int value)
{
    if(!cap.isOpened())
    {
        COUT << «Камера устройства не включена!»;
        return;
    }
    cap.set(cv::CAP_PROP_BRIGHTNESS,value);
}

void MainWindow::slot_SetCameraSaturation(int value)
{
    if(!cap.isOpened())
    {
        COUT << «Камера устройства не включена!»;
        return;
    }
    cap.set(cv::CAP_PROP_SATURATION,value);
}

void MainWindow::slot_SetCameraHue(int value)
{
    if(!cap.isOpened())
    {
        COUT << «Камера устройства не включена!»;
        return;
    }
    cap.set(cv::CAP_PROP_HUE,value);
}

void MainWindow::slot_SetCameraExposure(int value)
{
    if(!cap.isOpened())
    {
        COUT << «Камера устройства не включена!»;
        return;
    }
    cap.set(cv::CAP_PROP_EXPOSURE,value);
    COUT << "CAP_PROP_EXPOSURE:" << QString("%1").arg(cap.get(cv::CAP_PROP_EXPOSURE));
}

void MainWindow::slot_SetCameraContrast(int value)
{
    if(!cap.isOpened())
    {
        COUT << «Камера устройства не включена!»;
        return;
    }
    cap.set(cv::CAP_PROP_CONTRAST,value);
}

void MainWindow::slot_SetCameraGain(int value)
{
    if(!cap.isOpened())
    {
        COUT << «Камера устройства не включена!»;
        return;
    }
    cap.set(cv::CAP_PROP_GAIN,value);
}

void MainWindow::slot_SetCameraWhilteBalance(int value)
{
    if(!cap.isOpened())
    {
        COUT << «Камера устройства не включена!»;
        return;
    }
    cap.set(cv::CAP_PROP_WHITE_BALANCE_BLUE_U,value);
}

void MainWindow::slot_SetCameraAutoWb(int status)
{
    if(!cap.isOpened())
    {
        COUT << «Камера устройства не включена!»;
        return;
    }
    cap.set(cv::CAP_PROP_AUTO_WB,(status == Qt::CheckState::Checked) ? -1 : cap.get(cv::CAP_PROP_EXPOSURE));
    ui->spinBox_wb->setDisabled(status);
}

void MainWindow::slot_SetCameraAutoExposure(int status)
{
    COUT << «Установить автоматический контакт» << status;
    if(!cap.isOpened())
    {
        COUT << «Камера устройства не включена!»;
        return;
    }
    if(status == Qt::CheckState::Checked)
    {
        cap.set(cv::CAP_PROP_AUTO_EXPOSURE,0);
        cv::VideoCaptureProperties();
    }
    else
    {
        cap.set(cv::CAP_PROP_AUTO_EXPOSURE,1);
        cap.set(cv::CAP_PROP_EXPOSURE,cap.get(cv::CAP_PROP_EXPOSURE));
    }
    ui->spinBox_exposure->setDisabled(status);
    COUT << "автоматическийконтакт：" << cap.get(cv::CAP_PROP_AUTO_EXPOSURE);
    COUT << "контакт：" << cap.get(cv::CAP_PROP_EXPOSURE);
}

void MainWindow::slot_SetCameraPram()
{
    COUT << «Установить параметры камеры»;
    if(!cap.isOpened())
    {
        COUT << «Камера устройства не включена!»;
        return;
    }
    cap.set(cv::CAP_PROP_SETTINGS, 1);
    COUT << "автоматическийконтакт：" << cap.get(cv::CAP_PROP_AUTO_EXPOSURE);
    COUT << "контакт：" << cap.get(cv::CAP_PROP_EXPOSURE);
    COUT << «Автоматический баланс. белого：" << cap.get(cv::CAP_PROP_AUTO_WB);
    COUT << "баланс белого：" << cap.get(cv::CAP_PROP_WHITE_BALANCE_BLUE_U);
}

    connect(ui->pushButton_photo,&QPushButton::clicked,this,&MainWindow::slot_Photograph);

void MainWindow::slot_Photograph()
{
    if(!cap.isOpened())
    {
        COUT << «Камера устройства не включена!»;
        return;
    }

    isSaveImage = true; //Когда бит флага равен True, начинаем сохранять текущий кадр
}

    connect(ui->pushButton_recordvideo,&QPushButton::clicked,this,&MainWindow::slot_RecordVideo);
    connect(this,&MainWindow::signal_MatImage,this,&MainWindow::slot_SaveVideo);

void MainWindow::slot_RecordVideo()
{
    if(!cap.isOpened())
    {
        COUT << «Камера устройства не включена!»;
        return;
    }

    if(!videorecord.isOpened() && isRecordVideo == false)
    {
        QString resolution = ui->comboBox_resolution->currentText();
        int width = resolution.split("X").at(0).toInt();
        int height = resolution.split("X").at(1).toInt();
        COUT << "video size:" << width << " " << height;
        cv::Size _size = cv::Size(width,height);

        QString video_name = QString("%1.mp4").arg(QDateTime::currentDateTime().toString("yyyy-MM-dd_HH-mm-ss"));

        videorecord.open(video_name.toStdString(),cv::VideoWriter::fourcc('M', 'J', 'P', 'G'),30,_size,true);//Устанавливаем атрибут сохранения-кодирования-имя-разрешение
        if(videorecord.isOpened())
        {
            isRecordVideo = true;
            COUT << «Начать видеозапись»;
            ui->pushButton_recordvideo->setText("Завершить запись");
        }
    }
    else if(videorecord.isOpened() && isRecordVideo)
    {
        ui->pushButton_recordvideo->setText("видеозапись");
        videorecord.release();
        isRecordVideo = false;
        COUT << "видеозапись Заканчивать";    }
}

void MainWindow::slot_SaveVideo(cv::Mat image) //записываем файл кадра
{
    if(isRecordVideo)
    {
       videorecord.write(image);
    }
}

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QCamera>
#include <QCameraInfo>
#include <opencv2/opencv.hpp>
#include <QList>
#include <QTimer>
#include <QMetaEnum>
#include <QDebug>

#define COUT qDebug()<< __TIME__ << __FUNCTION__ << __LINE__ << " : " //Вывод журнала для облегчения вашей собственной отладки и настройки

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    explicit MainWindow(QWidget *parent = nullptr);
    ~MainWindow();

    enum PixelFormat
    {
        Format_Invalid,
        Format_ARGB32,
        Format_ARGB32_Premultiplied,
        Format_RGB32,
        Format_RGB24,
        Format_RGB565,
        Format_RGB555,
        Format_ARGB8565_Premultiplied,
        Format_BGRA32,
        Format_BGRA32_Premultiplied,
        Format_BGR32,
        Format_BGR24,
        Format_BGR565,
        Format_BGR555,
        Format_BGRA5658_Premultiplied,

        Format_AYUV444,
        Format_AYUV444_Premultiplied,
        Format_YUV444,
        Format_YUV420P,
        Format_YV12,
        Format_UYVY,
        Format_YUYV,
        Format_NV12,
        Format_NV21,
        Format_IMC1,
        Format_IMC2,
        Format_IMC3,
        Format_IMC4,
        Format_Y8,
        Format_Y16,

        Format_Jpeg,

        Format_CameraRaw,
        Format_AdobeDng,
    };
    Q_ENUM(PixelFormat)

private:
    Ui::MainWindow *ui;
    QList<QCameraInfo> cameras;
    QList<QStringList> camerasresolution;
    QList<QStringList> camerasformat;
    QList<QStringList> camerasframerate;
    QTimer timer;
    QMetaEnum formatmeta;
    cv::VideoCapture cap;
    cv::VideoWriter videorecord;
    bool isSaveImage;
    bool isRecordVideo;
    void CamerasInit();
    void GetCameraList();
    void GetCameraInfo(QCameraInfo info);
    void GetCameraResolution(QCamera *camera);
    void GetCameraFormat(QCamera *camera);
    void GetCameraFrameRate(QCamera *camera);
    void SetComboxValue(int index);
public slots:
    void slot_SetIndexCaptureCamera(int index);
    void slot_CaptureImage();
    void slot_LabelShowImg(cv::Mat image);
    void slot_SetIndexCameraResolution(int index);
    void slot_SetIndexCameraFrameRate(int index);
    void slot_SetCameraBrightness(int value);
    void slot_SetCameraSaturation(int value);
    void slot_SetCameraHue(int value);
    void slot_SetCameraExposure(int value);
    void slot_SetCameraContrast(int value);
    void slot_SetCameraGain(int value);
    void slot_SetCameraWhilteBalance(int value);
    void slot_SetCameraAutoWb(int status);
    void slot_SetCameraAutoExposure(int status);
    void slot_SetCameraPram();
    void slot_Photograph();
    void slot_RecordVideo();
    void slot_SaveVideo(cv::Mat image);

signals:
    void signal_MatImage(cv::Mat);
};

#endif // MAINWINDOW_H