PDFAWriter.h

/*
 * Copyright © 2016 - 2020 Stefan Kebekus <stefan.kebekus@math.uni-freiburg.de>
 *
 * This program is free software: you can redistribute it and/or modify it under
 * the terms of the GNU General Public License as published by the Free Software
 * Foundation, either version 3 of the License, or (at your option) any later
 * version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 
#ifndef PDFDOCUMENT
#define PDFDOCUMENT 1
 
#include <QFuture>
#include <QList>
#include <QReadWriteLock>
#include <QString>
 
#include "HOCRDocument.h"
#include "JBIG2Document.h"
#include "paperSize.h"
#include "resolution.h"
 
 
class PDFAWriter : public QObject
{
  Q_OBJECT
  Q_PROPERTY(QString author READ author WRITE setAuthor NOTIFY authorChanged)
  Q_PROPERTY(QString keywords READ keywords WRITE setKeywords NOTIFY keywordsChanged)
  Q_PROPERTY(QString subject READ subject WRITE setSubject NOTIFY subjectChanged)
  Q_PROPERTY(QString title READ title WRITE setTitle NOTIFY titleChanged)
  Q_PROPERTY(paperSize pageSize READ pageSize WRITE setPageSize NOTIFY pageSizeChanged)
  Q_PROPERTY(resolution resolutionOverrideHorizontal READ resolutionOverrideHorizontal WRITE setResolutionOverrideHorizontal NOTIFY resolutionOverrideHorizontalChanged)
  Q_PROPERTY(resolution resolutionOverrideVertical READ resolutionOverrideVertical WRITE setResolutionOverrideVertical NOTIFY resolutionOverrideVerticalChanged)
  Q_PROPERTY(bool autoOCR READ autoOCR WRITE setAutoOCR NOTIFY autoOCRChanged)
  Q_PROPERTY(QStringList autoOCRLanguages READ autoOCRLanguages WRITE setAutoOCRLanguages NOTIFY autoOCRLanguagesChanged)
 
 public:
  ~PDFAWriter();
  
  explicit PDFAWriter(bool bestCompression=false, QObject* parent=nullptr);
  
  QString author();
  
  void setAuthor(const QString &author);
  
  QString keywords();
  
  void setKeywords(const QString &keywords);
  
  QString subject();
  
  void setSubject(const QString &subject);
  
  QString title();
  
  void setTitle(const QString &title);
  
  paperSize pageSize();
 
  void setPageSize(const paperSize size);
  
  void setPageSize(paperSize::format size=paperSize::empty);
  
  resolution resolutionOverrideHorizontal();
 
  void setResolutionOverrideHorizontal(resolution horizontal);
 
  resolution resolutionOverrideVertical();
 
  void setResolutionOverrideVertical(resolution vertical);
  
  void setResolutionOverride(resolution horizontal, resolution vertical);
 
  void setResolutionOverride(resolution res)
  {
    setResolutionOverride(res, res);
  }
 
  void clearResolutionOverride()
  {
    setResolutionOverride(resolution(), resolution());
  }
  
  bool autoOCR();
  
  void setAutoOCR(bool autoOCR);
  
  QStringList autoOCRLanguages();
 
  QString setAutoOCRLanguages(const QStringList& nOCRLanguages);
 
  void appendToOCRData(const HOCRDocument &doc);
 
  HOCRDocument OCRData();
 
  void clearOCRData();
  
  QString addPages(const QImage &image, QStringList *warnings=0);
  
  QString addPages(const JBIG2Document &jbig2doc, QStringList *warnings=0);
 
  QString addPages(const QString &imageFileName, QStringList *warnings=0);
  
  operator QByteArray();
 
 public slots:
  void waitForWorkerThreads();
  
 signals:
  void authorChanged();
 
  void keywordsChanged();
 
  void subjectChanged();
 
  void titleChanged();
 
  void pageSizeChanged();
 
  void resolutionOverrideHorizontalChanged();
  
  void resolutionOverrideVerticalChanged();
 
  void autoOCRChanged();
 
  void autoOCRLanguagesChanged();
 
  void finished();
  
  void progress(qreal percentage);
  
 private:
  // Meta data
  QString _author, _keywords, _subject, _title;
 
  // Paper size
  paperSize _pageSize;
 
  // HOCR Document
  HOCRDocument userSpecifiedOCRData;
  QStringList OCRLanguages;
  bool _autoOCR;
  
  // Override resolutions
  resolution horizontalResolutionOverride;
  resolution verticalResolutionOverride;
  
  // This private method adds a JBIG2 image to the PDF document. It differs from
  // the generic method addPages() only in the arguments it expects the name of
  // a JBIG file inestead of an abitrary graphics file.
  //
  // The image will be embedded in the PDF without re-encoding.  The method does
  // not check in detail if the file complies with the JBIG2 standard.  If
  // invalid input data is fed into this method, then the resulting PDF file
  // might possibly not comply to the PDF/A standard.
  QString addJBIG2(const QString &fileName, QStringList *warnings=0);
 
  // This private method adds a JPEG image to the PDF document. It differs from
  // the generic method addPages() only in the arguments it expects the name of
  // a JPEG file inestead of an abitrary  graphics file.
  //
  // The image will be embedded in the PDF without re-encoding.  The method does
  // not check in detail if the file complies with the JPEG standard.  If
  // invalid input data is fed into this method, then the resulting PDF file
  // might possibly not comply to the PDF/A standard.
  QString addJPEG(const QString &fileName);
 
  // This private method adds a JPEG2000 (ISO/IEC 15444-2) image to the PDF
  // document. The method expects a JPX or JPF file, and NOT a JP2 file.  It
  // differs from the generic method addPages() only in the arguments. It
  // expects the name of a JPEG2000 file inestead of an abitrary graphics file.
  //
  // The image will be embedded in the PDF without re-encoding.  The method does
  // not check in detail if the file complies with the JPEG standard.  If
  // invalid input data is fed into this method, then the resulting PDF file
  // might possibly not comply to the PDF/A standard.
  QString addJPX(const QString &fileName);
 
  // This private method adds a TIFF image to the PDF document. The method
  // exists because QImageReader cannot handle multi-page TIFF files. The method
  // reads all images contained in the file, and calls addImage() to add them to
  // the PDF
  QString addTIFF(const QString &fileName);
 
  // This private method is used internally to generate a page containing a
  // given graphicObject, and optionally a text overlay.  This method assumes
  // that the arguments have been checked and are correct. It also assumes that
  // the PDFAWriter has been locked for writing.
  void addGFXPage(quint32 graphicObjectIndex, const imageInfo& bInfo, const QImage& imageForOCR = QImage());
 
  // Lock used to provide thread-safety
  QReadWriteLock lock;
  
  // PDF protoObject. This is either a QByteArray or QFuture<QByteArray>.
  class protoObject {
  public:
    // cppcheck-suppress noExplicitConstructor
    protoObject(QByteArray _data) : data(_data) {
      ;
    };
    
    // cppcheck-suppress noExplicitConstructor
    protoObject(QFuture<QByteArray> _future) : future(_future) {
      ;
    };
    
    inline operator QByteArray() {
      if (!future.isCanceled()) {
       data = future.result();
       future = QFuture<QByteArray>();
      }
      return data;
    };
    
    QString description;
    QByteArray data;
    QFuture<QByteArray> future;
  };
  
  // List of PDF objects
  QList<protoObject> objects;
 
  // Index of the PDF object in the 'objects' list that contains …
  quint32 catalogObjectIndex;        // … the catalog of the PDF file
  quint32 metaDataObjectIndex;       // … the meta data
  quint32 infoObjectIndex;           // … the info object
  quint32 pageDirectoryObjectIndex;  // … the page directory
  quint32 colorProfileObjectIndex;   // … the color profile
  quint32 fontObjectIndex;           // … the font object itself
 
  // Use zopfli compression for bitmap graphics
  bool bestCompression;
  
  // Indices of the PDF page objects in the 'objects' list
  QList<quint32> pageIndices;
 
  // Reads file content into QByteArray
  static QByteArray readFile(const QString& fileName);
 
  // Constructs a page directory object
  QByteArray generatePageDirectoryObject() const;
 
  // Takes data from input, checks is zlib compression actually shrinks the
  // data, and then generates a stream object, either unencoded or zlib encoded.
  static QByteArray generateStreamObject(const QByteArray &input);
 
  // Returns the index of a font object for Times-Roman. Creates the object, if necessary
  quint32 getFontObjectIndex();
 
  // Assumes that the image is black-and-white, as returned by
  // imageOperations::optimizedFormat(), and returns a QByteArray containing a
  // PDF object containing the FAX G4 compressed image.
  static QByteArray createImageObject_bw_G4(const QImage &image);
 
  // Assumes that the image is bitonal, as returned by
  // imageOperations::optimizedFormat(), and returns a QByteArray containing a
  // PDF object containing the FAX G4 compressed image.
  static QByteArray createImageObject_bitonal_G4(const QImage &image);
 
  // Assumes that the image is grayscale, as returned by
  // imageOperations::optimizedFormat(), and returns a QByteArray containing a
  // PDF object containing the zlib/zopfli compressed image.
  static QByteArray createImageObject_gray_zlib(const QImage &image, bool bestCompression);
 
  // Assumes that the image has an indexed palette, as returned by
  // imageOperations::optimizedFormat(), and returns a QByteArray containing a
  // PDF object containing the zlib/zopfli compressed image.
  static QByteArray createImageObject_indexed_zlib(const QImage &image, bool bestCompression);
 
  // Assumes that the image is full color, as returned by
  // imageOperations::optimizedFormat(), and returns a QByteArray containing a
  // PDF object containing the zlib/zopfli compressed image.
  static QByteArray createImageObject_rgb_zlib(const QImage &image, bool bestCompression);
 
  // Internal method. The method takes a page content stream and generates a
  // well-compressed pageContent object, using the textBox to create a text
  // overlay.
  static QByteArray completePageContentObject_a(QByteArray contentStream, const imageInfo& bInfo, length deltaX, length deltaY, const HOCRTextBox& textBox);
 
  // Internal method. The method takes runs the tesseract OCR engine to create a
  // HOCRTextBox and then calls completePageContentObject_a
  static QByteArray completePageContentObject_b(QByteArray contentStream, const imageInfo& bInfo, length deltaX, length deltaY, const QImage& image, const QStringList& OCRLanguages);
};
 
#endif