File indexing completed on 2024-04-28 11:20:48

 /*
     SPDX-License-Identifier: GPL-2.0-or-later
     SPDX-FileCopyrightText: 2012 Martin Kuettler <martin.kuettler@gmail.com>
 */
 
 #include "renderer.h"
 
 #include <QUuid>
 #include <QDebug>
 #include <QMutex>
 
 #include <config-cantorlib.h>
 
 #include <poppler-qt5.h>
 #ifdef LIBSPECTRE_FOUND
   #include "libspectre/spectre.h"
 #endif
 
 
 using namespace Cantor;
 
 // We need this, because poppler-qt5 not threadsafe before 0.73.0 and 0.73.0 is too new
 // and not common widespread in repositories
 static QMutex popplerMutex;
 
 class Cantor::RendererPrivate{
   public:
     double scale{1};
     bool useHighRes{false};
 };
 
 Renderer::Renderer() : d(new RendererPrivate())
 {
 }
 
 Renderer::~Renderer()
 {
     delete d;
 }
 
 void Renderer::setScale(qreal scale)
 {
     d->scale = scale;
 }
 
 qreal Renderer::scale()
 {
     return d->scale;
 }
 
 void Renderer::useHighResolution(bool b)
 {
     d->useHighRes = b;
 }
 
 QTextImageFormat Renderer::render(QTextDocument *document, Method method, const QUrl &url, const QString& uuid)
 {
     QTextImageFormat format;
 
     QUrl internal;
     internal.setScheme(QLatin1String("internal"));
     internal.setPath(uuid);
 
     QSizeF s = renderToResource(document, method, url, internal);
 
     if(s.isValid())
     {
         format.setName(internal.url());
         format.setWidth(s.width());
         format.setHeight(s.height());
     }
 
     return format;
 }
 
 QTextImageFormat Renderer::render(QTextDocument *document, const Cantor::LatexRenderer* latex)
 {
     QTextImageFormat format = render(document, Method::EPS, QUrl::fromLocalFile(latex->imagePath()), latex->uuid());
 
     if (!format.name().isEmpty()) {
         format.setProperty(CantorFormula, latex->method());
         format.setProperty(ImagePath, latex->imagePath());
         format.setProperty(Code, latex->latexCode());
     }
 
     return format;
 }
 
 QSizeF Renderer::renderToResource(QTextDocument *document, Method method, const QUrl &url, const QUrl& internal)
 {
     QSizeF size;
     QImage img = renderToImage(url, method, &size);
 
     qDebug() << internal;
     document->addResource(QTextDocument::ImageResource, internal, QVariant(img) );
     return size;
 }
 
 QImage Renderer::epsRenderToImage(const QUrl& url, double scale, bool useHighRes, QSizeF* size, QString* errorReason)
 {
 #ifdef LIBSPECTRE_FOUND
     SpectreDocument* doc = spectre_document_new();
     SpectreRenderContext* rc = spectre_render_context_new();
 
     qDebug() << "rendering eps file: " << url;
     QByteArray local_file = url.toLocalFile().toUtf8();
     spectre_document_load(doc, local_file.data());
 
     bool isEps = spectre_document_is_eps(doc);
     if (!isEps)
     {
         if (errorReason)
             *errorReason = QString::fromLatin1("Error: spectre document is not eps! It means, that url is invalid");
         return QImage();
     }
 
     int wdoc, hdoc;
     qreal w, h;
     double realScale;
     spectre_document_get_page_size(doc, &wdoc, &hdoc);
     if(useHighRes) {
         realScale = 1.2*4.0; //1.2 scaling factor, to make it look nice, 4x for high resolution
         w = 1.2 * wdoc;
         h = 1.2 * hdoc;
     } else {
         realScale=1.8*scale;
         w = 1.8 * wdoc;
         h = 1.8 * hdoc;
     }
 
     qDebug()<<"scale: "<<realScale;
 
     qDebug()<<"dimension: "<<w<<"x"<<h;
     unsigned char* data;
     int rowLength;
 
     spectre_render_context_set_scale(rc, realScale, realScale);
     spectre_document_render_full( doc, rc, &data, &rowLength);
 
     QImage img(data, wdoc*realScale, hdoc*realScale, rowLength, QImage::Format_RGB32);
     spectre_document_free(doc);
     spectre_render_context_free(rc);
     img = img.convertToFormat(QImage::Format_ARGB32);
 
     if (size)
         *size = QSizeF(w,h);
     return img;
 #else
     if (errorReason)
         *errorReason = QString::fromLatin1("Render Eps on Cantor without eps support (libspectre)!");
 
     Q_UNUSED(url);
     Q_UNUSED(scale);
     Q_UNUSED(useHighRes);
     Q_UNUSED(size);
     return QImage();
 #endif
 }
 
 QImage Renderer::pdfRenderToImage(const QUrl& url, double scale, bool highResolution, QSizeF* size, QString* errorReason)
 {
     popplerMutex.lock();
     Poppler::Document* document = Poppler::Document::load(url.toLocalFile());
     popplerMutex.unlock();
     if (document == nullptr)
     {
         if (errorReason)
             *errorReason = QString::fromLatin1("Poppler library have failed to open file % as pdf").arg(url.toLocalFile());
         return QImage();
     }
 
     Poppler::Page* pdfPage = document->page(0);
     if (pdfPage == nullptr) {
         if (errorReason)
             *errorReason = QString::fromLatin1("Poppler library failed to access first page of %1 document").arg(url.toLocalFile());
 
         delete document;
         return QImage();
     }
 
     QSize pageSize = pdfPage->pageSize();
 
     double realScale = 1.7 * 1.8;
     qreal w = 1.7 * pageSize.width();
     qreal h = 1.7 * pageSize.height();
     if(highResolution)
         realScale *= 5;
     else
         realScale *= scale;
 
 
     QImage image = pdfPage->renderToImage(72.0*realScale, 72.0*realScale);
 
     delete pdfPage;
     popplerMutex.lock();
     delete document;
     popplerMutex.unlock();
 
     if (image.isNull())
     {
         if (errorReason)
             *errorReason = QString::fromLatin1("Poppler library failed to render pdf %1 to image").arg(url.toLocalFile());
 
         return image;
     }
 
     // Resize with smooth transformation for more beautiful result
     image = image.convertToFormat(QImage::Format_ARGB32).scaled(image.size()/1.8, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
 
     if (size)
         *size = QSizeF(w, h);
     return image;
 }
 
 
 QImage Renderer::renderToImage(const QUrl& url, Method method, QSizeF* size)
 {
     switch(method)
     {
         case Method::PDF:
             return pdfRenderToImage(url, d->scale, d->useHighRes, size);
 
         case Method::EPS:
             return epsRenderToImage(url, d->scale, d->useHighRes, size);
 
         default:
             return QImage();
     }
 }