v4.1.4 release notes

Issue #79.
User submitted PDF with ICC profile attached to the monochrome image
in the input file, which is not common but useful for PDFs that want to
define how light the paper is or how dark the black is. The code was
written to assume unusual images are full color unless it can prove
otherwise. Handle this simple case. Other ICC cases should be tested.

.git_archival.txt

@@ -0,0 +1 @@
+ref-names: $Format:%D$

.gitattributes

@@ -5,4 +5,6 @@
 # (binary is a macro for -text -diff)
 *.jar	binary
 *.pdf	binary
-*.PDF	binary
+*.PDF	binary
+
+.git_archival.txt  export-subst

.travis.yml

@@ -5,7 +5,7 @@ cache: pip
 cache:
     directories:
         - $HOME/.ccache
-        - tarballs
+        - packages
         - tests/cache
 
 python:
@@ -21,17 +21,15 @@ before_install:
     - sudo add-apt-repository ppa:b-eltzner/qpdfview-exp -y  # for QPDF 5
     - sudo add-apt-repository ppa:itachi-san/ffmpeg -y  # for libav 11.2 (for unpaper)
     - sudo apt-get update -qq  # must go after all add-apt-repo
-    - sudo apt-get install -y ghostscript tesseract-ocr tesseract-ocr-deu tesseract-ocr-eng tesseract-ocr-fra qpdf poppler-utils gcc libavformat-dev libavcodec-dev libavutil-dev automake make pkg-config xsltproc libffi-dev
+    - sudo apt-get install -y ghostscript tesseract-ocr tesseract-ocr-deu tesseract-ocr-eng tesseract-ocr-fra qpdf poppler-utils libavformat56 libavcodec56 libavutil54 libffi-dev
 
     # pip
     - pip install --upgrade pip
 
     # Download, make and install unpaper (using ccache)
-    - mkdir -p tarballs
-    - "[ -f tarballs/unpaper-6.1.tar.xz ] || wget -q https://www.flameeyes.eu/files/unpaper-6.1.tar.xz -O tarballs/unpaper-6.1.tar.xz"
-    - tar -xvf tarballs/unpaper-6.1.tar.xz
-    - export PATH="/usr/lib/ccache:$PATH"
-    - pushd unpaper-6.1 && ./configure --prefix=/usr && make -j && sudo make install && popd
+    - mkdir -p packages
+    - "[ -f packages/unpaper_6.1-1.deb ] || wget -q https://dl.dropboxusercontent.com/u/28971240/unpaper_6.1-1.deb -O packages/unpaper_6.1-1.deb"
+    - sudo dpkg -i packages/unpaper_6.1-1.deb
 
 install:
     - pip install -r requirements.txt

Dockerfile

@@ -23,12 +23,8 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 
 RUN apt-get install -y --no-install-recommends \
   unpaper \
-  libopenjpeg-dev \
-  ghostscript \
   qpdf \
-  poppler-utils
-
-RUN apt-get install -y --no-install-recommends \
+  poppler-utils \
   tesseract-ocr \
   tesseract-ocr-deu tesseract-ocr-spa tesseract-ocr-eng tesseract-ocr-fra
 
@@ -37,6 +33,14 @@ RUN apt-get install -qy --no-install-recommends \
   libpython3-dev \
   gcc
 
+# Install Ghostscript from Debian sid to work around JPEG 2000 issue in
+# Debian stretch libgs9 or gs 9.16~dfsg-2.1
+
+COPY ./share/etc-apt-sources.list /etc/apt/sources.list
+
+RUN apt-get update && apt-get install -y ghostscript/sid
+
+
 # Enforce UTF-8
 # Borrowed from https://index.docker.io/u/crosbymichael/python/ 
 RUN dpkg-reconfigure locales && \
@@ -80,7 +84,6 @@ USER docker
 WORKDIR /home/docker
 
 ENV OCRMYPDF_TEST_OUTPUT=/tmp/test-output
-ENV OCRMYPDF_IN_DOCKER=1
 ENV OCRMYPDF_SHARP_TTF=1
 
 # Must use array form of ENTRYPOINT

README.rst

@@ -48,6 +48,14 @@ Download OCRmyPDF here: https://github.com/jbarlow83/OCRmyPDF/releases
 
 You can install it to a Python virtual environment or system-wide. 
 
+Debian and Ubuntu
+~~~~~~~~~~~~~~~~~
+
+Users of Debian 9 or later or Ubuntu 16.10 or later may simply
+``apt-get install ocrmypdf``.
+
+.. _Docker:
+
 Installing the Docker image
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -57,11 +65,15 @@ If you have `Docker <https://docs.docker.com/>`__ installed on your system, you
 a Docker image of the latest release.
 
 Follow the Docker installation instructions for your platform.  If you can run this command
-successfully, your system is ready to download and execute the image::
+successfully, your system is ready to download and execute the image:
+
+.. code-block:: bash
 
    docker run hello-world
    
-OCRmyPDF will use all available CPU cores.  By default, the VirtualBox machine instance on Windows and OS X has only a single CPU core enabled. Use the VirtualBox Manager to determine the name of your Docker engine host, and then follow these optional steps to enable multiple CPUs::
+OCRmyPDF will use all available CPU cores.  By default, the VirtualBox machine instance on Windows and OS X has only a single CPU core enabled. Use the VirtualBox Manager to determine the name of your Docker engine host, and then follow these optional steps to enable multiple CPUs:
+
+.. code-block:: bash
 
    # Optional step for Mac OS X users
    docker-machine stop "yourVM"
@@ -70,29 +82,41 @@ OCRmyPDF will use all available CPU cores.  By default, the VirtualBox machine i
    eval $(docker-machine env "yourVM")
 
 Assuming you have a Docker engine running somewhere, you can run these commands to download
-the image::
+the image:
+
+.. code-block:: bash
 
    docker pull jbarlow83/ocrmypdf
 
-Then tag it to give a more convenient name, just ocrmypdf::
+Then tag it to give a more convenient name, just ocrmypdf:
+
+.. code-block:: bash
 
    docker tag jbarlow83/ocrmypdf ocrmypdf
 
-This image contains language packs for English, French, Spanish and German. The alternative "polyglot" image provides `all available language packs <https://github.com/tesseract-ocr/tesseract/blob/master/doc/tesseract.1.asc#languages>`__::
+This image contains language packs for English, French, Spanish and German. The alternative "polyglot" image provides `all available language packs <https://github.com/tesseract-ocr/tesseract/blob/master/doc/tesseract.1.asc#languages>`__:
+
+.. code-block:: bash
 
    # Alternative step: If you need all language packs
    docker pull jbarlow83/ocrmypdf-polyglot
    docker tag jbarlow83/ocrmypdf-polyglot ocrmypdf
 
-You can then run ocrmypdf using the command::
+You can then run ocrmypdf using the command:
+
+.. code-block:: bash
 
    docker run ocrmypdf --help
   
-To execute the OCRmyPDF on a local file, you must `provide a writable volume to the Docker image <https://docs.docker.com/userguide/dockervolumes/>`__, such as this in this template::
+To execute the OCRmyPDF on a local file, you must `provide a writable volume to the Docker image <https://docs.docker.com/userguide/dockervolumes/>`__, such as this in this template:
+
+.. code-block:: bash
 
    docker run -v "$(pwd):/home/docker" <other docker arguments>   ocrmypdf <your arguments to ocrmypdf>
 
-In this worked example, the current working directory contains an input file called ``test.pdf`` and the output will go to ``output.pdf``:: 
+In this worked example, the current working directory contains an input file called ``test.pdf`` and the output will go to ``output.pdf``: 
+
+.. code-block:: bash
 
    docker run -v "$(pwd):/home/docker"   ocrmypdf --skip-text test.pdf output.pdf
 
@@ -106,30 +130,40 @@ These instructions probably work on all Mac OS X versions later than 10.7 (Lion)
 
 If it's not already present, `install Homebrew <http://brew.sh/>`__.
 
-Update Homebrew::
+Update Homebrew:
+
+.. code-block:: bash
 
    brew update
    
-Install or upgrade the required Homebrew packages, if any are missing::
+Install or upgrade the required Homebrew packages, if any are missing:
+
+.. code-block:: bash
 
    brew install libpng openjpeg jbig2dec     # image libraries
    brew install qpdf
    brew install ghostscript
    brew install python3
-   brew install libxml2
-   brew install leptonica
+   brew install libxml2 libffi leptonica
+   brew install unpaper    # optional
    brew install tesseract
    
-Update the homebrew pip and install Pillow::
+Update the homebrew pip and install Pillow:
+
+.. code-block:: bash
 
    pip3 install --upgrade pip
    pip3 install --upgrade pillow
 
-You can then install OCRmyPDF from PyPI::
+You can then install OCRmyPDF from PyPI:
+
+.. code-block:: bash
 
    pip3 install ocrmypdf
 
-The command line program should now be available::
+The command line program should now be available:
+
+.. code-block:: bash
 
    ocrmypdf --help
 
@@ -138,16 +172,21 @@ Installing on Ubuntu 14.04 LTS
 
 Installing on Ubuntu 14.04 LTS (trusty) is more difficult than other options, because of certain bugs in Python package installation.
 
-Update apt-get::
+Update apt-get:
+
+.. code-block:: bash
 
    sudo apt-get update
    sudo apt-get upgrade
    
-Install system dependencies::
+Install system dependencies:
+
+.. code-block:: bash
 
    sudo apt-get install \
       zlib1g-dev \
       libjpeg-dev \
+      libffi-dev \
       ghostscript \
       tesseract-ocr \
       qpdf \
@@ -158,13 +197,17 @@ Install system dependencies::
       python3-reportlab
 
 If you wish install OCRmyPDF to the system Python, then install as follows (note this installs new packages
-into your system Python, which could interfere with other programs)::
+into your system Python, which could interfere with other programs):
+
+.. code-block:: bash
 
    sudo pip3 install ocrmypdf
    
 If you wish to install OCRmyPDF to a virtual environment to isolate system Python from modified, you can
 follow these steps.  This includes a workaround `for a known, unresolved issue in Ubuntu 14.04's ensurepip
-package <http://www.thefourtheye.in/2014/12/Python-venv-problem-with-ensurepip-in-Ubuntu.html>`__::
+package <http://www.thefourtheye.in/2014/12/Python-venv-problem-with-ensurepip-in-Ubuntu.html>`__:
+
+.. code-block:: bash
 
    sudo apt-get install python3-venv
    python3 -m venv venv-ocrmypdf --without-pip
@@ -180,8 +223,18 @@ Ubuntu 14.04 only installs ``unpaper`` version 0.4.2, which is not supported by
 Installing on Windows
 ~~~~~~~~~~~~~~~~~~~~~
 
-Direct installation on Windows is not possible.  Install the Docker container as described above.
+Direct installation on Windows is not possible.  Install the _`Docker` container as described above.  Ensure that your command prompt can run the docker "hello world" container.
 
+Running on Windows
+~~~~~~~~~~~~~~~~~~
+
+The command line syntax to run ocrmypdf from a command prompt will resemble:
+
+.. code-block:: bat
+
+   docker run -v /c/Users/sampleuser:/home/docker ocrmypdf --skip-text test.pdf output.pdf
+
+where /c/Users/sampleuser is a Unix representation of the Windows path C:\\Users\\sampleuser, assuming a user named "sampleuser" is running ocrmypdf on a file in their home directory, and the files "test.pdf" and "output.pdf" are in the sampleuser folder. The Windows user must have read and write permissions.
       
 Installing HEAD revision from sources
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -189,21 +242,29 @@ Installing HEAD revision from sources
 If you have ``git`` and ``python3.4`` or ``python3.5`` installed, you can install from source. When the ``pip`` installer runs,
 it will alert you if dependencies are missing.
 
-To install the HEAD revision from sources in the current Python 3 environment::
+To install the HEAD revision from sources in the current Python 3 environment:
+
+.. code-block:: bash
 
    pip3 install git+https://github.com/jbarlow83/OCRmyPDF.git
 
-Or, to install in `development mode <https://pythonhosted.org/setuptools/setuptools.html#development-mode>`__,  allowing customization of OCRmyPDF, use the ``-e`` flag::
+Or, to install in `development mode <https://pythonhosted.org/setuptools/setuptools.html#development-mode>`__,  allowing customization of OCRmyPDF, use the ``-e`` flag:
+
+.. code-block:: bash
 
    pip3 install -e git+https://github.com/jbarlow83/OCRmyPDF.git
    
 On certain Linux distributions such as Ubuntu, you may need to use 
-run the install command as superuser::
+run the install command as superuser:
+
+.. code-block:: bash
 
    sudo pip3 install [-e] git+https://github.com/jbarlow83/OCRmyPDF.git
    
 Note that this will alter your system's Python distribution. If you prefer 
-to not install as superuser, you can install the package in a Python virtual environment::
+to not install as superuser, you can install the package in a Python virtual environment:
+
+.. code-block:: bash
 
    git clone -b master https://github.com/jbarlow83/OCRmyPDF.git
    pyvenv venv
@@ -214,7 +275,9 @@ to not install as superuser, you can install the package in a Python virtual env
 However, ``ocrmypdf`` will only be accessible on the system PATH after
 you activate the virtual environment.
 
-To run the program::
+To run the program:
+
+.. code-block:: bash
    
    ocrmypdf --help
 
@@ -227,7 +290,9 @@ Languages
 ---------
 
 OCRmyPDF uses Tesseract for OCR, and relies on its language packs. For Linux users,
-you can often find packages that provide language packs::
+you can often find packages that provide language packs:
+
+.. code-block:: bash
 
    # Debian/Ubuntu users
    sudo apt-get install tesseract-ocr-chi-sim
@@ -238,9 +303,15 @@ languages can be requested.
 Support
 -------
 
-In case you detect an issue, please:
+Once ocrmypdf is installed, the built-in help which explains the command syntax and options can be accessed via:
 
--  Check if your issue is already known
+.. code-block:: bash
+
+   ocrmypdf --help
+
+If you detect an issue, please:
+
+-  Check whether your issue is already known
 -  If no problem report exists on github, please create one here:
    https://github.com/jbarlow83/OCRmyPDF/issues
 -  Describe your problem thoroughly
@@ -252,11 +323,11 @@ In case you detect an issue, please:
 Press & Media
 -------------
 
--  `c't 1-2014, page 59 <http://www.heise.de/ct/inhalt/2014/1/58/>`__:
+-  `c't 1-2014, page 59 <http://heise.de/-2279695>`__:
    Detailed presentation of OCRmyPDF v1.0 in the leading German IT
    magazine c't
 -  `heise Open Source, 09/2014: Texterkennung mit
-   OCRmyPDF <http://www.heise.de/-2356670>`__
+   OCRmyPDF <http://heise.de/-2356670>`__
 
 Disclaimer
 ----------

RELEASE_NOTES.rst

@@ -6,6 +6,84 @@ Please always read this file before installing the package
 Download software here: https://github.com/jbarlow83/OCRmyPDF/tags
 
 
+v4.1.4:
+=======
+
+-  Bug fix: monochrome images with an ICC profile attached were incorrectly converted to full color images if lossless reconstruction was not possible due to other settings; consequence was increased file size for these images
+
+
+v4.1.3:
+=======
+
+-  More helpful error message for PDFs with version 4 security handler
+-  Update usage instructions for Windows/Docker users
+-  Fix order of operations for matrix multiplication (no effect on most users)
+-  Add a few leptonica wrapper functions (no effect on most users)
+
+
+v4.1.2:
+=======
+
+-  Replace IEC sRGB ICC profile with Debian's sRGB (from icc-profiles-free) which is more compatible with the MIT license
+-  More helpful error message for an error related to certain types of malformed PDFs
+
+
+v4.1:
+=====
+
+-  ``--rotate-pages`` now only rotates pages when reasonably confidence in the orientation. This behavior can be adjusted with the new argument ``--rotate-pages-threshold``
+-  Fixed problems in error checking if ``unpaper`` is uninstalled or missing at run-time
+-  Fixed problems with "RethrownJobError" errors during error handling that suppressed the useful error messages
+
+
+v4.0.7:
+=======
+
+-  Minor correction to Ghostscript output settings
+
+
+v4.0.6:
+=======
+
+-  Update install instructions
+-  Provide a sRGB profile instead of using Ghostscript's
+
+
+v4.0.5:
+=======
+
+Fixes
+-----
+
+-  Remove some verbose debug messages from v4.0.4
+-  Fixed temporary that wasn't being deleted
+-  DPI is now calculated correctly for cropped images, along with other image transformations
+-  Inline images are now checked during DPI calculation instead of rejecting the image
+
+v4.0.4:
+=======
+
+Released with verbose debug message turned on. Do not use. Skip to v4.0.5.
+
+
+v4.0.3:
+=======
+
+New features
+------------
+
+-  Page orientations detected are now reported in a summary comment
+
+
+Fixes
+-----
+
+-  Show stack trace if unexpect errors occur
+-  Treat "too few characters" error message from Tesseract as a reason to skip that page rather than
+   abort the file
+-  Docker: fix blank JPEG2000 issue by insisting on Ghostscript versions that have this fixed
+
+
 v4.0.2:
 =======
 

ocrmypdf/__init__.py

@@ -11,6 +11,7 @@ class ExitCode(IntEnum):
     file_access_error = 5
     already_done_ocr = 6
     child_process_error = 7
+    encrypted_pdf = 8
     other_error = 15
 
 

ocrmypdf/ghostscript.py

@@ -5,6 +5,7 @@ from tempfile import NamedTemporaryFile
 from subprocess import Popen, PIPE, check_call
 from shutil import copy
 from . import get_program
+from .pdfa import SRGB_ICC_PROFILE
 
 
 def rasterize_pdf(input_file, output_file, xres, yres, raster_device, log,
@@ -52,7 +53,6 @@ def generate_pdfa(pdf_pages, output_file, threads=1):
             "-dJPEGQ=95",
             "-dPDFA=2",
             "-sPDFACompatibilityPolicy=2",
-            "-sOutputICCProfile=srgb.icc",
             "-sOutputFile=" + gs_pdf.name,
         ]
         args_gs.extend(pdf_pages)

ocrmypdf/leptonica.py

@@ -17,6 +17,7 @@ from tempfile import TemporaryFile
 from ctypes.util import find_library
 from .lib._leptonica import ffi
 from functools import lru_cache
+from enum import Enum
 
 lept = ffi.dlopen(find_library('lept'))
 
@@ -83,6 +84,13 @@ class LeptonicaIOError(LeptonicaError):
     pass
 
 
+class RemoveColormap(Enum):
+    to_binary = 0
+    to_grayscale = 1
+    to_full_color = 2
+    based_on_src = 3
+
+
 class Pix:
     """Wrapper around leptonica's PIX object.
 
@@ -98,27 +106,31 @@ class Pix:
     in a threadsafe manner if a Python threading.Lock protects the data.
     """
 
-    def __init__(self, cpix):
-        self.cpix = ffi.gc(cpix, Pix._pix_destroy)
+    def __init__(self, pix):
+        self._pix = ffi.gc(pix, Pix._pix_destroy)
 
     def __repr__(self):
-        if self.cpix:
+        if self._pix:
             s = "<leptonica.Pix image size={0}x{1} depth={2} at 0x{3:x}>"
-            return s.format(self.cpix.w, self.cpix.h, self.cpix.d,
-                            int(ffi.cast("intptr_t", self.cpix)))
+            return s.format(self._pix.w, self._pix.h, self._pix.d,
+                            int(ffi.cast("intptr_t", self._pix)))
         else:
             return "<leptonica.Pix image NULL>"
 
     def __getstate__(self):
-        data = ffi.new('l_uint32 *[]', 1)
-        size = ffi.new('size_t *', 0)
+        data = ffi.new('l_uint32 **')
+        size = ffi.new('size_t *')
 
-        err = lept.pixSerializeToMemory(self.cpix, data, size)
+        err = lept.pixSerializeToMemory(self._pix, data, size)
         if err != 0:
             raise LeptonicaIOError("pixSerializeToMemory")
 
         char_data = ffi.cast('char *', data[0])
+
+        # Copy from C bytes to python bytes()
         data_bytes = ffi.buffer(char_data, size[0])[:]
+
+        # Can now free C bytes
         lept.lept_free(char_data)
         return dict(data=data_bytes)
 
@@ -126,16 +138,41 @@ class Pix:
         cdata_bytes = ffi.new('char[]', state['data'])
         cdata_uint32 = ffi.cast('l_uint32 *', cdata_bytes)
 
-        self.cpix = lept.pixDeserializeFromMemory(
+        pix = lept.pixDeserializeFromMemory(
             cdata_uint32, len(state['data']))
+        Pix.__init__(self, pix)
 
     @property
     def width(self):
-        return self.cpix.w
+        return self._pix.w
 
     @property
     def height(self):
-        return self.cpix.h
+        return self._pix.h
+
+    @property
+    def depth(self):
+        return self._pix.d
+
+    @property
+    def size(self):
+        return (self._pix.w, self._pix.h)
+
+    @property
+    def info(self):
+        return {'dpi': (self._pix.xres, self._pix.yres)}
+
+    @property
+    def mode(self):
+        "Return mode like PIL.Image"
+        if self.depth == 1:
+            return '1'
+        elif self.depth >= 16:
+            return 'RGB'
+        elif not self._pix.colormap:
+            return 'L'
+        else:
+            return 'P'
 
     @classmethod
     def read(cls, filename):
@@ -158,7 +195,29 @@ class Pix:
         with LeptonicaErrorTrap():
             lept.pixWriteImpliedFormat(
                 filename.encode(sys.getfilesystemencoding()),
-                self.cpix, jpeg_quality, jpeg_progressive)
+                self._pix, jpeg_quality, jpeg_progressive)
+
+    def topil(self):
+        "Returns a PIL.Image version of this Pix"
+        from PIL import Image
+
+        with LeptonicaErrorTrap():
+            pix_swapped = Pix(lept.pixEndianByteSwapNew(self._pix))
+
+        size = (pix_swapped._pix.wpl * 4, pix_swapped._pix.h)
+        buf = ffi.buffer(pix_swapped._pix.data, size[0] * size[1])
+
+        im_raw = Image.frombytes(self.mode, size, buf, 'raw')
+
+        # Leptonica stores images in 32-bit words
+        # Need to crop the any trailing amount
+        box = (0, 0, self.width, self.height)
+        im = im_raw.crop(box)
+
+        return im
+
+    def show(self):
+        return self.topil().show()
 
     def deskew(self, reduction_factor=0):
         """Returns the deskewed pix object.
@@ -170,16 +229,21 @@ class Pix:
             for skew angle
         """
         with LeptonicaErrorTrap():
-            return Pix(lept.pixDeskew(self.cpix, reduction_factor))
+            return Pix(lept.pixDeskew(self._pix, reduction_factor))
 
     def scale(self, scalex, scaley):
         "Returns the pix object rescaled according to the proportions given."
         with LeptonicaErrorTrap():
-            return Pix(lept.pixScale(self.cpix, scalex, scaley))
+            return Pix(lept.pixScale(self._pix, scalex, scaley))
 
     def rotate180(self):
         with LeptonicaErrorTrap():
-            return Pix(lept.pixRotate180(ffi.NULL, self.cpix))
+            return Pix(lept.pixRotate180(ffi.NULL, self._pix))
+
+    def rotate_orth(self, quads):
+        "Orthographic rotation, quads: 0-3, number of clockwise rotations"
+        with LeptonicaErrorTrap():
+            return Pix(lept.pixRotateOrth(self._pix, quads))
 
     def find_skew(self):
         """Returns a tuple (deskew angle in degrees, confidence value).
@@ -189,27 +253,125 @@ class Pix:
         with LeptonicaErrorTrap():
             angle = ffi.new('float *', 0.0)
             confidence = ffi.new('float *', 0.0)
-            result = lept.pixFindSkew(self.cpix, angle, confidence)
+            result = lept.pixFindSkew(self._pix, angle, confidence)
             if result == 0:
                 return (angle[0], confidence[0])
             else:
                 return (None, None)
 
+    def convert_rgb_to_luminance(self):
+        with LeptonicaErrorTrap():
+            gray_pix = lept.pixConvertRGBToLuminance(self._pix)
+            if gray_pix:
+                return Pix(gray_pix)
+            return None
+
+    def remove_colormap(self, removal_type):
+        """Remove a palette
+
+            removal_type - RemovalColormap()
+        """
+
+        with LeptonicaErrorTrap():
+            return Pix(lept.pixRemoveColormap(self._pix, removal_type))
+
+    def otsu_adaptive_threshold(
+            self, tile_size=(300, 300), kernel_size=(4, 4), scorefract=0.1):
+        with LeptonicaErrorTrap():
+            sx, sy = tile_size
+            smoothx, smoothy = kernel_size
+            p_pix = ffi.new('PIX **')
+
+            result = lept.pixOtsuAdaptiveThreshold(
+                self._pix,
+                sx, sy,
+                smoothx, smoothy,
+                scorefract,
+                ffi.NULL,
+                p_pix)
+            if result == 0:
+                return Pix(p_pix[0])
+            else:
+                return None
+
+    def otsu_threshold_on_background_norm(
+            self, mask=None, tile_size=(10, 15), thresh=100, mincount=50,
+            bgval=255, kernel_size=(2, 2), scorefract=0.1):
+        with LeptonicaErrorTrap():
+            sx, sy = tile_size
+            smoothx, smoothy = kernel_size
+            if mask is None:
+                mask = ffi.NULL
+            if isinstance(mask, Pix):
+                mask = mask._pix
+
+            thresh_pix = lept.pixOtsuThreshOnBackgroundNorm(
+                self._pix,
+                mask,
+                sx, sy,
+                thresh, mincount, bgval,
+                smoothx, smoothy,
+                scorefract,
+                ffi.NULL
+                )
+            if thresh_pix == ffi.NULL:
+                return None
+            return Pix(thresh_pix)
+
+    def crop_to_foreground(
+            self, threshold=128, mindist=70, erasedist=30, pagenum=0,
+            showmorph=0, display=0, pdfdir=ffi.NULL):
+        with LeptonicaErrorTrap():
+            cropbox = Box(lept.pixFindPageForeground(
+                self._pix,
+                threshold,
+                mindist,
+                erasedist,
+                pagenum,
+                showmorph,
+                display,
+                pdfdir))
+
+            print(repr(cropbox))
+
+            cropped_pix = lept.pixClipRectangle(
+                self._pix,
+                cropbox._box,
+                ffi.NULL)
+
+            return Pix(cropped_pix)
+
+    def clean_background_to_white(
+            self, mask=None, grayscale=None, gamma=1.0, black=0, white=255):
+        with LeptonicaErrorTrap():
+            return Pix(lept.pixCleanBackgroundToWhite(
+                self._pix,
+                mask or ffi.NULL,
+                grayscale or ffi.NULL,
+                gamma,
+                black,
+                white))
+
+    @staticmethod
+    @lru_cache(maxsize=1)
+    def make_pixel_sum_tab8():
+        return lept.makePixelSumTab8()
+
     @staticmethod
     def correlation_binary(pix1, pix2):
         if get_leptonica_version() < 'leptonica-1.72':
             # Older versions of Leptonica (pre-1.72) have a buggy
             # implementation of pixCorrelationBinary that overflows on larger
             # images.
-            pix1_count = ffi.new('l_int32 *', 0)
-            pix2_count = ffi.new('l_int32 *', 0)
-            pixn_count = ffi.new('l_int32 *', 0)
-            tab8 = lept.makePixelSumTab8()  # Small memory leak on each call
+            pix1_count = ffi.new('l_int32 *')
+            pix2_count = ffi.new('l_int32 *')
+            pixn_count = ffi.new('l_int32 *')
+            tab8 = Pix.make_pixel_sum_tab8()
 
-            lept.pixCountPixels(pix1.cpix, pix1_count, tab8)
-            lept.pixCountPixels(pix2.cpix, pix2_count, tab8)
-            pixn = Pix(lept.pixAnd(ffi.NULL, pix1.cpix, pix2.cpix))
-            lept.pixCountPixels(pixn.cpix, pixn_count, tab8)
+            lept.pixCountPixels(pix1._pix, pix1_count, tab8)
+            lept.pixCountPixels(pix2._pix, pix2_count, tab8)
+            pixn = Pix(lept.pixAnd(ffi.NULL, pix1._pix, pix2._pix))
+            lept.pixCountPixels(pixn._pix, pixn_count, tab8)
 
             # Python converts these int32s to larger units as needed
             # to avoid overflow. Overflow happens easily here.
@@ -220,7 +382,7 @@ class Pix:
             return correlation
         else:
             correlation = ffi.new('float *', 0.0)
-            result = lept.pixCorrelationBinary(pix1.cpix, pix2.cpix,
+            result = lept.pixCorrelationBinary(pix1._pix, pix2._pix,
                                                correlation)
             if result != 0:
                 raise LeptonicaError("Correlation failed")
@@ -228,11 +390,48 @@ class Pix:
 
     @staticmethod
     def _pix_destroy(pix):
-        ptr_to_pix = ffi.new('PIX **', pix)
-        lept.pixDestroy(ptr_to_pix)
+        p_pix = ffi.new('PIX **', pix)
+        lept.pixDestroy(p_pix)
         # print('pix destroy ' + repr(pix))
 
 
+class Box:
+    """Wrapper around Leptonica's BOX objects.
+
+    See class Pix for notes about reference counting.
+    """
+
+    def __init__(self, box):
+        self._box = ffi.gc(box, Box._box_destroy)
+
+    def __repr__(self):
+        if self._box:
+            return '<leptonica.Box x={0} y={1} w={2} h={3}>'.format(
+                self.x, self.y, self.w, self.h)
+        return '<leptonica.Box NULL>'
+
+    @property
+    def x(self):
+        return self._box.x
+
+    @property
+    def y(self):
+        return self._box.y
+
+    @property
+    def w(self):
+        return self._box.w
+
+    @property
+    def h(self):
+        return self._box.h
+
+    @staticmethod
+    def _box_destroy(box):
+        p_box = ffi.new('BOX **', box)
+        lept.boxDestroy(p_box)
+
+
 @lru_cache(maxsize=1)
 def get_leptonica_version():
     """Get Leptonica version string.

ocrmypdf/lib/compile_leptonica.py

@@ -42,6 +42,18 @@ struct PixColormap
     l_int32          n;         /* number of color entries used            */
 };
 typedef struct PixColormap  PIXCMAP;
+
+struct Box
+{
+    l_int32            x;
+    l_int32            y;
+    l_int32            w;
+    l_int32            h;
+    l_uint32           refcount;      /* reference count (1 if no clones)  */
+
+};
+typedef struct Box    BOX;
+
 """)
 
 ffi.cdef("""
@@ -50,10 +62,17 @@ PIX * pixScale ( PIX *pixs, l_float32 scalex, l_float32 scaley );
 l_int32 pixFindSkew ( PIX *pixs, l_float32 *pangle, l_float32 *pconf );
 l_int32 pixWriteImpliedFormat ( const char *filename, PIX *pix, l_int32 quality, l_int32 progressive );
 void pixDestroy ( PIX **ppix );
+
+PIX *
+pixEndianByteSwapNew(PIX  *pixs);
+
 PIX * pixDeskew ( PIX *pixs, l_int32 redsearch );
 char * getLeptonicaVersion (  );
 l_int32 pixCorrelationBinary(PIX *pix1, PIX *pix2, l_float32 *pval);
 PIX *pixRotate180(PIX *pixd, PIX *pixs);
+PIX *
+pixRotateOrth(PIX     *pixs,
+              l_int32  quads);
 
 l_int32 pixCountPixels ( PIX *pix, l_int32 *pcount, l_int32 *tab8 );
 PIX * pixAnd ( PIX *pixd, PIX *pixs1, PIX *pixs2 );
@@ -62,6 +81,59 @@ l_int32 * makePixelSumTab8 ( void );
 PIX * pixDeserializeFromMemory ( const l_uint32 *data, size_t nbytes );
 l_int32 pixSerializeToMemory ( PIX *pixs, l_uint32 **pdata, size_t *pnbytes );
 
+PIX * pixConvertRGBToLuminance(PIX *pixs);
+
+PIX * pixRemoveColormap(PIX *pixs, l_int32  type);
+
+l_int32
+pixOtsuAdaptiveThreshold(PIX       *pixs,
+                         l_int32    sx,
+                         l_int32    sy,
+                         l_int32    smoothx,
+                         l_int32    smoothy,
+                         l_float32  scorefract,
+                         PIX      **ppixth,
+                         PIX      **ppixd);
+
+PIX *
+pixOtsuThreshOnBackgroundNorm(PIX       *pixs,
+                              PIX       *pixim,
+                              l_int32    sx,
+                              l_int32    sy,
+                              l_int32    thresh,
+                              l_int32    mincount,
+                              l_int32    bgval,
+                              l_int32    smoothx,
+                              l_int32    smoothy,
+                              l_float32  scorefract,
+                              l_int32   *pthresh);
+
+PIX *
+pixCleanBackgroundToWhite(PIX       *pixs,
+                          PIX       *pixim,
+                          PIX       *pixg,
+                          l_float32  gamma,
+                          l_int32    blackval,
+                          l_int32    whiteval);
+
+BOX *
+pixFindPageForeground(PIX         *pixs,
+                      l_int32      threshold,
+                      l_int32      mindist,
+                      l_int32      erasedist,
+                      l_int32      pagenum,
+                      l_int32      showmorph,
+                      l_int32      display,
+                      const char  *pdfdir);
+
+PIX *
+pixClipRectangle(PIX   *pixs,
+                 BOX   *box,
+                 BOX  **pboxc);
+
+void
+boxDestroy(BOX  **pbox);
+
 void lept_free(void *ptr);
 """)
 

ocrmypdf/main.py

@@ -188,6 +188,10 @@ advanced.add_argument(
     '--tesseract-timeout', default=180.0, type=float, metavar='SECONDS',
     help='give up on OCR after the timeout, but copy the preprocessed page '
          'into the final output')
+advanced.add_argument(
+    '--rotate-pages-threshold', default=14.0, type=float, metavar='CONFIDENCE',
+    help="only rotate pages when confidence is above this value (arbitrary "
+         "units reported by tesseract)")
 
 debugging = parser.add_argument_group(
     "Debugging",
@@ -234,13 +238,18 @@ if options.pdf_renderer == 'tesseract' and tesseract.version() < '3.04.01' \
         "Some PDF viewers will fail to find searchable text.\n"
         "--pdf-renderer=tesseract is not recommended.")
 
-if any((options.deskew, options.clean, options.clean_final)):
+if any((options.clean, options.clean_final)):
     try:
         from . import unpaper
-    except ImportError:
+        if unpaper.version() < '6.1':
+            complain(
+                "The installed 'unpaper' is not supported. "
+                "Install version 6.1 or newer.")
+            sys.exit(ExitCode.missing_dependency)
+    except FileNotFoundError:
         complain(
             "Install the 'unpaper' program to use --deskew or --clean.")
-        sys.exit(ExitCode.bad_args)
+        sys.exit(ExitCode.missing_dependency)
 else:
     unpaper = None
 
@@ -378,7 +387,7 @@ def cleanup_working_files(*args):
 @transform(
     input=options.input_file,
     filter=formatter('(?i)\.pdf'),
-    output=work_folder + '{basename[0]}.repaired.pdf',
+    output=os.path.join(work_folder, '{basename[0]}.repaired.pdf'),
     extras=[_log, _pdfinfo, _pdfinfo_lock])
 def repair_pdf(
         input_file,
@@ -529,15 +538,29 @@ def orient_page(
         270: '⇦'
     }
 
+    apply_correction = False
+    description = ''
+    if orient_conf.confidence >= options.rotate_pages_threshold:
+        if orient_conf.angle != 0:
+            apply_correction = True
+            description = ' - will rotate'
+        else:
+            description = ' - rotation appears correct'
+    else:
+        if orient_conf.angle != 0:
+            description = ' - confidence too low to rotate'
+        else:
+            description = ' - no change'
+
     log.info(
         '{0:4d}: page is facing {1}, confidence {2:.2f}{3}'.format(
             page_number(preview),
             direction.get(orient_conf.angle, '?'),
             orient_conf.confidence,
-            ' - correcting rotation' if orient_conf.angle != 0 else '')
+            description)
     )
 
-    if orient_conf.angle == 0:
+    if not apply_correction:
         re_symlink(page_pdf, output_file)
     else:
         writer = pypdf.PdfFileWriter()
@@ -550,6 +573,12 @@ def orient_page(
         with open(output_file, 'wb') as out:
             writer.write(out)
 
+        with pdfinfo_lock:
+            pageno = int(os.path.basename(page_pdf)[0:6]) - 1
+            pageinfo = pdfinfo[pageno].copy()
+            pageinfo['rotated'] = orient_conf.angle
+            pdfinfo[pageno] = pageinfo
+
 
 @transform(
     input=orient_page,
@@ -768,6 +797,10 @@ def render_hocr_debug_page(
                          showBoundingboxes=True, invisibleText=False)
 
 
+class PdfMergeFailedError(Exception):
+    pass
+
+
 @active_if(options.pdf_renderer == 'hocr')
 @collate(
     input=[render_hocr_page, select_image_layer],
@@ -826,8 +859,13 @@ def add_text_layer(
         log.info("{0:4d}: rotating image layer {1} degrees".format(
             page_number(image), rotation, tx, ty))
 
-    page_text.mergeRotatedScaledTranslatedPage(
-        page_image, rotation, 1.0, tx, ty, expand=False)
+    try:
+        page_text.mergeRotatedScaledTranslatedPage(
+            page_image, rotation, 1.0, tx, ty, expand=False)
+    except (AttributeError, ValueError) as e:
+        if 'writeToStream' in str(e) or 'invalid literal' in str(e):
+            raise PdfMergeFailedError() from e
+
 
     pdf_output = pypdf.PdfFileWriter()
     pdf_output.addPage(page_text)
@@ -1004,49 +1042,106 @@ def cleanup_ruffus_error_message(msg):
     return msg
 
 
+def do_ruffus_exception(ruffus_five_tuple):
+    """Replace the elaborate ruffus stack trace with a user friendly
+    description of the error message that occurred."""
+
+    task_name, job_name, exc_name, exc_value, exc_stack = ruffus_five_tuple
+    if exc_name == 'builtins.SystemExit':
+        match = re.search(r"\.(.+?)\)", exc_value)
+        exit_code_name = match.groups()[0]
+        exit_code = getattr(ExitCode, exit_code_name, 'other_error')
+        return exit_code
+    elif exc_name == 'ruffus.ruffus_exceptions.MissingInputFileError':
+        _log.error(cleanup_ruffus_error_message(exc_value))
+        return ExitCode.input_file
+    elif exc_name == 'builtins.TypeError':
+        # Even though repair_pdf will fail, ruffus will still try
+        # to call split_pages with no input files, likely due to a bug
+        if task_name == 'split_pages':
+            _log.error("Input file '{0}' is not a valid PDF".format(
+                options.input_file))
+            return ExitCode.input_file
+    elif exc_name == 'subprocess.CalledProcessError':
+        # It's up to the subprocess handler to report something useful
+        msg = "Error occurred while running this command:"
+        _log.error(msg + '\n' + exc_value)
+        return ExitCode.child_process_error
+    elif exc_name == 'ocrmypdf.main.PdfMergeFailedError':
+        _log.error(textwrap.dedent("""\
+            Failed to merge PDF image layer with OCR layer
+
+            Usually this happens because the input PDF file is mal-formed and
+            ocrmypdf cannot automatically correct the problem on its own.
+
+            Try using
+                ocrmypdf --pdf-renderer tesseract  [..other args..]
+            """))
+        return ExitCode.input_file
+    elif exc_name == 'PyPDF2.utils.PdfReadError' and \
+            'not been decrypted' in exc_value:
+        _log.error(textwrap.dedent("""\
+            Input PDF uses either an encryption algorithm or a PDF security
+            handler that is not supported by ocrmypdf.
+
+            For information about this PDF's security use
+                qpdf --show-encryption [...input PDF...]
+
+            (Only algorithms "R = 1" and "R = 2" are supported.)
+
+            """))
+        return ExitCode.encrypted_pdf
+    elif not options.verbose:
+        _log.error(exc_stack)
+        return ExitCode.other_error
+
+
+def traverse_ruffus_exception(e):
+    """Walk through a RethrownJobError and find the first exception.
+
+    The exit code will be based on this, even if multiple exceptions occurred
+    at the same time."""
+
+    if isinstance(e[0], str) and len(e) == 5:
+        return do_ruffus_exception(e)
+    elif hasattr(e, '__iter__'):
+        for exc in e:
+            return traverse_ruffus_exception(exc)
+
+
 def run_pipeline():
     if not options.jobs:
         options.jobs = available_cpu_count()
     try:
-        options.history_file = os.path.join(work_folder, 'ruffus_history.sqlite')
+        options.history_file = os.path.join(
+            work_folder, 'ruffus_history.sqlite')
         cmdline.run(options)
     except ruffus_exceptions.RethrownJobError as e:
         if options.verbose:
-            _log.debug(e)
+            _log.debug(str(e))  # stringify exception so logger doesn't have to
 
-        # Yuck. Hunt through the ruffus exception to find out what the
-        # return code is supposed to be.
-        # Ruffus flattens the exception to a string, throwing away all kinds
-        # of helpful details
-        # task_name, job_name - ruffus status
-        # exc_name - class name of exception
-        # exc_value - irritating string that makes impossible to recover
-        #   exception object
-        # exc_stack - string that contains traceback of exception
-        for exc in e.args:
-            task_name, job_name, exc_name, exc_value, exc_stack = exc
-            if exc_name == 'builtins.SystemExit':
-                match = re.search(r"\.(.+?)\)", exc_value)
-                exit_code_name = match.groups()[0]
-                exit_code = getattr(ExitCode, exit_code_name, 'other_error')
-                return exit_code
-            elif exc_name == 'ruffus.ruffus_exceptions.MissingInputFileError':
-                _log.error(cleanup_ruffus_error_message(exc_value))
-                return ExitCode.input_file
-            elif exc_name == 'builtins.TypeError':
-                # Even though repair_pdf will fail, ruffus will still try
-                # to call split_pages with no input files, likely due to a bug
-                if task_name == 'split_pages':
-                    _log.error("Input file '{0}' is not a valid PDF".format(
-                        options.input_file))
-                    return ExitCode.input_file
-            elif exc_name == 'subprocess.CalledProcessError':
-                # It's up to the subprocess handler to report something useful
-                msg = "Error occurred while running this command:"
-                _log.error(msg + '\n' + exc_value)
-                return ExitCode.child_process_error
+        # Ruffus flattens exception to 5 element tuples. Because of a bug
+        # in <= 2.6.3 it may present either the single:
+        #   (task, job, exc, value, stack)
+        # or something like:
+        #   [[(task, job, exc, value, stack)]]
+        #
+        # Generally cross-process exception marshalling doesn't work well
+        # and ruffus doesn't support because BaseException has its own
+        # implementation of __reduce__ that attempts to reconstruct the
+        # exception based on e.__init__(e.args).
+        #
+        # Attempting to log the exception directly marshalls it to the logger
+        # which is probably in another process, so it's better to log only
+        # data from the exception at this point.
 
-        return ExitCode.other_error
+        exitcode = traverse_ruffus_exception(e.args)
+        if exitcode is None:
+            _log.error("Unexpected ruffus exception: " + str(e))
+            _log.error(repr(e))
+            return ExitCode.other_error
+        else:
+            return exitcode
     except Exception as e:
         _log.error(e)
         return ExitCode.other_error
@@ -1055,6 +1150,20 @@ def run_pipeline():
         _log.warning('Output file: The generated PDF/A file is INVALID')
         return ExitCode.invalid_output_pdfa
 
+    with _pdfinfo_lock:
+        _log.debug(_pdfinfo)
+        direction = {0: 'n', 90: 'e',
+                     180: 's', 270: 'w'}
+        orientations = []
+        for n, page in enumerate(_pdfinfo):
+            angle = _pdfinfo[n].get('rotated', 0)
+            if angle != 0:
+                orientations.append('{0}{1}'.format(
+                    n + 1,
+                    direction.get(angle, '')))
+        if orientations:
+            _log.info('Page orientations detected: ' + ' '.join(orientations))
+
     return ExitCode.ok
 
 

ocrmypdf/pageinfo.py

@@ -3,10 +3,13 @@
 
 from subprocess import Popen, PIPE
 from decimal import Decimal, getcontext
+from math import hypot
 import re
 import sys
 import PyPDF2 as pypdf
+from collections import namedtuple
 
+matrix_mult = pypdf.pdf.utils.matrixMultiply
 
 FRIENDLY_COLORSPACE = {
     '/DeviceGray': 'gray',
@@ -19,7 +22,11 @@ FRIENDLY_COLORSPACE = {
     '/Indexed': 'index',
     '/Separation': 'sep',
     '/DeviceN': 'devn',
-    '/Pattern': '-'
+    '/Pattern': '-',
+    '/G': 'gray',  # Abbreviations permitted in inline images
+    '/RGB': 'rgb',
+    '/CMYK': 'cmyk',
+    '/I': 'index',
 }
 
 FRIENDLY_ENCODING = {
@@ -27,6 +34,13 @@ FRIENDLY_ENCODING = {
     '/DCTDecode': 'jpeg',
     '/JPXDecode': 'jpx',
     '/JBIG2Decode': 'jbig2',
+    '/CCF': 'ccitt',  # Abbreviations permitted in inline images
+    '/DCT': 'jpeg',
+    '/AHx': 'asciihex',
+    '/A85': 'ascii85',
+    '/LZW': 'lzw',
+    '/Fl': 'flate',
+    '/RL': 'runlength'
 }
 
 FRIENDLY_COMP = {
@@ -38,47 +52,165 @@ FRIENDLY_COMP = {
 }
 
 
-def _page_has_inline_images(page):
-    # PDF always uses \r\n for separator regardless of platform
-    # Really basic heuristic that might trigger the odd false positive
-    # This is only finds the first image and is not quite spec compliant
-    try:
-        contents = page.getContents()
-        data = contents.getData()
-    except AttributeError:
-        # If we can't access the contents or data (empty page?) then there
-        # are no inline images
-        return False
+def _matrix_from_shorthand(shorthand):
+    """Convert from PDF matrix shorthand to full matrix
 
-    begin_image, image_data, end_image = False, False, False
-    for data in re.split(b'\s+', data):
-        if data == b'BI':
-            begin_image = True
-        elif data == b'ID':
-            image_data = True
-        elif data == b'EI':
-            end_image = True
-        if all((begin_image, image_data, end_image)):
-            return True
-    return False
+    PDF 1.7 spec defines a shorthand for describing the entries of a matrix
+    since the last column is always (0, 0, 1).
+    """
+
+    a, b, c, d, e, f = map(float, shorthand)
+    return ((a, b, 0),
+            (c, d, 0),
+            (e, f, 1))
 
 
-def _find_page_images(page, pageinfo):
+def _shorthand_from_matrix(matrix):
+    """Convert from transformation matrix to PDF shorthand."""
+    a, b = matrix[0][0], matrix[0][1]
+    c, d = matrix[1][0], matrix[1][1]
+    e, f = matrix[2][0], matrix[2][1]
+    return tuple(map(float, (a, b, c, d, e, f)))
+
+
+ContentsInfo = namedtuple('ContentsInfo', ['raster_settings', 'inline_images'])
+
+
+def _interpret_contents(contentstream):
+    operations = contentstream.operations
+    stack = []
+    ctm = _matrix_from_shorthand((1, 0, 0, 1, 0, 0))
+    image_raster_settings = []
+    inline_images = []
+
+    for op in operations:
+        operands, command = op
+        if command == b'q':
+            stack.append(ctm)
+            if len(stack) > 32:
+                raise RuntimeError("PDF graphics stack overflow")
+        elif command == b'Q':
+            ctm = stack.pop()
+        elif command == b'cm':
+            ctm = matrix_mult(
+                _matrix_from_shorthand(operands), ctm)
+        elif command == b'Do':
+            image_name = operands[0]
+            image_raster_settings.append(
+                (image_name, _shorthand_from_matrix(ctm)))
+        elif command == b'INLINE IMAGE':
+            settings = operands['settings']
+            inline_images.append(
+                (settings, _shorthand_from_matrix(ctm)))
+
+    return ContentsInfo(
+        raster_settings=image_raster_settings,
+        inline_images=inline_images)
+
+
+def _get_dpi(ctm_shorthand, image_size):
+    """Given the transformation matrix and image size, find the image DPI.
+
+    PDFs do not include image resolution information within image data.
+    Instead, the PDF page content stream describes the location where the
+    image will be rasterized, and the effective resolution is the ratio of the
+    pixel size to raster target size.
+
+    Normally a scanned PDF has the paper size set appropriately but this is
+    not guaranteed. The most common case is a cropped image will change the
+    page size (/CropBox) without altering the page content stream. That means
+    it is not sufficient to assume that the image fills the page, even though
+    that is the most common case.
+
+    A PDF image may be scaled (always), cropped, translated, rotated in place
+    to an arbitrary angle (rarely) and skewed. Only equal area mappings can
+    be expressed, that is, it is not necessary to consider distortions where
+    the effective DPI varies with position.
+
+    To determine the image scale, transform an offset axis vector v0 (0, 0),
+    width-axis vector v0 (1, 0), height-axis vector vh (0, 1) with the matrix,
+    which gives the dimensions of the image in PDF units. From there we can
+    compare to actual image dimensions. PDF uses
+    row vector * matrix_tranposed unlike the traditional
+    matrix * column vector.
+
+    The offset, width and height vectors can be combined in a matrix and
+    multiplied by the transform matrix. Then we want to calculated
+        magnitude(width_vector - offset_vector)
+    and
+        magnitude(height_vector - offset_vector)
+
+    When the above is worked out algebraically, the effect of translation
+    cancels out, and the vector magnitudes become functions of the nonzero
+    transformation matrix indices. The results of the derivation are used
+    in this code.
+
+    pdfimages -list does calculate the DPI in some way that is not completely
+    naive, but it does not get the DPI of rotated images right, so cannot be
+    used anymore to validate this. Photoshop works, or using Acrobat to
+    rotate the image back to normal.
+
+    It does not matter if the image is partially cropped, or even out of the
+    /MediaBox.
+
+    """
+
+    a, b, c, d, _, _ = ctm_shorthand
+
+    # Calculate the width and height of the image in PDF units
+    image_drawn_width = hypot(a, b)
+    image_drawn_height = hypot(c, d)
+
+    # The scale of the image is pixels per PDF unit (1/72")
+    scale_w = image_size[0] / image_drawn_width
+    scale_h = image_size[1] / image_drawn_height
+
+    # DPI = scale * 72
+    dpi_w = scale_w * 72.0
+    dpi_h = scale_h * 72.0
+
+    return (dpi_w, dpi_h)
+
+
+def _find_page_inline_images(page, pageinfo, contentsinfo):
+    "Find inline images on the page"
+
+    for n, im in enumerate(contentsinfo.inline_images):
+        settings, shorthand = im
+        image = {}
+        image['name'] = str('inline-%02d' % n)
+        image['width'] = settings['/W']
+        image['height'] = settings['/H']
+        image['bpc'] = settings['/BPC']
+        image['color'] = FRIENDLY_COLORSPACE.get(settings['/CS'], '-')
+        image['comp'] = FRIENDLY_COMP.get(image['color'], '?')
+        if '/F' in settings:
+            filter_ = settings['/F']
+            if isinstance(filter_, pypdf.generic.ArrayObject):
+                filter_ = filter_[0]
+            image['enc'] = FRIENDLY_ENCODING.get(filter_, 'image')
+        else:
+            image['enc'] = 'image'
+
+        dpi_w, dpi_h = _get_dpi(shorthand, (image['width'], image['height']))
+        image['dpi_w'], image['dpi_h'] = Decimal(dpi_w), Decimal(dpi_h)
+        yield image
+
+
+def _find_page_regular_images(page, pageinfo, contentsinfo):
+    "Find images stored in XObject resources"
+
     try:
         page['/Resources']['/XObject']
     except KeyError:
         return
-
-    # Look for XObject (out of line images)
     for xobj in page['/Resources']['/XObject']:
         # PyPDF2 returns the keys as an iterator
         pdfimage = page['/Resources']['/XObject'][xobj]
         if pdfimage['/Subtype'] != '/Image':
             continue
-        if '/ImageMask' in pdfimage:
-            if pdfimage['/ImageMask']:
-                continue
         image = {}
+        image['name'] = str(xobj)
         image['width'] = pdfimage['/Width']
         image['height'] = pdfimage['/Height']
         image['bpc'] = pdfimage['/BitsPerComponent']
@@ -98,12 +230,41 @@ def _find_page_images(page, pageinfo):
             image['color'] = 'jpx' if image['enc'] == 'jpx' else '?'
 
         image['comp'] = FRIENDLY_COMP.get(image['color'], '?')
-        image['dpi_w'] = image['width'] / pageinfo['width_inches']
-        image['dpi_h'] = image['height'] / pageinfo['height_inches']
+
+        # Bit of a hack... infer grayscale if component count is uncertain
+        # but encoding must be monochrome. This happens if a monochrome image
+        # has an ICC profile attached. Better solution would be to examine
+        # the ICC profile.
+        if image['comp'] == '?' and image['enc'] in ('ccitt', 'jbig2'):
+            image['comp'] = FRIENDLY_COMP['gray']
+
+        image['dpi_w'] = image['dpi_h'] = 0
+
+        for raster in contentsinfo.raster_settings:
+            # Loop in case the same image is display multiple times on a page
+            if raster[0] != image['name']:
+                continue
+            shorthand = raster[1]
+
+            dpi_w, dpi_h = _get_dpi(
+                shorthand, (image['width'], image['height']))
+
+            # When image is used multiple times take the highest DPI it is
+            # rendered at
+            image['dpi_w'] = max(dpi_w, image.get('dpi_w', 0))
+            image['dpi_h'] = max(dpi_h, image.get('dpi_h', 0))
+
+        image['dpi_w'] = Decimal(image['dpi_w'])
+        image['dpi_h'] = Decimal(image['dpi_h'])
         image['dpi'] = (image['dpi_w'] * image['dpi_h']) ** Decimal(0.5)
         yield image
 
 
+def _find_page_images(page, pageinfo, contentsinfo):
+    yield from _find_page_inline_images(page, pageinfo, contentsinfo)
+    yield from _find_page_regular_images(page, pageinfo, contentsinfo)
+
+
 def _page_has_text(pdf, page):
     # Simple test
     text = page.extractText()
@@ -141,12 +302,14 @@ def _pdf_get_pageinfo(infile, pageno: int):
     pageinfo['width_inches'] = width_pt / Decimal(72.0)
     pageinfo['height_inches'] = height_pt / Decimal(72.0)
 
-    pageinfo['images'] = [im for im in _find_page_images(page, pageinfo)]
+    try:
+        contentstream = pypdf.pdf.ContentStream(page.getContents(), pdf)
+    except AttributeError as e:
+        return pageinfo
 
-    # Look for inline images
-    if _page_has_inline_images(page):
-        raise NotImplementedError(
-            "Warning: input PDF contains inline images - not supported")
+    contentsinfo = _interpret_contents(contentstream)
+    pageinfo['images'] = [im for im in _find_page_images(
+                                page, pageinfo, contentsinfo)]
 
     if pageinfo['images']:
         xres = max(image['dpi_w'] for image in pageinfo['images'])
@@ -164,3 +327,17 @@ def pdf_get_all_pageinfo(infile):
     pdf = pypdf.PdfFileReader(infile)
     getcontext().prec = 6
     return [_pdf_get_pageinfo(infile, n) for n in range(pdf.numPages)]
+
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument('infile')
+    args = parser.parse_args()
+    info = pdf_get_all_pageinfo(args.infile)
+    from pprint import pprint
+    pprint(info)
+
+
+if __name__ == '__main__':
+    main()

ocrmypdf/pdfa.py

@@ -5,10 +5,13 @@
 
 from __future__ import print_function, absolute_import, division
 from string import Template
-from subprocess import Popen, PIPE
-import os
 import codecs
-from . import get_program
+import pkg_resources
+
+ICC_PROFILE_RELPATH = 'data/sRGB.icc'
+
+SRGB_ICC_PROFILE = pkg_resources.resource_filename(
+    'ocrmypdf', ICC_PROFILE_RELPATH)
 
 
 # This is a template written in PostScript which is needed to create PDF/A
@@ -93,38 +96,9 @@ def _get_pdfa_def(icc_profile, icc_identifier, pdfmark):
     return result
 
 
-def _get_postscript_icc_path():
-    "Parse Ghostscript's help message to find where iccprofiles are stored"
-
-    p_gs = Popen([get_program('gs'), '--help'], close_fds=True,
-                 universal_newlines=True,
-                 stdout=PIPE, stderr=PIPE)
-    out, _ = p_gs.communicate()
-    lines = out.splitlines()
-
-    def search_paths(lines):
-        seeking = True
-        for line in lines:
-            if seeking:
-                if line.startswith('Search path'):
-                    seeking = False
-                    continue
-            else:
-                if line.strip().startswith('/'):
-                    yield from (
-                        path.strip() for path in line.split(':')
-                        if path.strip() != '')
-    for root in search_paths(lines):
-        path = os.path.realpath(os.path.join(root, '../iccprofiles'))
-        if os.path.exists(path):
-            return path
-
-    raise FileNotFoundError("Could not find Ghostscript's iccprofiles")
-
-
 def generate_pdfa_def(target_filename, pdfmark, icc='sRGB'):
     if icc == 'sRGB':
-        icc_profile = os.path.join(_get_postscript_icc_path(), 'srgb.icc')
+        icc_profile = SRGB_ICC_PROFILE
     else:
         raise NotImplementedError("Only supporting sRGB")
 

ocrmypdf/tesseract.py

@@ -98,7 +98,8 @@ def get_orientation(input_file, language: list, timeout: float, log):
         return OrientationConfidence(angle=0, confidence=0.0)
     except CalledProcessError as e:
         tesseract_log_output(log, e.output, input_file)
-        if 'Image too large' in e.output:
+        if ('Too few characters. Skipping this page' in e.output or
+                'Image too large' in e.output):
             return OrientationConfidence(0, 0)
         raise e from e
     else:

ocrmypdf/unpaper.py

@@ -3,7 +3,7 @@
 # unpaper documentation:
 # https://github.com/Flameeyes/unpaper/blob/master/doc/basic-concepts.md
 
-from subprocess import Popen, PIPE
+from subprocess import CalledProcessError, STDOUT, check_output, check_call
 from tempfile import NamedTemporaryFile
 import sys
 import os
@@ -17,10 +17,9 @@ def version():
         get_program('unpaper'),
         '--version'
     ]
-    p_unpaper = Popen(args_unpaper, close_fds=True, universal_newlines=True,
-                      stdout=PIPE, stderr=PIPE)
-    version, _ = p_unpaper.communicate(timeout=5)
-
+    version = check_output(
+        args_unpaper, close_fds=True, universal_newlines=True,
+        stderr=STDOUT, timeout=5)
     return version.strip()
 
 
@@ -68,15 +67,17 @@ def run(input_file, output_file, dpi, log, mode_args):
         os.unlink(output_pnm.name)
 
         args_unpaper.extend([input_pnm.name, output_pnm.name])
-        p_unpaper = Popen(
-            args_unpaper, close_fds=True,
-            universal_newlines=True, stdout=PIPE, stderr=PIPE
-            )
-        out, err = p_unpaper.communicate()
-        log.debug(out)
-        log.debug(err)
-
-        Image.open(output_pnm.name).save(output_file)
+        try:
+            stdout = check_output(
+                args_unpaper, close_fds=True,
+                universal_newlines=True, stderr=STDOUT,
+                )
+        except CalledProcessError as e:
+            log.debug(e.output)
+            raise e from e
+        else:
+            log.debug(stdout)
+            Image.open(output_pnm.name).save(output_file)
 
 
 def deskew(input_file, output_file, dpi, log):

setup.py

@@ -209,7 +209,6 @@ setup(
         ],
     setup_requires=[
         'setuptools_scm',
-        'setuptools_scm_git_archive',
         'cffi>=1.5.0',
         'pytest-runner'
     ],
@@ -218,7 +217,7 @@ setup(
         'ocrmypdf/lib/compile_leptonica.py:ffi'
     ],
     install_requires=[
-        'ruffus>=2.6.3',
+        'ruffus==2.6.3',
         'Pillow>=3.0.0',
         'reportlab>=3.1.44',
         'PyPDF2>=1.25.1',
@@ -231,5 +230,6 @@ setup(
             'ocrmypdf = ocrmypdf.main:run_pipeline'
         ],
     },
+    package_data={'ocrmypdf': ['data/sRGB.icc']},
     include_package_data=True,
     zip_safe=False)

share/etc-apt-sources.list

@@ -0,0 +1,4 @@
+deb http://httpredir.debian.org/debian stretch main
+deb http://httpredir.debian.org/debian stretch-updates main
+deb http://security.debian.org stretch/updates main
+deb http://ftp.de.debian.org/debian sid main contrib non-free

tests/resources/README.rst

@@ -47,12 +47,13 @@ These test resources are assemblies from other previously mentioned files, relea
 
 - cardinal.pdf (four cardinal directions, rotated copies of LinnSequencer.jpg)
 - ccitt.pdf (LinnSequencer.jpg, converted to CCITT encoding)
+- encrypted_algo4.pdf (congress.jpg, encrypted with algorithm 4 - not supported by PyPDF2)
 - graph_ocred.pdf (from graph.pdf)
 - jbig2.pdf (congress.jpg, converted to JBIG2 encoding)
 - multipage.pdf (from several other files)
 - palette.pdf (congress.jpg, converted to a 256-color palette)
 - skew.pdf (from c02-22.pdf)
-- skew-encrypted.pdf (skew.pdf with encrypted applied)
+- skew-encrypted.pdf (skew.pdf with encryption - access supported by PyPDF2)
 
 
 .. _`Wikimedia: LinnSequencer`: https://upload.wikimedia.org/wikipedia/en/b/b7/LinnSequencer_hardware_MIDI_sequencer_brochure_page_2_300dpi.jpg
@@ -63,4 +64,4 @@ These test resources are assemblies from other previously mentioned files, relea
 
 .. _`Wikimedia: Pandas text analysis.png`: https://en.wikipedia.org/wiki/File:Pandas_text_analysis.png
 
-.. _`Wikimedia: JPEG2000 Lichtenstein`: https://en.wikipedia.org/wiki/JPEG_2000#/media/File:Jpeg2000_2-level_wavelet_transform-lichtenstein.png
+.. _`Wikimedia: JPEG2000 Lichtenstein`: https://en.wikipedia.org/wiki/JPEG_2000#/media/File:Jpeg2000_2-level_wavelet_transform-lichtenstein.png

tests/spoof/unpaper_oldversion.py

@@ -0,0 +1,14 @@
+#!/usr/bin/env python3
+import sys
+
+def main():
+    if sys.argv[1] == '--version':
+        print('0.5')
+        sys.exit(0)
+
+    print("Only supports --version")
+    sys.exit(1)
+
+
+if __name__ == '__main__':
+    main()

tests/test_main.py

@@ -28,6 +28,11 @@ TEST_OUTPUT = os.environ.get(
     default=os.path.join(PROJECT_ROOT, 'tests', 'output', 'main'))
 
 
+def running_in_docker():
+    # Docker creates a file named /.dockerinit
+    return os.path.exists('/.dockerinit')
+
+
 def setup_module():
     with suppress(FileNotFoundError):
         shutil.rmtree(TEST_OUTPUT)
@@ -105,6 +110,8 @@ def spoof_tesseract_noop():
 
 @pytest.fixture
 def spoof_tesseract_cache():
+    if running_in_docker():
+        return os.environ.copy()
     return spoof('tesseract', "tesseract_cache.py")
 
 
@@ -318,11 +325,6 @@ def test_monochrome_correlation():
     'tesseract',
     ])
 def test_autorotate(spoof_tesseract_cache, renderer):
-    import ocrmypdf.ghostscript as ghostscript
-    import logging
-
-    gslog = logging.getLogger()
-
     # cardinal.pdf contains four copies of an image rotated in each cardinal
     # direction - these ones are "burned in" not tagged with /Rotate
     out = check_ocrmypdf('cardinal.pdf', 'test_autorotate_%s.pdf' % renderer,
@@ -336,6 +338,36 @@ def test_autorotate(spoof_tesseract_cache, renderer):
         assert correlation > 0.80
 
 
+def test_autorotate_threshold_low(spoof_tesseract_cache):
+    out = check_ocrmypdf('cardinal.pdf', 'test_autorotate_threshold_low.pdf',
+                         '--rotate-pages-threshold', '1',
+                         '-r', '-v', '1', env=spoof_tesseract_cache)
+
+    # Low threshold -> always rotate -> expect high correlation between
+    # reference page and test page
+    correlation = check_monochrome_correlation(
+        reference_pdf=_infile('cardinal.pdf'),
+        reference_pageno=1,
+        test_pdf=out,
+        test_pageno=3)
+    assert correlation > 0.80
+
+
+def test_autorotate_threshold_high(spoof_tesseract_cache):
+    out = check_ocrmypdf('cardinal.pdf', 'test_autorotate_threshold_high.pdf',
+                         '--rotate-pages-threshold', '99',
+                         '-r', '-v', '1', env=spoof_tesseract_cache)
+
+    # High threshold -> never rotate -> expect low correlation since
+    # test page will not be rotated
+    correlation = check_monochrome_correlation(
+        reference_pdf=_infile('cardinal.pdf'),
+        reference_pageno=1,
+        test_pdf=out,
+        test_pageno=3)
+    assert correlation < 0.10
+
+
 @pytest.mark.parametrize('renderer', [
     'hocr',
     'tesseract',
@@ -408,6 +440,8 @@ def test_missing_docinfo(spoof_tesseract_noop):
     assert p.returncode == ExitCode.ok, err
 
 
+@pytest.mark.skipif(running_in_docker(),
+                    reason="writes to tests/resources")
 def test_uppercase_extension(spoof_tesseract_noop):
     shutil.copy(_infile("skew.pdf"), _infile("UPPERCASE.PDF"))
     try:
@@ -484,6 +518,8 @@ def test_tesseract_crash_autorotate(spoof_tesseract_crash):
     assert sh.returncode == ExitCode.child_process_error
     assert not os.path.exists(_outfile('wontwork.pdf'))
     assert "ERROR" in err
+    print(out)
+    print(err)
 
 
 @pytest.mark.parametrize('renderer', [
@@ -494,3 +530,24 @@ def test_tesseract_image_too_big(renderer, spoof_tesseract_big_image_error):
     check_ocrmypdf(
         'hugemono.pdf', 'hugemono_%s.pdf' % renderer, '-r',
         '--pdf-renderer', renderer, env=spoof_tesseract_big_image_error)
+
+
+def test_no_unpaper():
+    env = os.environ.copy()
+    env['OCRMYPDF_UNPAPER'] = os.path.abspath('./spoof/no_unpaper_here.py')
+    sh, out, err = run_ocrmypdf_env(
+        'c02-22.pdf', 'wont_be_created.pdf', '--clean', env=env)
+    assert sh.returncode == ExitCode.missing_dependency
+
+
+def test_old_unpaper():
+    env = os.environ.copy()
+    env['OCRMYPDF_UNPAPER'] = os.path.abspath('./spoof/unpaper_oldversion.py')
+    sh, out, err = run_ocrmypdf_env(
+        'c02-22.pdf', 'wont_be_created.pdf', '--clean', env=env)
+    assert sh.returncode == ExitCode.missing_dependency
+
+
+def test_algo4():
+    sh, _, _ = run_ocrmypdf_env('encrypted_algo4.pdf', 'wontwork.pdf')
+    assert sh.returncode == ExitCode.encrypted_pdf

tests/test_pageinfo.py

@@ -103,8 +103,8 @@ def test_single_page_image():
     assert pdfimage['bpc'] == 8
 
     # DPI in a 1"x1" is the image width
-    assert pdfimage['dpi_w'] == 8
-    assert pdfimage['dpi_h'] == 8
+    assert abs(pdfimage['dpi_w'] - 8) < 1e-5
+    assert abs(pdfimage['dpi_h'] - 8) < 1e-5
 
 
 def test_single_page_inline_image():
@@ -120,8 +120,12 @@ def test_single_page_inline_image():
         pdf.showPage()
         pdf.save()
 
-    with pytest.raises(NotImplementedError):
-        pageinfo.pdf_get_all_pageinfo(filename)
+    pdfinfo = pageinfo.pdf_get_all_pageinfo(filename)
+    print(pdfinfo)
+    pdfimage = pdfinfo[0]['images'][0]
+    assert (pdfimage['dpi_w'] - 8) < 1e-5
+    assert pdfimage['color'] != '-'
+    assert pdfimage['width'] == 8
 
 
 def test_jpeg():
@@ -131,4 +135,5 @@ def test_jpeg():
 
     pdfimage = pdfinfo[0]['images'][0]
     assert pdfimage['enc'] == 'jpeg'
+    assert (pdfimage['dpi_w'] - 150) < 1e-5