code_app/app/scanner/dialog_exportimagefile.cpp

#include "dialog_exportimagefile.h"
#include "ui_dialog_exportimagefile.h"
#include "mainwindow.h"
#include "base/HGInfo.h"
#include "imgfmt/HGImgFmt.h"
#include "imgproc/HGOCR.h"
#include "HGUIGlobal.h"
#include "HGString.h"
#include <QMessageBox>

Dialog_ExportImageFile::Dialog_ExportImageFile(const QString &destPath, const QString &destName, const QString &destExt,
    bool isSaveAsMulti, int jpegQuality, int tiffCompressionBW, int tiffCompression, int tiffQuality, bool isOcr,
    const QStringList &srcFiles, QWidget *parent)
    : QDialog(parent)
    , ui(new Ui::Dialog_ExportImageFile)
    , m_destPath(destPath)
    , m_destName(destName)
    , m_destExt(destExt)
    , m_isSaveAsMulti(isSaveAsMulti)
    , m_jpegQuality(jpegQuality)
    , m_tiffCompressionBW(tiffCompressionBW)
    , m_tiffCompression(tiffCompression)
    , m_tiffQuality(tiffQuality)
    , m_isOcr(isOcr)
    , m_srcFiles(srcFiles)
{
    ui->setupUi(this);

    ui->progressBar->setMinimum(0);
    ui->progressBar->setMaximum(srcFiles.size());
    ui->progressBar->setValue(0);

    connect(this, SIGNAL(updateProgress(int)), this, SLOT(on_updateProgress(int)), Qt::QueuedConnection);
    connect(this, SIGNAL(finish()), this, SLOT(on_finish()), Qt::QueuedConnection);

    m_stopThread = false;
    HGBase_OpenThread(ThreadFunc, this, &m_thread);
}

Dialog_ExportImageFile::~Dialog_ExportImageFile()
{
    if (nullptr != m_thread)
    {
        HGBase_CloseThread(m_thread);
        m_thread = nullptr;
    }

    delete ui;
}

void HGAPI Dialog_ExportImageFile::ThreadFunc(HGThread thread, HGPointer param)
{
    (void)thread;
    Dialog_ExportImageFile *p = (Dialog_ExportImageFile *)param;

    if (p->m_isSaveAsMulti)
    {
        QString fileName = p->m_destPath + p->m_destName + p->m_destExt;

        if (p->m_isOcr)
        {
            HGOCRMgr ocrMgr = nullptr;
            HGImgProc_CreateOCRMgr(0, &ocrMgr);
            if (nullptr != ocrMgr)
            {
                for (int i = 0; i < p->m_srcFiles.size(); ++i)
                {
                    if (p->m_stopThread)
                    {
                        break;
                    }

                    emit p->updateProgress(i);

                    HGImgFmtReader imgFmtReader = nullptr;
                    HGImgFmt_OpenImageReader(getStdString(p->m_srcFiles[i]).c_str(), 0, &imgFmtReader);
                    if (nullptr != imgFmtReader)
                    {
                        HGUInt count = 0;
                        HGImgFmt_GetImagePageCount(imgFmtReader, &count);
                        for (HGUInt j = 0; j < count; ++j)
                        {
                            if (p->m_stopThread)
                            {
                                break;
                            }

                            HGImage img = nullptr;
                            HGImgFmt_LoadImageFromReader(imgFmtReader, j, nullptr, 0, HGBASE_IMGORIGIN_TOP, &img);
                            if (nullptr != img)
                            {
                                HGImgProc_AddToImageOCRList(ocrMgr, img);
                                HGBase_DestroyImage(img);
                            }
                        }

                        HGImgFmt_CloseImageReader(imgFmtReader);
                    }
                }

                HGResult ret = HGImgProc_ImageListOCRToFile(ocrMgr, 0, getStdString(fileName).c_str(), NULL, NULL);
                if(ret != HGBASE_ERR_OK)
                {
                    HGBase_WriteInfo(HGBASE_INFOTYPE_ERROR, "HGImgProc_ImageListOCRToFile:%u", ret);
                }
                HGImgProc_DestroyOCRMgr(ocrMgr);
            }
        }
        else
        {
            HGImgFmtWriter imgFmtWriter = nullptr;
            HGImgFmt_OpenImageWriter(getStdString(fileName).c_str(), 0, &imgFmtWriter);
            if (nullptr != imgFmtWriter)
            {
                for (int i = 0; i < p->m_srcFiles.size(); ++i)
                {
                    if (p->m_stopThread)
                    {
                        break;
                    }

                    emit p->updateProgress(i);

                    HGImgFmtReader imgFmtReader = nullptr;
                    HGImgFmt_OpenImageReader(getStdString(p->m_srcFiles[i]).c_str(), 0, &imgFmtReader);
                    if (nullptr != imgFmtReader)
                    {
                        HGUInt count = 0;
                        HGImgFmt_GetImagePageCount(imgFmtReader, &count);
                        for (HGUInt j = 0; j < count; ++j)
                        {
                            if (p->m_stopThread)
                            {
                                break;
                            }

                            HGImage img = nullptr;
                            HGImgFmt_LoadImageFromReader(imgFmtReader, j, nullptr, 0, HGBASE_IMGORIGIN_TOP, &img);
                            if (nullptr != img)
                            {
                                HGImgFmtSaveInfo saveInfo;
                                saveInfo.jpegQuality = (HGUInt)p->m_jpegQuality;
                                saveInfo.tiffCompression = HGIMGFMT_TIFFCOMP_NONE;
                                saveInfo.tiffJpegQuality = (HGUInt)p->m_tiffQuality;

                                HGImageInfo imgInfo;
                                HGBase_GetImageInfo(img, &imgInfo);
                                if (HGBASE_IMGTYPE_BINARY == imgInfo.type)
                                {
                                    if (1 == p->m_tiffCompressionBW)
                                        saveInfo.tiffCompression = HGIMGFMT_TIFFCOMP_LZW;
                                    else if (2 == p->m_tiffCompressionBW)
                                        saveInfo.tiffCompression = HGIMGFMT_TIFFCOMP_CCITTFAX4;
                                }
                                else
                                {
                                    if (1 == p->m_tiffCompression)
                                        saveInfo.tiffCompression = HGIMGFMT_TIFFCOMP_LZW;
                                    else if (2 == p->m_tiffCompression)
                                        saveInfo.tiffCompression = HGIMGFMT_TIFFCOMP_JPEG;
                                }

                                HGImgFmt_SaveImageToWriter(imgFmtWriter, img, &saveInfo);
                                HGBase_DestroyImage(img);
                            }
                        }

                        HGImgFmt_CloseImageReader(imgFmtReader);
                    }
                }

                HGImgFmt_CloseImageWriter(imgFmtWriter);
            }
        }
    }
    else
    {
        int index = 1;

        for (int i = 0; i < p->m_srcFiles.size(); ++i)
        {
            if (p->m_stopThread)
            {
                break;
            }

            emit p->updateProgress(i);

            HGImgFmtReader imgFmtReader = nullptr;
            HGImgFmt_OpenImageReader(getStdString(p->m_srcFiles[i]).c_str(), 0, &imgFmtReader);
            if (nullptr != imgFmtReader)
            {
                HGUInt count = 0;
                HGImgFmt_GetImagePageCount(imgFmtReader, &count);
                for (HGUInt j = 0; j < count; ++j)
                {
                    if (p->m_stopThread)
                    {
                        break;
                    }

                    HGImage img = nullptr;
                    HGImgFmt_LoadImageFromReader(imgFmtReader, j, nullptr, 0, HGBASE_IMGORIGIN_TOP, &img);
                    if (nullptr != img)
                    {
                        char fileName[512];
                        if(p->m_srcFiles.size() > 1)
                        {
                            sprintf(fileName, "%s%03d", getStdString(p->m_destName).c_str(), index);
                        }else
                            sprintf(fileName, "%s", getStdString(p->m_destName).c_str());

                        ++index;

                        QString saveFileName = p->m_destPath + QString(StdStringToUtf8(fileName).c_str()) + p->m_destExt;

                        HGImgFmtSaveInfo saveInfo;
                        saveInfo.jpegQuality = (HGUInt)p->m_jpegQuality;
                        saveInfo.tiffCompression = HGIMGFMT_TIFFCOMP_NONE;
                        saveInfo.tiffJpegQuality = (HGUInt)p->m_tiffQuality;

                        HGImageInfo imgInfo;
                        HGBase_GetImageInfo(img, &imgInfo);
                        if (HGBASE_IMGTYPE_BINARY == imgInfo.type)
                        {
                            if (1 == p->m_tiffCompressionBW)
                                saveInfo.tiffCompression = HGIMGFMT_TIFFCOMP_LZW;
                            else if (2 == p->m_tiffCompressionBW)
                                saveInfo.tiffCompression = HGIMGFMT_TIFFCOMP_CCITTFAX4;
                        }
                        else
                        {
                            if (1 == p->m_tiffCompression)
                                saveInfo.tiffCompression = HGIMGFMT_TIFFCOMP_LZW;
                            else if (2 == p->m_tiffCompression)
                                saveInfo.tiffCompression = HGIMGFMT_TIFFCOMP_JPEG;
                        }

                        MainWindow::saveImage(img, &saveInfo, p->m_isOcr, getStdString(saveFileName).c_str());
                        HGBase_DestroyImage(img);
                    }
                }

                HGImgFmt_CloseImageReader(imgFmtReader);
            }
        }
    }

    emit p->finish();
}

void Dialog_ExportImageFile::on_updateProgress(int value)
{
    ui->progressBar->setValue(value);
}

void Dialog_ExportImageFile::on_finish()
{
    QMessageBox msg(QMessageBox::Information, tr("tip"), tr("export succeed"), QMessageBox::Ok, this);
    msg.setButtonText(QMessageBox::Ok, tr("ok"));
    close();
    msg.exec();
}

void Dialog_ExportImageFile::on_pushButton_clicked()
{
    m_stopThread = true;
    HGBase_CloseThread(m_thread);
    m_thread = nullptr;
}

void Dialog_ExportImageFile::closeEvent(QCloseEvent *e)
{
    (void)e;
    m_stopThread = true;
    HGBase_CloseThread(m_thread);
    m_thread = nullptr;
}