myvtm/DevAdapter/cw/hspscanner.1.1/hspscannerform.cpp

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

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(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] = 2560;
    m_iCamAll[1] = 1440;
}

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

void    HSPScannerForm::SetPos(int iX, int iY, int iW, int iH)
{
    this->move(iX, iY);
    ui->labViewPos->move(0, 0);
    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[4], float dID[4], int iAll[2])
{
    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)
{
    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();
}

#include "cmb.h"
void HSPScannerForm::onCamTimer()
{
    cv::Mat mMat1, mMat2;

    LOG4VTM(WARN, "Read Start!");
    m_cvCamera.read(mMat1);
    LOG4VTM(WARN, "Read End!");
    cv::Size size = mMat1.size();
    if (mMat1.empty())
    {
        m_cvCamera.release();
        m_ViewTimer->stop();
        m_bIsView = false;
    }
    if (m_bIsGrey)
        cv::cvtColor(mMat1, mMat2, cv::COLOR_RGB2GRAY);
    else
        mMat2 = mMat1;

    if (m_iScanSz == 0)
    {
        mMat1 = mMat2;
        m_Capture = mMat1;
    }
    if (m_iScanSz == 1)
    {
        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])));
        mMat1  = cv::Mat(cv::Size(rA4.width, rA4.height), mMat2.type());
        mMat2(rA4).convertTo(mMat1, mMat1.type(), 1, 0);
        m_Capture = mMat1;
    }
    if (m_iScanSz == 2)
    {
        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_Capture  = cv::Mat(cv::Size(rID.width, rID.height), mMat2.type());
        mMat2(rID).convertTo(m_Capture, m_Capture.type(), 1, 0);
        mMat1 = mMat2;
        rectangle(mMat1, rID, cv::Scalar(0,255,0));
    }
//*
    if (m_iRotate == 0)
        mMat2 = mMat1;
    if (m_iRotate == 1)
        cv::flip(mMat1.t(), mMat2, 1);
    if (m_iRotate == 2)
        cv::flip(mMat1.t(), mMat2, -1);
    if (m_iRotate == 3)
        cv::flip(mMat1.t(), mMat2, 0);
//        cv::rotate(mMat1, mMat2, 0);
/*/
    mMat2 = mMat1;
//*/
    if (this->isHidden()) return;
    QImage  image = Mat2QImage(mMat2);
    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)
{
    if (!m_cvCamera.isOpened()) return ERR_NOT_OPENED;
    if (m_Capture.empty())  return ERR_VIEW_FAIL;

    if (cv::imwrite(sFile, m_Capture)) return 0;
    return ERR_VIEW_FAIL;
}

int HSPScannerForm::Open(const char* sID)
{
    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;
        return 0;
    }
    m_bIsOpen = false;
    return ERR_OPEN_FAIL;
}

int HSPScannerForm::Close()
{
    if (isVisible())    hide();
    if (m_cvCamera.isOpened())
        m_cvCamera.release();
    m_bIsOpen = false;
    return 0;
}

int     HSPScannerForm::Preview(bool b)
{
    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);
        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 == NULL) 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
    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;
}