myvtm/DevAdapter/keba/HSPScanner.keba.1.1/hspscannerform.cpp

#include "hspscannerform.h"
#include "ui_hspscannerform.h"

LOG_EXTERN()

HSPScannerForm::HSPScannerForm(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::HSPScannerForm)
{
    ui->setupUi(this);
    Qt::WindowFlags flags = windowFlags();
    this->setWindowFlags(flags | Qt::WindowStaysOnTopHint | Qt::FramelessWindowHint);

    m_ViewTimer = new QTimer(this);
    connect(m_ViewTimer, SIGNAL(timeout()), this, SLOT(onCamTimer()));

    m_bIsGrey = false;
    m_bIsOpen = m_bIsView = false;
    m_bIsHide = true;
    m_iRotate = 0;
    m_iScanSz = 0;
    m_iCamIdx = -1;

    SetPos(0, 0 , DEFAULT_DIALOG_WIDTH, DEFAULT_DIALOG_HEIGHT); //SetPos(1080, 0 , 384, 216);
    m_dA4Pos[0] = 0.07;
    m_dA4Pos[1] = 0.07;
    m_dA4Pos[2] = 0.93;
    m_dA4Pos[3] = 0.93;

    m_dIDPos[0] = 0.35;
    m_dIDPos[1] = 0.35;
    m_dIDPos[2] = 0.65;
    m_dIDPos[3] = 0.65;

    m_iCamAll[0] = DEFAULT_DIALOG_WIDTH; //DEFAULT_DIALOG_WIDTH
    m_iCamAll[1] = DEFAULT_DIALOG_HEIGHT;
}

HSPScannerForm::~HSPScannerForm()
{
    delete ui;
    delete m_ViewTimer;
}

void HSPScannerForm::SetPos(int iX, int iY, int iW, int iH)
{
    LOG_FUNCTION();

    this->move(iX, iY);
    ui->labViewPos->move(iX, iY);
    this->resize(iW, iH);
    ui->labViewPos->resize(iW, iH);
    ui->labViewPos->setAlignment(Qt::AlignCenter);
    QPalette label_palette;
    label_palette.setColor(QPalette::Background, QColor(200,200,200));

    ui->labViewPos->setAutoFillBackground(true);
    ui->labViewPos->setPalette(label_palette);
}

void HSPScannerForm::SetSize(float dA4[], float dID[], int iAll[])
{
    LOG_FUNCTION();

        memcpy(m_dA4Pos, dA4, sizeof(m_dA4Pos));
        memcpy(m_dIDPos, dID, sizeof(m_dIDPos));
        memcpy(m_iCamAll, iAll, sizeof(m_iCamAll));
}

QImage HSPScannerForm::Mat2QImage(cv::Mat cvImg)
{
    LOG_FUNCTION();

    QImage qImg;
    if(cvImg.channels() == 3) //3 channels color image
        {
            qImg = QImage((const unsigned char*)(cvImg.data),
                                        cvImg.cols, cvImg.rows,
                                        cvImg.cols * cvImg.channels(),
                                        QImage::Format_RGB888);
        }
        else if(cvImg.channels() == 1) //grayscale image
        {
            qImg = QImage((const unsigned char*)(cvImg.data),
                                        cvImg.cols, cvImg.rows,
                                        cvImg.cols * cvImg.channels(),
                                        QImage::Format_Indexed8);
        }
        else
        {
            qImg = QImage((const unsigned char*)(cvImg.data),
                                        cvImg.cols, cvImg.rows,
                                        cvImg.cols * cvImg.channels(),
                                        QImage::Format_RGB888);
        }

        return qImg.rgbSwapped();
}

void HSPScannerForm::onCamTimer()
{
    LOG_FUNCTION();

    std::lock_guard<std::mutex> lock(m_mutex);//自动锁

        cv::Mat mMat1, mMat2;

        LogM("Read Start!");
        m_cvCamera.read(mMat1);
        //m_cvCamera >> mMat1;
        LogM("Read End!");

        cv::Size size = mMat1.size();
        if(mMat1.empty())
        {
            m_cvCamera.release();
            m_ViewTimer->stop();
            m_bIsView = false;
        }
        //if(mMat1.empty()) return;

        //灰度  mMat1-> mMat2
        if(m_bIsGrey)
            cv::cvtColor(mMat1, mMat2, cv::COLOR_RGB2GRAY);
        else
            mMat2 = mMat1;

        m_Capture = mMat2; //保存当前帧数据
        //
        if(m_iScanSz == 0)//HSPS_SCAN_FULL 全画幅扫描
        {
            //mMat1 = mMat2;
        }
        else if(m_iScanSz == 1)//HSPS_SCAN_A4 A4尺寸扫描
        {
         /*
            int _x = (int)(size.width * m_dA4Pos[0]);
            int _y = (int)(size.height * m_dA4Pos[1]);
            int _width = (int)(size.width * (m_dA4Pos[2] - m_dA4Pos[0]));
            int _height = (int)(size.height * (m_dA4Pos[3] - m_dA4Pos[1]));
            cv::Rect rA4(_x, _y, _width, _height);
        */
            cv::Rect rA4((int)(size.width * m_dA4Pos[0]), (int)(size.height * m_dA4Pos[1]),
                  (int)(size.width * (m_dA4Pos[2] - m_dA4Pos[0])), (int)(size.height * (m_dA4Pos[3] - m_dA4Pos[1])));
            m_rA4 = rA4;
            cv::rectangle(mMat2, m_rA4, cv::Scalar(0, 255, 0)); //画长方形

//            mMat2 = cv::Mat(cv::Size(rA4.width, rA4.height), mMat1.type());
//            mMat1(rA4).convertTo(mMat2, mMat2.type(), 1, 0);
        }
        else if(m_iScanSz == 2) //HSPS_SCAN_IDCARD 身份证尺寸扫描
        {
            cv::Rect rID((int)(size.width * m_dIDPos[0]), (int)(size.height * m_dIDPos[1]),
                     (int)(size.width * (m_dIDPos[2] - m_dIDPos[0])), (int)(size.height * (m_dIDPos[3] - m_dIDPos[1])));
            m_rID = rID;
            cv::rectangle(mMat2, m_rID, cv::Scalar(0, 255, 0)); //画长方形

//            mMat2 = cv::Mat(cv::Size(rID.width, rID.height), mMat1.type());
//            mMat1(rID).convertTo(mMat2, mMat2.type(), 1, 0);
//            cv::blur(mMat1, mMat2, cv::Size(rID.width, rID.height));
//            cv::medianBlur;
        }

//        HSPS_ROTATE_NOANGLE,	// 物理环境的上方为预览窗口的上方 Positive direction. 保持最初状态不旋转
//        HSPS_ROTATE_LEFT,		// 物理环境的左侧为预览窗口的上方  从最初状态向左旋转90度
//        HSPS_ROTATE_MIRROR,   // 物理环境的下方为预览窗口的上方 Opposite/Nagative direction. 从最初状态向左或向右旋转180度
//        HSPS_ROTATE_RIGHT,	// 物理环境的右侧为预览窗口的上方  从最初状态向右旋转90度

//        enum RotateFlags {
//            ROTATE_90_CLOCKWISE = 0, //!<Rotate 90 degrees clockwise 顺时针方向旋转90度
//            ROTATE_180 = 1, //!<Rotate 180 degrees clockwise 顺时针方向旋转180度
//            ROTATE_90_COUNTERCLOCKWISE = 2, //!<Rotate 270 degrees clockwise 顺时针方向旋转270度
//        };
        if(m_iRotate == 0)
            mMat1 = mMat2;
        else if(m_iRotate == 1)//从最初状态向左旋转90度，即顺时针方向旋转270度
            ROTATE(mMat2, mMat1, Enum_ROTATE_90_COUNTERCLOCKWISE);
        else if(m_iRotate == 2) //从最初状态向左或向右旋转180度
            ROTATE(mMat2, mMat1, Enum_ROTATE_180);
        else if(m_iRotate == 3) //从最初状态向右旋转90度，即顺时针方向旋转90度
            ROTATE(mMat2, mMat1, Enum_ROTATE_90_CLOCKWISE);

        if(this->isHidden()) return;

        QImage image = Mat2QImage(mMat1);
        QPixmap pixmap = QPixmap::fromImage(image);
        int iH = height();
        int iW = ((iH * pixmap.width()) / pixmap.height());
        QPixmap fiPixmap = pixmap.scaled(iW, iH, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
        ui->labViewPos->setPixmap(fiPixmap);
}

int HSPScannerForm::GetPic(const char* sFile)
{
    LOG_FUNCTION();
    LogM("GetPic(%s)", sFile);

    std::lock_guard<std::mutex> lock(m_mutex);//自动锁

        if(!m_cvCamera.isOpened()) return ERR_NOT_OPENED;
        if(m_Capture.empty()) return ERR_VIEW_FAIL;

        cv::Mat mMat1;
        if(m_iScanSz == 0)//HSPS_SCAN_FULL 全画幅扫描
        {
            mMat1 = m_Capture;
        }
        else if(m_iScanSz == 1)//HSPS_SCAN_A4 A4尺寸扫描
        {
            mMat1 = cv::Mat(cv::Size(m_rA4.width, m_rA4.height), m_Capture.type());
            m_Capture(m_rA4).convertTo(mMat1, mMat1.type(), 1, 0);
        }
        else if(m_iScanSz == 2) //HSPS_SCAN_IDCARD 身份证尺寸扫描
        {
            mMat1 = cv::Mat(cv::Size(m_rID.width, m_rID.height), m_Capture.type());
            m_Capture(m_rID).convertTo(mMat1, mMat1.type(), 1, 0);
        }

        if(cv::imwrite(sFile, mMat1)) //保存成文件
        {
            LogM("cv::imwrite(%s) OK!", sFile);
            return 0;
        }

        return ERR_VIEW_FAIL;
}

int HSPScannerForm::Open(const char* sID)
{
    LOG_FUNCTION();

    if(m_cvCamera.isOpened()) return 0;
    m_iCamIdx = GetCamIndex(sID);
    if(m_iCamIdx < 0) return ERR_NO_DEVICE;

    m_cvCamera.open(m_iCamIdx);
    if(m_cvCamera.isOpened())
    {
            //m_cvCamera.release();
            m_bIsOpen = true;

//            m_cvCamera.set(CV_CAP_PROP_FRAME_WIDTH, 1080);//宽度
//            m_cvCamera.set(CV_CAP_PROP_FRAME_HEIGHT, 960);//高度
//            m_cvCamera.set(CV_CAP_PROP_FPS, 30);//帧率 帧/秒
//            m_cvCamera.set(CV_CAP_PROP_BRIGHTNESS, 1);//亮度
//            m_cvCamera.set(CV_CAP_PROP_CONTRAST,40);//对比度 40
//            m_cvCamera.set(CV_CAP_PROP_SATURATION, 50);//饱和度 50
//            m_cvCamera.set(CV_CAP_PROP_HUE, 50);//色调 50
//            m_cvCamera.set(CV_CAP_PROP_EXPOSURE, 50);//曝光 50 获取摄像头参数
//            double cps_FOURCC = m_cvCamera.get(CV_CAP_PROP_FOURCC);
//            LogD("CV_CAP_PROP_FOURCC=[%f]", cps_FOURCC);
//            m_cvCamera.set(CV_CAP_PROP_FOURCC, CV_FOURCC('M', 'J', 'P', 'G'));

            double cps_W = m_cvCamera.get(cv::CAP_PROP_FRAME_WIDTH);
            double cps_H = m_cvCamera.get(cv::CAP_PROP_FRAME_HEIGHT);
            LogD("CAP_PROP_FRAME_WIDTH=[%f]", cps_W);
            LogD("CAP_PROP_FRAME_HEIGHT=[%f]", cps_H);

            return 0;
    }
    m_bIsOpen = false;
    return ERR_OPEN_FAIL;
}

int HSPScannerForm::Close()
{
    LOG_FUNCTION();

        if(isVisible()) hide();
        if(m_cvCamera.isOpened())
             m_cvCamera.release();

        m_bIsOpen = false;
        return 0;
}

int HSPScannerForm::Preview(bool b)
{
    LOG_FUNCTION();

        if(!m_bIsOpen) return ERR_NOT_OPENED;
        if(b)
        {
                if(!m_cvCamera.isOpened())
                    m_cvCamera.open(m_iCamIdx);
                if(!m_cvCamera.isOpened())
                    return ERR_OPEN_FAIL;

                m_cvCamera.set(cv::CAP_PROP_FRAME_WIDTH, m_iCamAll[0]); //
                m_cvCamera.set(cv::CAP_PROP_FRAME_HEIGHT, m_iCamAll[1]);

                double fps = m_cvCamera.get(cv::CAP_PROP_FPS); //CAP_PROP_FRAME_WIDTH  CAP_PROP_FRAME_HEIGHT
                double cps_W = m_cvCamera.get(cv::CAP_PROP_FRAME_WIDTH);
                double cps_H = m_cvCamera.get(cv::CAP_PROP_FRAME_HEIGHT);
                LogD("CAP_PROP_FPS=[%f]", fps);
                LogD("CAP_PROP_FRAME_WIDTH=[%f]", cps_W);
                LogD("CAP_PROP_FRAME_HEIGHT=[%f]", cps_H);

                if(fps < 10) fps = 10;
                m_ViewTimer->start(int(1000/fps));
                m_bIsView = true;
        }
        else
        {
            m_bIsView =false;
            m_ViewTimer->stop();
            m_cvCamera.release();
        }

        return 0;
}

int HSPScannerForm::Show(bool b)
{
    if(!m_bIsOpen) return ERR_NOT_OPENED;

        m_bIsHide = !b;
        if(b)
            this->show();
        else
            this->hide();

        return 0;
}

int HSPScannerForm::State()
{
        return 0;
}

bool HSPScannerForm::GetVideoID(int iIndex, char* sGet)
{
    char sTemp[128];
    sprintf(sTemp, "/sys/class/video4linux/video%d/device/modalias", iIndex);
    FILE* fp = fopen(sTemp, "r");
    if(fp == nullptr) return false;

    int iLen = fread(sTemp, 1, 100, fp);
    sTemp[iLen] = 0;
    fclose(fp);
    strcpy(sGet, sTemp);

    return true;
}

int HSPScannerForm::GetCamIndex(const char* sIn)
{
        char sSys[128]; //usb:v04F2pB61E  d0425dcE  usb:v1B17p0509
        for(int ia = 0; ia < 10; ia++)
        {
            if(GetVideoID(ia, sSys) == false) return -1;
            if(memcmp(sIn, sSys, strlen(sIn)) == 0) return ia;
        }

        return -1;
}

/*
enum RotateFlags {
    ROTATE_90_CLOCKWISE = 0, //!<Rotate 90 degrees clockwise
    ROTATE_180 = 1, //!<Rotate 180 degrees clockwise
    ROTATE_90_COUNTERCLOCKWISE = 2, //!<Rotate 270 degrees clockwise
};
*/

#if defined(OpenCV31)
void rotate(cv::Mat src, cv::Mat& dst, int rotateCode) //
{
    double angle = 90.0;
    if(rotateCode == Enum_ROTATE_90_COUNTERCLOCKWISE)//从最初状态向左旋转90度，即顺时针方向旋转270度
        angle = 90.0;
    else if(rotateCode == Enum_ROTATE_180) //从最初状态向左或向右旋转180度
        angle = 180.0;
    else if(rotateCode == Enum_ROTATE_90_CLOCKWISE) //从最初状态向右旋转90度，即顺时针方向旋转90度
        angle = 270.0;

    cv::Size src_sz = src.size();
    cv::Size dst_sz(src_sz.width, src_sz.height);

    cv::Point center = cv::Point(src.cols / 2, src.rows / 2);//旋转中心
    cv::Mat rot_mat = cv::getRotationMatrix2D(center, angle, 1.0);//获得仿射变换矩阵

    cv::warpAffine(src, dst, rot_mat, dst_sz);
}
#endif