Metadata-Version: 2.1
Name: pyvips
Version: 2.1.16
Summary: binding for the libvips image processing library, API mode
Home-page: https://github.com/libvips/pyvips
Author: John Cupitt
Author-email: jcupitt@gmail.com
License: MIT
Description: README
        ======
        
        .. image:: https://travis-ci.org/libvips/pyvips.svg?branch=master
            :alt: Build Status
            :target: https://travis-ci.org/libvips/pyvips
        
        PyPI package:
        
        https://pypi.python.org/pypi/pyvips
        
        conda package:
        
        https://anaconda.org/conda-forge/pyvips
        
        We have formatted docs online here:
        
        https://libvips.github.io/pyvips/
        
        This module wraps the libvips image processing library:
        
        https://libvips.github.io/libvips/
        
        The libvips docs are also very useful:
        
        https://libvips.github.io/libvips/API/current/
        
        If you have the development headers for libvips installed and have a working C
        compiler, this module will use cffi API mode to try to build a libvips 
        binary extension for your Python. 
        
        If it is unable to build a binary extension, it will use cffi ABI mode
        instead and only needs the libvips shared library. This takes longer to
        start up and is typically ~20% slower in execution.  You can find out how
        pyvips installed with ``pip show pyvips``.
        
        This binding passes the vips test suite cleanly and with no leaks under
        python2.7 - python3.6, pypy and pypy3 on Windows, macOS and Linux. 
        
        How it works
        ------------
        
        Programs that use ``pyvips`` don't manipulate images directly, instead
        they create pipelines of image processing operations building on a source
        image. When the end of the pipe is connected to a destination, the whole
        pipeline executes at once, streaming the image in parallel from source to
        destination a section at a time.
        
        Because ``pyvips`` is parallel, it's quick, and because it doesn't need to
        keep entire images in memory, it's light.  For example, the libvips 
        speed and memory use benchmark:
        
        https://github.com/libvips/libvips/wiki/Speed-and-memory-use
        
        Loads a large tiff image, shrinks by 10%, sharpens, and saves again. On this
        test ``pyvips`` is typically 3x faster than ImageMagick and needs 5x less
        memory. 
        
        There's a handy chapter in the docs explaining how libvips opens files,
        which gives some more background.
        
        http://libvips.github.io/libvips/API/current/How-it-opens-files.md.html
        
        conda Install
        -------------
        
        The conda package includes a matching libvips binary, so just enter:
        
        .. code-block:: shell
        
            $ conda install --channel conda-forge pyvips
        
        Non-conda install
        -----------------
        
        First, you need the libvips shared library on your library search path, version
        8.2 or later, though at least version 8.9 is required for all features to work. 
        On Linux and macOS, you can just install via your package manager; on Windows you
        can download a pre-compiled binary from the libvips website.
        
        https://libvips.github.io/libvips/install.html
        
        Next, install this package, perhaps:
        
        .. code-block:: shell
        
            $ pip install --user pyvips
        
        On Windows, you'll need a 64-bit Python. The official one works well. 
        You will also need to add ``vips-dev-x.y\bin`` to your ``PATH`` so
        that pyvips can find all the DLLs it needs. You can either do this in the
        **Advanced System Settings** control panel, or you can just change
        ``PATH`` in your Python program.
        
        If you set the PATH environment variable in the control panel, you can use
        the ``vips`` command-line tools, which I find useful. However, this will add
        a lot of extra DLLs to your search path and they might conflict with other
        programs, so it's usually safer just to set ``PATH`` in your program.
        
        To set ``PATH`` from within Python, you need something like this at the start:
        
        .. code-block:: python
        
            import os
            vipshome = 'c:\\vips-dev-8.7\\bin'
            os.environ['PATH'] = vipshome + ';' + os.environ['PATH']
        
        Now when you import pyvips, it should be able to find the DLLs.
        
        Example
        -------
        
        This sample program loads a JPG image, doubles the value of every green pixel,
        sharpens, and then writes the image back to the filesystem again:
        
        .. code-block:: python
        
            import pyvips
        
            image = pyvips.Image.new_from_file('some-image.jpg', access='sequential')
            image *= [1, 2, 1]
            mask = pyvips.Image.new_from_array([[-1, -1, -1],
                                                [-1, 16, -1],
                                                [-1, -1, -1]
                                               ], scale=8)
            image = image.conv(mask, precision='integer')
            image.write_to_file('x.jpg')
        
        
        Notes
        -----
        
        Local user install:
        
        .. code-block:: shell
        
            $ pip3 install -e .
            $ pypy -m pip --user -e .
        
        Run all tests:
        
        .. code-block:: shell
        
            $ tox 
        
        Run test suite:
        
        .. code-block:: shell
        
            $ tox test
        
        Run a specific test:
        
        .. code-block:: shell
        
            $ pytest-3 tests/test_saveload.py
        
        Run perf tests:
        
        .. code-block:: shell
        
           $ cd tests/perf
           $ ./run.sh
        
        Stylecheck:
        
        .. code-block:: shell
        
            $ tox qa
        
        Generate HTML docs in ``doc/build/html``:
        
        .. code-block:: shell
        
            $ cd doc; sphinx-build -bhtml . build/html
        
        Regenerate autodocs:
        
        .. code-block:: shell
        
            $ cd doc; \
              python3 -c "import pyvips; pyvips.Operation.generate_sphinx_all()" > x 
        
        And copy-paste ``x`` into the obvious place in ``doc/vimage.rst``. See
        `examples/gen-enums.py` to regenerate all enums.
        
        Update version number:
        
        .. code-block:: shell
        
            $ vi pyvips/version.py
            $ vi doc/conf.py
        
        Update pypi package:
        
        .. code-block:: shell
        
            $ python3 setup.py sdist
            $ twine upload dist/*
            $ git tag -a v2.1.12 -m "as uploaded to pypi"
            $ git push origin v2.1.12
        
        
Keywords: image processing
Platform: UNKNOWN
Classifier: Development Status :: 5 - Production/Stable
Classifier: Environment :: Console
Classifier: Intended Audience :: Developers
Classifier: Intended Audience :: Science/Research
Classifier: Topic :: Multimedia :: Graphics
Classifier: Topic :: Multimedia :: Graphics :: Graphics Conversion
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.3
Classifier: Programming Language :: Python :: 3.4
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: Implementation :: PyPy
Classifier: Programming Language :: Python :: Implementation :: CPython
Provides-Extra: doc
Provides-Extra: test
