2023-11-06 07:49:28 +00:00
|
|
|
#include "dialog_exportimagefile.h"
|
2022-05-03 10:25:52 +00:00
|
|
|
#include "ui_dialog_exportimagefile.h"
|
2022-05-13 12:38:58 +00:00
|
|
|
#include "mainwindow.h"
|
2022-10-27 10:25:03 +00:00
|
|
|
#include "base/HGInfo.h"
|
2023-02-17 01:20:12 +00:00
|
|
|
#include "base/HGUtility.h"
|
2022-05-03 10:25:52 +00:00
|
|
|
#include "imgfmt/HGImgFmt.h"
|
2023-06-25 08:57:35 +00:00
|
|
|
#include "imgfmt/HGGif.h"
|
2022-08-23 15:35:53 +00:00
|
|
|
#include "imgproc/HGOCR.h"
|
2022-05-03 10:25:52 +00:00
|
|
|
#include "HGUIGlobal.h"
|
2022-05-18 03:39:16 +00:00
|
|
|
#include "HGString.h"
|
2022-06-13 08:04:19 +00:00
|
|
|
#include <QMessageBox>
|
2022-11-25 10:35:22 +00:00
|
|
|
#include <QFile>
|
2023-03-02 03:21:09 +00:00
|
|
|
#include "app_cfg.h"
|
2022-05-03 10:25:52 +00:00
|
|
|
|
|
|
|
Dialog_ExportImageFile::Dialog_ExportImageFile(const QString &destPath, const QString &destName, const QString &destExt,
|
2022-05-16 09:00:08 +00:00
|
|
|
bool isSaveAsMulti, int jpegQuality, int tiffCompressionBW, int tiffCompression, int tiffQuality, bool isOcr,
|
2023-06-19 06:52:49 +00:00
|
|
|
const QStringList &srcFiles, QWidget *parent)
|
2022-05-03 10:25:52 +00:00
|
|
|
: QDialog(parent)
|
|
|
|
, ui(new Ui::Dialog_ExportImageFile)
|
|
|
|
, m_destPath(destPath)
|
|
|
|
, m_destName(destName)
|
|
|
|
, m_destExt(destExt)
|
|
|
|
, m_isSaveAsMulti(isSaveAsMulti)
|
2022-05-13 12:38:58 +00:00
|
|
|
, m_jpegQuality(jpegQuality)
|
|
|
|
, m_tiffCompressionBW(tiffCompressionBW)
|
|
|
|
, m_tiffCompression(tiffCompression)
|
|
|
|
, m_tiffQuality(tiffQuality)
|
2022-05-16 09:00:08 +00:00
|
|
|
, m_isOcr(isOcr)
|
2022-05-03 10:25:52 +00:00
|
|
|
, 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);
|
2022-11-24 10:14:56 +00:00
|
|
|
connect(this, SIGNAL(finish(int)), this, SLOT(on_finish(int)), Qt::QueuedConnection);
|
2022-05-03 10:25:52 +00:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2022-10-12 03:51:41 +00:00
|
|
|
void HGAPI Dialog_ExportImageFile::ThreadFunc(HGThread thread, HGPointer param)
|
2022-05-03 10:25:52 +00:00
|
|
|
{
|
|
|
|
(void)thread;
|
|
|
|
Dialog_ExportImageFile *p = (Dialog_ExportImageFile *)param;
|
2022-11-24 09:02:26 +00:00
|
|
|
HGResult ret = HGBASE_ERR_FAIL;
|
2022-05-03 10:25:52 +00:00
|
|
|
|
|
|
|
if (p->m_isSaveAsMulti)
|
|
|
|
{
|
|
|
|
QString fileName = p->m_destPath + p->m_destName + p->m_destExt;
|
|
|
|
|
2022-08-23 15:35:53 +00:00
|
|
|
if (p->m_isOcr)
|
2022-05-03 10:25:52 +00:00
|
|
|
{
|
2023-03-03 04:00:14 +00:00
|
|
|
#if 0
|
2023-02-17 01:20:12 +00:00
|
|
|
|
|
|
|
HGChar tmpFileName[256];
|
|
|
|
HGBase_GetTmpFileName("tif", tmpFileName, 256);
|
|
|
|
|
|
|
|
HGImgFmtWriter writer = NULL;
|
|
|
|
HGImgFmt_OpenImageWriter(tmpFileName, 0, &writer);
|
|
|
|
|
|
|
|
for (int i = 0; i < p->m_srcFiles.size(); ++i)
|
|
|
|
{
|
|
|
|
if (p->m_stopThread)
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
emit p->updateProgress(i);
|
|
|
|
|
|
|
|
HGImgFmtReader imgFmtReader = nullptr;
|
|
|
|
ret = HGImgFmt_OpenImageReader(getStdString(p->m_srcFiles[i]).c_str(), 0, &imgFmtReader);
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
{
|
|
|
|
HGUInt count = 0;
|
|
|
|
HGImgFmt_GetImagePageCount(imgFmtReader, &count);
|
|
|
|
for (HGUInt j = 0; j < count; ++j)
|
|
|
|
{
|
|
|
|
if (p->m_stopThread)
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
HGImage img = nullptr;
|
|
|
|
ret = HGImgFmt_LoadImageFromReader(imgFmtReader, j, nullptr, 0, HGBASE_IMGORIGIN_TOP, &img);
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
{
|
|
|
|
ret = HGImgFmt_SaveImageToWriter(writer, img, NULL);
|
|
|
|
HGBase_DestroyImage(img);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret != HGBASE_ERR_OK)
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
HGImgFmt_CloseImageReader(imgFmtReader);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret != HGBASE_ERR_OK)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
HGImgFmt_CloseImageWriter(writer);
|
|
|
|
|
2023-03-02 07:43:58 +00:00
|
|
|
bool result = createOcrPdf(tmpFileName, getStdString(fileName).c_str(), m_ocrLanguageType);
|
2023-02-17 01:20:12 +00:00
|
|
|
QFile::remove(tmpFileName);
|
2023-02-17 03:05:49 +00:00
|
|
|
if (!result)
|
|
|
|
{
|
|
|
|
ret = HGIMGPROC_ERR_OCR;
|
|
|
|
}
|
2023-02-17 01:20:12 +00:00
|
|
|
#else
|
2022-08-23 15:35:53 +00:00
|
|
|
HGOCRMgr ocrMgr = nullptr;
|
2022-11-24 09:02:26 +00:00
|
|
|
ret = HGImgProc_CreateOCRMgr(0, &ocrMgr);
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
2022-05-03 10:25:52 +00:00
|
|
|
{
|
2022-08-23 15:35:53 +00:00
|
|
|
for (int i = 0; i < p->m_srcFiles.size(); ++i)
|
2022-05-03 10:25:52 +00:00
|
|
|
{
|
2022-08-23 15:35:53 +00:00
|
|
|
if (p->m_stopThread)
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
2022-05-03 10:25:52 +00:00
|
|
|
|
2022-08-23 15:35:53 +00:00
|
|
|
emit p->updateProgress(i);
|
2022-05-03 10:25:52 +00:00
|
|
|
|
2022-08-23 15:35:53 +00:00
|
|
|
HGImgFmtReader imgFmtReader = nullptr;
|
2022-11-25 10:35:22 +00:00
|
|
|
ret = HGImgFmt_OpenImageReader(getStdString(p->m_srcFiles[i]).c_str(), 0, &imgFmtReader);
|
2022-11-26 03:06:18 +00:00
|
|
|
if (HGBASE_ERR_OK == ret)
|
2022-05-03 10:25:52 +00:00
|
|
|
{
|
2022-08-23 15:35:53 +00:00
|
|
|
HGUInt count = 0;
|
|
|
|
HGImgFmt_GetImagePageCount(imgFmtReader, &count);
|
|
|
|
for (HGUInt j = 0; j < count; ++j)
|
2022-05-03 10:25:52 +00:00
|
|
|
{
|
2022-08-23 15:35:53 +00:00
|
|
|
if (p->m_stopThread)
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
HGImage img = nullptr;
|
2022-11-25 10:35:22 +00:00
|
|
|
ret = HGImgFmt_LoadImageFromReader(imgFmtReader, j, nullptr, 0, HGBASE_IMGORIGIN_TOP, &img);
|
2022-11-26 03:06:18 +00:00
|
|
|
if (HGBASE_ERR_OK == ret)
|
2022-08-23 15:35:53 +00:00
|
|
|
{
|
2022-11-24 09:02:26 +00:00
|
|
|
ret = HGImgProc_AddToImageOCRList(ocrMgr, img);
|
2022-08-23 15:35:53 +00:00
|
|
|
HGBase_DestroyImage(img);
|
2022-11-26 03:06:18 +00:00
|
|
|
}
|
2022-11-24 09:02:26 +00:00
|
|
|
|
2022-11-26 03:06:18 +00:00
|
|
|
if (ret != HGBASE_ERR_OK)
|
|
|
|
{
|
|
|
|
break;
|
2022-08-23 15:35:53 +00:00
|
|
|
}
|
2022-05-03 10:25:52 +00:00
|
|
|
}
|
|
|
|
|
2022-08-23 15:35:53 +00:00
|
|
|
HGImgFmt_CloseImageReader(imgFmtReader);
|
|
|
|
}
|
2022-11-24 09:02:26 +00:00
|
|
|
|
|
|
|
if (ret != HGBASE_ERR_OK)
|
|
|
|
break;
|
2022-08-23 15:35:53 +00:00
|
|
|
}
|
|
|
|
|
2022-11-24 09:02:26 +00:00
|
|
|
if (ret == HGBASE_ERR_OK)
|
2022-10-27 10:25:03 +00:00
|
|
|
{
|
2022-11-24 09:02:26 +00:00
|
|
|
ret = HGImgProc_ImageListOCRToFile(ocrMgr, 0, getStdString(fileName).c_str(), NULL, NULL);
|
2022-10-27 10:25:03 +00:00
|
|
|
}
|
2022-11-24 09:02:26 +00:00
|
|
|
|
2022-08-23 15:35:53 +00:00
|
|
|
HGImgProc_DestroyOCRMgr(ocrMgr);
|
|
|
|
}
|
2023-02-17 01:20:12 +00:00
|
|
|
#endif
|
2022-08-23 15:35:53 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2023-06-25 08:57:35 +00:00
|
|
|
if (p->m_destExt == ".gif")
|
2022-08-23 15:35:53 +00:00
|
|
|
{
|
2023-06-25 08:57:35 +00:00
|
|
|
ret = p->processGif(fileName);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
HGImgFmtWriter imgFmtWriter = nullptr;
|
|
|
|
ret = HGImgFmt_OpenImageWriter(getStdString(fileName).c_str(), 0, &imgFmtWriter);
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
2022-08-23 15:35:53 +00:00
|
|
|
{
|
2023-06-25 08:57:35 +00:00
|
|
|
for (int i = 0; i < p->m_srcFiles.size(); ++i)
|
2022-08-23 15:35:53 +00:00
|
|
|
{
|
2023-06-25 08:57:35 +00:00
|
|
|
if (p->m_stopThread)
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
2022-08-23 15:35:53 +00:00
|
|
|
|
2023-06-25 08:57:35 +00:00
|
|
|
emit p->updateProgress(i);
|
2022-08-23 15:35:53 +00:00
|
|
|
|
2023-06-25 08:57:35 +00:00
|
|
|
HGImgFmtReader imgFmtReader = nullptr;
|
|
|
|
ret = HGImgFmt_OpenImageReader(getStdString(p->m_srcFiles[i]).c_str(), 0, &imgFmtReader);
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
2022-05-03 10:25:52 +00:00
|
|
|
{
|
2023-06-25 08:57:35 +00:00
|
|
|
HGUInt count = 0;
|
|
|
|
HGImgFmt_GetImagePageCount(imgFmtReader, &count);
|
|
|
|
for (HGUInt j = 0; j < count; ++j)
|
2022-05-27 04:14:39 +00:00
|
|
|
{
|
2023-06-25 08:57:35 +00:00
|
|
|
if (p->m_stopThread)
|
2022-08-23 15:35:53 +00:00
|
|
|
{
|
2023-06-25 08:57:35 +00:00
|
|
|
break;
|
2022-08-23 15:35:53 +00:00
|
|
|
}
|
2023-06-25 08:57:35 +00:00
|
|
|
|
|
|
|
HGImage img = nullptr;
|
|
|
|
ret = HGImgFmt_LoadImageFromReader(imgFmtReader, j, nullptr, 0, HGBASE_IMGORIGIN_TOP, &img);
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
2022-08-23 15:35:53 +00:00
|
|
|
{
|
2023-06-25 08:57:35 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = HGImgFmt_SaveImageToWriter(imgFmtWriter, img, &saveInfo);
|
|
|
|
|
|
|
|
HGBase_DestroyImage(img);
|
2022-08-23 15:35:53 +00:00
|
|
|
}
|
|
|
|
|
2023-06-25 08:57:35 +00:00
|
|
|
if (ret != HGBASE_ERR_OK)
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
2022-11-26 03:06:18 +00:00
|
|
|
}
|
2022-11-24 09:02:26 +00:00
|
|
|
|
2023-06-25 08:57:35 +00:00
|
|
|
HGImgFmt_CloseImageReader(imgFmtReader);
|
2022-05-03 10:25:52 +00:00
|
|
|
}
|
|
|
|
|
2023-06-25 08:57:35 +00:00
|
|
|
if (ret != HGBASE_ERR_OK)
|
|
|
|
break;
|
2022-08-23 15:35:53 +00:00
|
|
|
}
|
2022-11-24 09:02:26 +00:00
|
|
|
|
2023-06-25 08:57:35 +00:00
|
|
|
HGImgFmt_CloseImageWriter(imgFmtWriter);
|
2022-05-03 10:25:52 +00:00
|
|
|
}
|
2022-08-23 15:35:53 +00:00
|
|
|
}
|
2022-05-03 10:25:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
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;
|
2022-11-25 10:35:22 +00:00
|
|
|
ret = HGImgFmt_OpenImageReader(getStdString(p->m_srcFiles[i]).c_str(), 0, &imgFmtReader);
|
2022-11-26 03:06:18 +00:00
|
|
|
if (HGBASE_ERR_OK == ret)
|
2022-05-03 10:25:52 +00:00
|
|
|
{
|
|
|
|
HGUInt count = 0;
|
|
|
|
HGImgFmt_GetImagePageCount(imgFmtReader, &count);
|
|
|
|
for (HGUInt j = 0; j < count; ++j)
|
|
|
|
{
|
|
|
|
if (p->m_stopThread)
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
HGImage img = nullptr;
|
2022-11-25 10:35:22 +00:00
|
|
|
ret = HGImgFmt_LoadImageFromReader(imgFmtReader, j, nullptr, 0, HGBASE_IMGORIGIN_TOP, &img);
|
2022-11-26 03:06:18 +00:00
|
|
|
if (HGBASE_ERR_OK == ret)
|
2022-05-03 10:25:52 +00:00
|
|
|
{
|
|
|
|
char fileName[512];
|
2023-11-06 07:49:28 +00:00
|
|
|
if(p->m_srcFiles.size() > 1 || count > 1)
|
2022-06-06 03:58:49 +00:00
|
|
|
{
|
|
|
|
sprintf(fileName, "%s%03d", getStdString(p->m_destName).c_str(), index);
|
|
|
|
}else
|
|
|
|
sprintf(fileName, "%s", getStdString(p->m_destName).c_str());
|
|
|
|
|
2022-05-03 10:25:52 +00:00
|
|
|
++index;
|
|
|
|
|
|
|
|
QString saveFileName = p->m_destPath + QString(StdStringToUtf8(fileName).c_str()) + p->m_destExt;
|
|
|
|
|
2022-05-13 12:38:58 +00:00
|
|
|
HGImgFmtSaveInfo saveInfo;
|
|
|
|
saveInfo.jpegQuality = (HGUInt)p->m_jpegQuality;
|
|
|
|
saveInfo.tiffCompression = HGIMGFMT_TIFFCOMP_NONE;
|
|
|
|
saveInfo.tiffJpegQuality = (HGUInt)p->m_tiffQuality;
|
2022-05-27 04:14:39 +00:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2023-06-19 06:52:49 +00:00
|
|
|
ret = MainWindow::saveImage(img, &saveInfo, p->m_isOcr, getStdString(saveFileName).c_str());
|
2022-05-03 10:25:52 +00:00
|
|
|
HGBase_DestroyImage(img);
|
|
|
|
}
|
2022-11-26 03:06:18 +00:00
|
|
|
|
|
|
|
if (ret != HGBASE_ERR_OK)
|
|
|
|
break;
|
2022-05-03 10:25:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
HGImgFmt_CloseImageReader(imgFmtReader);
|
|
|
|
}
|
2022-11-26 03:06:18 +00:00
|
|
|
|
|
|
|
if (ret != HGBASE_ERR_OK)
|
|
|
|
break;
|
2022-05-03 10:25:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-11-24 10:14:56 +00:00
|
|
|
emit p->finish((int)ret);
|
2022-05-03 10:25:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Dialog_ExportImageFile::on_updateProgress(int value)
|
|
|
|
{
|
|
|
|
ui->progressBar->setValue(value);
|
|
|
|
}
|
|
|
|
|
2022-11-24 10:14:56 +00:00
|
|
|
void Dialog_ExportImageFile::on_finish(int ret)
|
2022-05-03 10:25:52 +00:00
|
|
|
{
|
2022-11-24 09:40:18 +00:00
|
|
|
QString str = (ret == HGBASE_ERR_OK) ? tr("export succeed") : tr("export failed: ") + MainWindow::getLogInfo(ret);
|
2022-11-24 09:02:26 +00:00
|
|
|
QMessageBox msg(QMessageBox::Information, tr("tip"), str, QMessageBox::Ok, this);
|
|
|
|
close();
|
2022-11-24 10:27:43 +00:00
|
|
|
msg.exec();
|
2022-05-03 10:25:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Dialog_ExportImageFile::on_pushButton_clicked()
|
|
|
|
{
|
|
|
|
m_stopThread = true;
|
|
|
|
HGBase_CloseThread(m_thread);
|
|
|
|
m_thread = nullptr;
|
|
|
|
}
|
|
|
|
|
2023-06-25 08:57:35 +00:00
|
|
|
HGResult Dialog_ExportImageFile::processGif(const QString &fileName)
|
|
|
|
{
|
|
|
|
HGUInt maxWidth = 0;
|
|
|
|
HGUInt maxHeight = 0;
|
|
|
|
for (int i = 0; i < m_srcFiles.size(); ++i)
|
|
|
|
{
|
|
|
|
HGImgFmtReader imgFmtReader = nullptr;
|
|
|
|
HGImgFmt_OpenImageReader(getStdString(m_srcFiles[i]).c_str(), 0, &imgFmtReader);
|
|
|
|
if (nullptr != imgFmtReader)
|
|
|
|
{
|
|
|
|
HGUInt count = 0;
|
|
|
|
HGImgFmt_GetImagePageCount(imgFmtReader, &count);
|
|
|
|
for (HGUInt j = 0; j < count; ++j)
|
|
|
|
{
|
|
|
|
HGImgFmtLoadInfo info = {0};
|
|
|
|
HGImgFmt_LoadImageFromReader(imgFmtReader, j, &info, 0, 0, NULL);
|
|
|
|
if (info.width > maxWidth)
|
|
|
|
maxWidth = info.width;
|
|
|
|
if (info.height > maxHeight)
|
|
|
|
maxHeight = info.height;
|
|
|
|
}
|
|
|
|
|
|
|
|
HGImgFmt_CloseImageReader(imgFmtReader);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
HGGifSaveInfo gifSaveInfo = {maxWidth, maxHeight};
|
|
|
|
|
|
|
|
HGGifWriter gifWriter = NULL;
|
|
|
|
HGResult ret = HGImgFmt_OpenGifWriter(getStdString(fileName).c_str(), &gifSaveInfo, &gifWriter);
|
|
|
|
if (ret != HGBASE_ERR_OK)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
for (int i = 0; i < m_srcFiles.size(); ++i)
|
|
|
|
{
|
|
|
|
if (m_stopThread)
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
emit updateProgress(i);
|
|
|
|
|
|
|
|
HGImgFmtReader imgFmtReader = nullptr;
|
|
|
|
ret = HGImgFmt_OpenImageReader(getStdString(m_srcFiles[i]).c_str(), 0, &imgFmtReader);
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
{
|
|
|
|
HGUInt count = 0;
|
|
|
|
HGImgFmt_GetImagePageCount(imgFmtReader, &count);
|
|
|
|
for (HGUInt j = 0; j < count; ++j)
|
|
|
|
{
|
|
|
|
if (m_stopThread)
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
HGImage img = nullptr;
|
|
|
|
ret = HGImgFmt_LoadImageFromReader(imgFmtReader, j, nullptr, 0, HGBASE_IMGORIGIN_TOP, &img);
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
{
|
|
|
|
ret = HGImgFmt_SaveImageToGifWriter(gifWriter, 200, HG_MAKECOLOR(255, 255, 255, 255), img);
|
|
|
|
|
|
|
|
HGBase_DestroyImage(img);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret != HGBASE_ERR_OK)
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
HGImgFmt_CloseImageReader(imgFmtReader);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret != HGBASE_ERR_OK)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
HGImgFmt_CloseGifWriter(gifWriter);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2022-05-03 10:25:52 +00:00
|
|
|
void Dialog_ExportImageFile::closeEvent(QCloseEvent *e)
|
|
|
|
{
|
|
|
|
(void)e;
|
|
|
|
m_stopThread = true;
|
|
|
|
HGBase_CloseThread(m_thread);
|
|
|
|
m_thread = nullptr;
|
|
|
|
}
|