<!DOCTYPE html>
<!--[if IE 8]><html class="no-js lt-ie9" lang="en" > <![endif]-->
<!--[if gt IE 8]><!--> <html class="no-js" lang="en" > <!--<![endif]-->
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>PIL.Image — Pillow (PIL Fork) 5.4.1 documentation</title>
<script type="text/javascript" src="../../_static/js/modernizr.min.js"></script>
<script type="text/javascript" id="documentation_options" data-url_root="../../" src="../../_static/documentation_options.js"></script>
<script type="text/javascript" src="../../_static/jquery.js"></script>
<script type="text/javascript" src="../../_static/underscore.js"></script>
<script type="text/javascript" src="../../_static/doctools.js"></script>
<script type="text/javascript" src="../../_static/language_data.js"></script>
<script type="text/javascript" src="../../_static/js/script.js"></script>
<script type="text/javascript" src="../../_static/js/theme.js"></script>
<link rel="stylesheet" href="../../_static/css/theme.css" type="text/css" />
<link rel="stylesheet" href="../../_static/pygments.css" type="text/css" />
<link rel="author" title="About these documents" href="../../about.html" />
<link rel="index" title="Index" href="../../genindex.html" />
<link rel="search" title="Search" href="../../search.html" />
</head>
<body class="wy-body-for-nav">
<div class="wy-grid-for-nav">
<nav data-toggle="wy-nav-shift" class="wy-nav-side">
<div class="wy-side-scroll">
<div class="wy-side-nav-search" >
<a href="../../index.html" class="icon icon-home"> Pillow (PIL Fork)
</a>
<div class="version">
5.4.1
</div>
<div role="search">
<form id="rtd-search-form" class="wy-form" action="../../search.html" method="get">
<input type="text" name="q" placeholder="Search docs" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
</div>
</div>
<div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="main navigation">
<ul>
<li class="toctree-l1"><a class="reference internal" href="../../installation.html">Installation</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../handbook/index.html">Handbook</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../reference/index.html">Reference</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../porting.html">Porting</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../about.html">About</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../releasenotes/index.html">Release Notes</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../deprecations.html">Deprecations and removals</a></li>
</ul>
</div>
</div>
</nav>
<section data-toggle="wy-nav-shift" class="wy-nav-content-wrap">
<nav class="wy-nav-top" aria-label="top navigation">
<i data-toggle="wy-nav-top" class="fa fa-bars"></i>
<a href="../../index.html">Pillow (PIL Fork)</a>
</nav>
<div class="wy-nav-content">
<div class="rst-content">
<div role="navigation" aria-label="breadcrumbs navigation">
<ul class="wy-breadcrumbs">
<li><a href="../../index.html">Docs</a> »</li>
<li><a href="../index.html">Module code</a> »</li>
<li>PIL.Image</li>
<li class="wy-breadcrumbs-aside">
</li>
</ul>
<hr/>
</div>
<div role="main" class="document" itemscope="itemscope" itemtype="http://schema.org/Article">
<div itemprop="articleBody">
<h1>Source code for PIL.Image</h1><div class="highlight"><pre>
<span></span><span class="c1">#</span>
<span class="c1"># The Python Imaging Library.</span>
<span class="c1"># $Id$</span>
<span class="c1">#</span>
<span class="c1"># the Image class wrapper</span>
<span class="c1">#</span>
<span class="c1"># partial release history:</span>
<span class="c1"># 1995-09-09 fl Created</span>
<span class="c1"># 1996-03-11 fl PIL release 0.0 (proof of concept)</span>
<span class="c1"># 1996-04-30 fl PIL release 0.1b1</span>
<span class="c1"># 1999-07-28 fl PIL release 1.0 final</span>
<span class="c1"># 2000-06-07 fl PIL release 1.1</span>
<span class="c1"># 2000-10-20 fl PIL release 1.1.1</span>
<span class="c1"># 2001-05-07 fl PIL release 1.1.2</span>
<span class="c1"># 2002-03-15 fl PIL release 1.1.3</span>
<span class="c1"># 2003-05-10 fl PIL release 1.1.4</span>
<span class="c1"># 2005-03-28 fl PIL release 1.1.5</span>
<span class="c1"># 2006-12-02 fl PIL release 1.1.6</span>
<span class="c1"># 2009-11-15 fl PIL release 1.1.7</span>
<span class="c1">#</span>
<span class="c1"># Copyright (c) 1997-2009 by Secret Labs AB. All rights reserved.</span>
<span class="c1"># Copyright (c) 1995-2009 by Fredrik Lundh.</span>
<span class="c1">#</span>
<span class="c1"># See the README file for information on usage and redistribution.</span>
<span class="c1">#</span>
<span class="c1"># VERSION is deprecated and will be removed in Pillow 6.0.0.</span>
<span class="c1"># PILLOW_VERSION is deprecated and will be removed after that.</span>
<span class="c1"># Use __version__ instead.</span>
<span class="kn">from</span> <span class="nn">.</span> <span class="k">import</span> <span class="n">VERSION</span><span class="p">,</span> <span class="n">PILLOW_VERSION</span><span class="p">,</span> <span class="n">__version__</span><span class="p">,</span> <span class="n">_plugins</span>
<span class="kn">from</span> <span class="nn">._util</span> <span class="k">import</span> <span class="n">py3</span>
<span class="kn">import</span> <span class="nn">logging</span>
<span class="kn">import</span> <span class="nn">warnings</span>
<span class="kn">import</span> <span class="nn">math</span>
<span class="k">try</span><span class="p">:</span>
<span class="kn">import</span> <span class="nn">builtins</span>
<span class="k">except</span> <span class="ne">ImportError</span><span class="p">:</span>
<span class="kn">import</span> <span class="nn">__builtin__</span>
<span class="n">builtins</span> <span class="o">=</span> <span class="n">__builtin__</span>
<span class="kn">from</span> <span class="nn">.</span> <span class="k">import</span> <span class="n">ImageMode</span>
<span class="kn">from</span> <span class="nn">._binary</span> <span class="k">import</span> <span class="n">i8</span>
<span class="kn">from</span> <span class="nn">._util</span> <span class="k">import</span> <span class="n">isPath</span><span class="p">,</span> <span class="n">isStringType</span><span class="p">,</span> <span class="n">deferred_error</span>
<span class="kn">import</span> <span class="nn">os</span>
<span class="kn">import</span> <span class="nn">sys</span>
<span class="kn">import</span> <span class="nn">io</span>
<span class="kn">import</span> <span class="nn">struct</span>
<span class="kn">import</span> <span class="nn">atexit</span>
<span class="c1"># type stuff</span>
<span class="kn">import</span> <span class="nn">numbers</span>
<span class="k">try</span><span class="p">:</span>
<span class="c1"># Python 3</span>
<span class="kn">from</span> <span class="nn">collections.abc</span> <span class="k">import</span> <span class="n">Callable</span>
<span class="k">except</span> <span class="ne">ImportError</span><span class="p">:</span>
<span class="c1"># Python 2.7</span>
<span class="kn">from</span> <span class="nn">collections</span> <span class="k">import</span> <span class="n">Callable</span>
<span class="c1"># Silence warnings</span>
<span class="k">assert</span> <span class="n">VERSION</span>
<span class="k">assert</span> <span class="n">PILLOW_VERSION</span>
<span class="n">logger</span> <span class="o">=</span> <span class="n">logging</span><span class="o">.</span><span class="n">getLogger</span><span class="p">(</span><span class="vm">__name__</span><span class="p">)</span>
<span class="k">class</span> <span class="nc">DecompressionBombWarning</span><span class="p">(</span><span class="ne">RuntimeWarning</span><span class="p">):</span>
<span class="k">pass</span>
<span class="k">class</span> <span class="nc">DecompressionBombError</span><span class="p">(</span><span class="ne">Exception</span><span class="p">):</span>
<span class="k">pass</span>
<span class="k">class</span> <span class="nc">_imaging_not_installed</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
<span class="c1"># module placeholder</span>
<span class="k">def</span> <span class="nf">__getattr__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="nb">id</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">ImportError</span><span class="p">(</span><span class="s2">"The _imaging C module is not installed"</span><span class="p">)</span>
<span class="c1"># Limit to around a quarter gigabyte for a 24 bit (3 bpp) image</span>
<span class="n">MAX_IMAGE_PIXELS</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="mi">1024</span> <span class="o">*</span> <span class="mi">1024</span> <span class="o">*</span> <span class="mi">1024</span> <span class="o">//</span> <span class="mi">4</span> <span class="o">//</span> <span class="mi">3</span><span class="p">)</span>
<span class="k">try</span><span class="p">:</span>
<span class="c1"># If the _imaging C module is not present, Pillow will not load.</span>
<span class="c1"># Note that other modules should not refer to _imaging directly;</span>
<span class="c1"># import Image and use the Image.core variable instead.</span>
<span class="c1"># Also note that Image.core is not a publicly documented interface,</span>
<span class="c1"># and should be considered private and subject to change.</span>
<span class="kn">from</span> <span class="nn">.</span> <span class="k">import</span> <span class="n">_imaging</span> <span class="k">as</span> <span class="n">core</span>
<span class="k">if</span> <span class="n">__version__</span> <span class="o">!=</span> <span class="nb">getattr</span><span class="p">(</span><span class="n">core</span><span class="p">,</span> <span class="s1">'PILLOW_VERSION'</span><span class="p">,</span> <span class="kc">None</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">ImportError</span><span class="p">(</span><span class="s2">"The _imaging extension was built for another "</span>
<span class="s2">"version of Pillow or PIL:</span><span class="se">\n</span><span class="s2">"</span>
<span class="s2">"Core version: </span><span class="si">%s</span><span class="se">\n</span><span class="s2">"</span>
<span class="s2">"Pillow version: </span><span class="si">%s</span><span class="s2">"</span> <span class="o">%</span>
<span class="p">(</span><span class="nb">getattr</span><span class="p">(</span><span class="n">core</span><span class="p">,</span> <span class="s1">'PILLOW_VERSION'</span><span class="p">,</span> <span class="kc">None</span><span class="p">),</span>
<span class="n">__version__</span><span class="p">))</span>
<span class="k">except</span> <span class="ne">ImportError</span> <span class="k">as</span> <span class="n">v</span><span class="p">:</span>
<span class="n">core</span> <span class="o">=</span> <span class="n">_imaging_not_installed</span><span class="p">()</span>
<span class="c1"># Explanations for ways that we know we might have an import error</span>
<span class="k">if</span> <span class="nb">str</span><span class="p">(</span><span class="n">v</span><span class="p">)</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="s2">"Module use of python"</span><span class="p">):</span>
<span class="c1"># The _imaging C module is present, but not compiled for</span>
<span class="c1"># the right version (windows only). Print a warning, if</span>
<span class="c1"># possible.</span>
<span class="n">warnings</span><span class="o">.</span><span class="n">warn</span><span class="p">(</span>
<span class="s2">"The _imaging extension was built for another version "</span>
<span class="s2">"of Python."</span><span class="p">,</span>
<span class="ne">RuntimeWarning</span>
<span class="p">)</span>
<span class="k">elif</span> <span class="nb">str</span><span class="p">(</span><span class="n">v</span><span class="p">)</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="s2">"The _imaging extension"</span><span class="p">):</span>
<span class="n">warnings</span><span class="o">.</span><span class="n">warn</span><span class="p">(</span><span class="nb">str</span><span class="p">(</span><span class="n">v</span><span class="p">),</span> <span class="ne">RuntimeWarning</span><span class="p">)</span>
<span class="k">elif</span> <span class="s2">"Symbol not found: _PyUnicodeUCS2_"</span> <span class="ow">in</span> <span class="nb">str</span><span class="p">(</span><span class="n">v</span><span class="p">):</span>
<span class="c1"># should match _PyUnicodeUCS2_FromString and</span>
<span class="c1"># _PyUnicodeUCS2_AsLatin1String</span>
<span class="n">warnings</span><span class="o">.</span><span class="n">warn</span><span class="p">(</span>
<span class="s2">"The _imaging extension was built for Python with UCS2 support; "</span>
<span class="s2">"recompile Pillow or build Python --without-wide-unicode. "</span><span class="p">,</span>
<span class="ne">RuntimeWarning</span>
<span class="p">)</span>
<span class="k">elif</span> <span class="s2">"Symbol not found: _PyUnicodeUCS4_"</span> <span class="ow">in</span> <span class="nb">str</span><span class="p">(</span><span class="n">v</span><span class="p">):</span>
<span class="c1"># should match _PyUnicodeUCS4_FromString and</span>
<span class="c1"># _PyUnicodeUCS4_AsLatin1String</span>
<span class="n">warnings</span><span class="o">.</span><span class="n">warn</span><span class="p">(</span>
<span class="s2">"The _imaging extension was built for Python with UCS4 support; "</span>
<span class="s2">"recompile Pillow or build Python --with-wide-unicode. "</span><span class="p">,</span>
<span class="ne">RuntimeWarning</span>
<span class="p">)</span>
<span class="c1"># Fail here anyway. Don't let people run with a mostly broken Pillow.</span>
<span class="c1"># see docs/porting.rst</span>
<span class="k">raise</span>
<span class="c1"># works everywhere, win for pypy, not cpython</span>
<span class="n">USE_CFFI_ACCESS</span> <span class="o">=</span> <span class="nb">hasattr</span><span class="p">(</span><span class="n">sys</span><span class="p">,</span> <span class="s1">'pypy_version_info'</span><span class="p">)</span>
<span class="k">try</span><span class="p">:</span>
<span class="kn">import</span> <span class="nn">cffi</span>
<span class="k">except</span> <span class="ne">ImportError</span><span class="p">:</span>
<span class="n">cffi</span> <span class="o">=</span> <span class="kc">None</span>
<span class="k">try</span><span class="p">:</span>
<span class="kn">from</span> <span class="nn">pathlib</span> <span class="k">import</span> <span class="n">Path</span>
<span class="n">HAS_PATHLIB</span> <span class="o">=</span> <span class="kc">True</span>
<span class="k">except</span> <span class="ne">ImportError</span><span class="p">:</span>
<span class="k">try</span><span class="p">:</span>
<span class="kn">from</span> <span class="nn">pathlib2</span> <span class="k">import</span> <span class="n">Path</span>
<span class="n">HAS_PATHLIB</span> <span class="o">=</span> <span class="kc">True</span>
<span class="k">except</span> <span class="ne">ImportError</span><span class="p">:</span>
<span class="n">HAS_PATHLIB</span> <span class="o">=</span> <span class="kc">False</span>
<span class="k">def</span> <span class="nf">isImageType</span><span class="p">(</span><span class="n">t</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Checks if an object is an image object.</span>
<span class="sd"> .. warning::</span>
<span class="sd"> This function is for internal use only.</span>
<span class="sd"> :param t: object to check if it's an image</span>
<span class="sd"> :returns: True if the object is an image</span>
<span class="sd"> """</span>
<span class="k">return</span> <span class="nb">hasattr</span><span class="p">(</span><span class="n">t</span><span class="p">,</span> <span class="s2">"im"</span><span class="p">)</span>
<span class="c1">#</span>
<span class="c1"># Constants</span>
<span class="n">NONE</span> <span class="o">=</span> <span class="mi">0</span>
<span class="c1"># transpose</span>
<span class="n">FLIP_LEFT_RIGHT</span> <span class="o">=</span> <span class="mi">0</span>
<span class="n">FLIP_TOP_BOTTOM</span> <span class="o">=</span> <span class="mi">1</span>
<span class="n">ROTATE_90</span> <span class="o">=</span> <span class="mi">2</span>
<span class="n">ROTATE_180</span> <span class="o">=</span> <span class="mi">3</span>
<span class="n">ROTATE_270</span> <span class="o">=</span> <span class="mi">4</span>
<span class="n">TRANSPOSE</span> <span class="o">=</span> <span class="mi">5</span>
<span class="n">TRANSVERSE</span> <span class="o">=</span> <span class="mi">6</span>
<span class="c1"># transforms (also defined in Imaging.h)</span>
<span class="n">AFFINE</span> <span class="o">=</span> <span class="mi">0</span>
<span class="n">EXTENT</span> <span class="o">=</span> <span class="mi">1</span>
<span class="n">PERSPECTIVE</span> <span class="o">=</span> <span class="mi">2</span>
<span class="n">QUAD</span> <span class="o">=</span> <span class="mi">3</span>
<span class="n">MESH</span> <span class="o">=</span> <span class="mi">4</span>
<span class="c1"># resampling filters (also defined in Imaging.h)</span>
<span class="n">NEAREST</span> <span class="o">=</span> <span class="n">NONE</span> <span class="o">=</span> <span class="mi">0</span>
<span class="n">BOX</span> <span class="o">=</span> <span class="mi">4</span>
<span class="n">BILINEAR</span> <span class="o">=</span> <span class="n">LINEAR</span> <span class="o">=</span> <span class="mi">2</span>
<span class="n">HAMMING</span> <span class="o">=</span> <span class="mi">5</span>
<span class="n">BICUBIC</span> <span class="o">=</span> <span class="n">CUBIC</span> <span class="o">=</span> <span class="mi">3</span>
<span class="n">LANCZOS</span> <span class="o">=</span> <span class="n">ANTIALIAS</span> <span class="o">=</span> <span class="mi">1</span>
<span class="c1"># dithers</span>
<span class="n">NEAREST</span> <span class="o">=</span> <span class="n">NONE</span> <span class="o">=</span> <span class="mi">0</span>
<span class="n">ORDERED</span> <span class="o">=</span> <span class="mi">1</span> <span class="c1"># Not yet implemented</span>
<span class="n">RASTERIZE</span> <span class="o">=</span> <span class="mi">2</span> <span class="c1"># Not yet implemented</span>
<span class="n">FLOYDSTEINBERG</span> <span class="o">=</span> <span class="mi">3</span> <span class="c1"># default</span>
<span class="c1"># palettes/quantizers</span>
<span class="n">WEB</span> <span class="o">=</span> <span class="mi">0</span>
<span class="n">ADAPTIVE</span> <span class="o">=</span> <span class="mi">1</span>
<span class="n">MEDIANCUT</span> <span class="o">=</span> <span class="mi">0</span>
<span class="n">MAXCOVERAGE</span> <span class="o">=</span> <span class="mi">1</span>
<span class="n">FASTOCTREE</span> <span class="o">=</span> <span class="mi">2</span>
<span class="n">LIBIMAGEQUANT</span> <span class="o">=</span> <span class="mi">3</span>
<span class="c1"># categories</span>
<span class="n">NORMAL</span> <span class="o">=</span> <span class="mi">0</span>
<span class="n">SEQUENCE</span> <span class="o">=</span> <span class="mi">1</span>
<span class="n">CONTAINER</span> <span class="o">=</span> <span class="mi">2</span>
<span class="k">if</span> <span class="nb">hasattr</span><span class="p">(</span><span class="n">core</span><span class="p">,</span> <span class="s1">'DEFAULT_STRATEGY'</span><span class="p">):</span>
<span class="n">DEFAULT_STRATEGY</span> <span class="o">=</span> <span class="n">core</span><span class="o">.</span><span class="n">DEFAULT_STRATEGY</span>
<span class="n">FILTERED</span> <span class="o">=</span> <span class="n">core</span><span class="o">.</span><span class="n">FILTERED</span>
<span class="n">HUFFMAN_ONLY</span> <span class="o">=</span> <span class="n">core</span><span class="o">.</span><span class="n">HUFFMAN_ONLY</span>
<span class="n">RLE</span> <span class="o">=</span> <span class="n">core</span><span class="o">.</span><span class="n">RLE</span>
<span class="n">FIXED</span> <span class="o">=</span> <span class="n">core</span><span class="o">.</span><span class="n">FIXED</span>
<span class="c1"># --------------------------------------------------------------------</span>
<span class="c1"># Registries</span>
<span class="n">ID</span> <span class="o">=</span> <span class="p">[]</span>
<span class="n">OPEN</span> <span class="o">=</span> <span class="p">{}</span>
<span class="n">MIME</span> <span class="o">=</span> <span class="p">{}</span>
<span class="n">SAVE</span> <span class="o">=</span> <span class="p">{}</span>
<span class="n">SAVE_ALL</span> <span class="o">=</span> <span class="p">{}</span>
<span class="n">EXTENSION</span> <span class="o">=</span> <span class="p">{}</span>
<span class="n">DECODERS</span> <span class="o">=</span> <span class="p">{}</span>
<span class="n">ENCODERS</span> <span class="o">=</span> <span class="p">{}</span>
<span class="c1"># --------------------------------------------------------------------</span>
<span class="c1"># Modes supported by this version</span>
<span class="n">_MODEINFO</span> <span class="o">=</span> <span class="p">{</span>
<span class="c1"># NOTE: this table will be removed in future versions. use</span>
<span class="c1"># getmode* functions or ImageMode descriptors instead.</span>
<span class="c1"># official modes</span>
<span class="s2">"1"</span><span class="p">:</span> <span class="p">(</span><span class="s2">"L"</span><span class="p">,</span> <span class="s2">"L"</span><span class="p">,</span> <span class="p">(</span><span class="s2">"1"</span><span class="p">,)),</span>
<span class="s2">"L"</span><span class="p">:</span> <span class="p">(</span><span class="s2">"L"</span><span class="p">,</span> <span class="s2">"L"</span><span class="p">,</span> <span class="p">(</span><span class="s2">"L"</span><span class="p">,)),</span>
<span class="s2">"I"</span><span class="p">:</span> <span class="p">(</span><span class="s2">"L"</span><span class="p">,</span> <span class="s2">"I"</span><span class="p">,</span> <span class="p">(</span><span class="s2">"I"</span><span class="p">,)),</span>
<span class="s2">"F"</span><span class="p">:</span> <span class="p">(</span><span class="s2">"L"</span><span class="p">,</span> <span class="s2">"F"</span><span class="p">,</span> <span class="p">(</span><span class="s2">"F"</span><span class="p">,)),</span>
<span class="s2">"P"</span><span class="p">:</span> <span class="p">(</span><span class="s2">"RGB"</span><span class="p">,</span> <span class="s2">"L"</span><span class="p">,</span> <span class="p">(</span><span class="s2">"P"</span><span class="p">,)),</span>
<span class="s2">"RGB"</span><span class="p">:</span> <span class="p">(</span><span class="s2">"RGB"</span><span class="p">,</span> <span class="s2">"L"</span><span class="p">,</span> <span class="p">(</span><span class="s2">"R"</span><span class="p">,</span> <span class="s2">"G"</span><span class="p">,</span> <span class="s2">"B"</span><span class="p">)),</span>
<span class="s2">"RGBX"</span><span class="p">:</span> <span class="p">(</span><span class="s2">"RGB"</span><span class="p">,</span> <span class="s2">"L"</span><span class="p">,</span> <span class="p">(</span><span class="s2">"R"</span><span class="p">,</span> <span class="s2">"G"</span><span class="p">,</span> <span class="s2">"B"</span><span class="p">,</span> <span class="s2">"X"</span><span class="p">)),</span>
<span class="s2">"RGBA"</span><span class="p">:</span> <span class="p">(</span><span class="s2">"RGB"</span><span class="p">,</span> <span class="s2">"L"</span><span class="p">,</span> <span class="p">(</span><span class="s2">"R"</span><span class="p">,</span> <span class="s2">"G"</span><span class="p">,</span> <span class="s2">"B"</span><span class="p">,</span> <span class="s2">"A"</span><span class="p">)),</span>
<span class="s2">"CMYK"</span><span class="p">:</span> <span class="p">(</span><span class="s2">"RGB"</span><span class="p">,</span> <span class="s2">"L"</span><span class="p">,</span> <span class="p">(</span><span class="s2">"C"</span><span class="p">,</span> <span class="s2">"M"</span><span class="p">,</span> <span class="s2">"Y"</span><span class="p">,</span> <span class="s2">"K"</span><span class="p">)),</span>
<span class="s2">"YCbCr"</span><span class="p">:</span> <span class="p">(</span><span class="s2">"RGB"</span><span class="p">,</span> <span class="s2">"L"</span><span class="p">,</span> <span class="p">(</span><span class="s2">"Y"</span><span class="p">,</span> <span class="s2">"Cb"</span><span class="p">,</span> <span class="s2">"Cr"</span><span class="p">)),</span>
<span class="s2">"LAB"</span><span class="p">:</span> <span class="p">(</span><span class="s2">"RGB"</span><span class="p">,</span> <span class="s2">"L"</span><span class="p">,</span> <span class="p">(</span><span class="s2">"L"</span><span class="p">,</span> <span class="s2">"A"</span><span class="p">,</span> <span class="s2">"B"</span><span class="p">)),</span>
<span class="s2">"HSV"</span><span class="p">:</span> <span class="p">(</span><span class="s2">"RGB"</span><span class="p">,</span> <span class="s2">"L"</span><span class="p">,</span> <span class="p">(</span><span class="s2">"H"</span><span class="p">,</span> <span class="s2">"S"</span><span class="p">,</span> <span class="s2">"V"</span><span class="p">)),</span>
<span class="c1"># Experimental modes include I;16, I;16L, I;16B, RGBa, BGR;15, and</span>
<span class="c1"># BGR;24. Use these modes only if you know exactly what you're</span>
<span class="c1"># doing...</span>
<span class="p">}</span>
<span class="k">if</span> <span class="n">sys</span><span class="o">.</span><span class="n">byteorder</span> <span class="o">==</span> <span class="s1">'little'</span><span class="p">:</span>
<span class="n">_ENDIAN</span> <span class="o">=</span> <span class="s1">'<'</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">_ENDIAN</span> <span class="o">=</span> <span class="s1">'>'</span>
<span class="n">_MODE_CONV</span> <span class="o">=</span> <span class="p">{</span>
<span class="c1"># official modes</span>
<span class="s2">"1"</span><span class="p">:</span> <span class="p">(</span><span class="s1">'|b1'</span><span class="p">,</span> <span class="kc">None</span><span class="p">),</span> <span class="c1"># Bits need to be extended to bytes</span>
<span class="s2">"L"</span><span class="p">:</span> <span class="p">(</span><span class="s1">'|u1'</span><span class="p">,</span> <span class="kc">None</span><span class="p">),</span>
<span class="s2">"LA"</span><span class="p">:</span> <span class="p">(</span><span class="s1">'|u1'</span><span class="p">,</span> <span class="mi">2</span><span class="p">),</span>
<span class="s2">"I"</span><span class="p">:</span> <span class="p">(</span><span class="n">_ENDIAN</span> <span class="o">+</span> <span class="s1">'i4'</span><span class="p">,</span> <span class="kc">None</span><span class="p">),</span>
<span class="s2">"F"</span><span class="p">:</span> <span class="p">(</span><span class="n">_ENDIAN</span> <span class="o">+</span> <span class="s1">'f4'</span><span class="p">,</span> <span class="kc">None</span><span class="p">),</span>
<span class="s2">"P"</span><span class="p">:</span> <span class="p">(</span><span class="s1">'|u1'</span><span class="p">,</span> <span class="kc">None</span><span class="p">),</span>
<span class="s2">"RGB"</span><span class="p">:</span> <span class="p">(</span><span class="s1">'|u1'</span><span class="p">,</span> <span class="mi">3</span><span class="p">),</span>
<span class="s2">"RGBX"</span><span class="p">:</span> <span class="p">(</span><span class="s1">'|u1'</span><span class="p">,</span> <span class="mi">4</span><span class="p">),</span>
<span class="s2">"RGBA"</span><span class="p">:</span> <span class="p">(</span><span class="s1">'|u1'</span><span class="p">,</span> <span class="mi">4</span><span class="p">),</span>
<span class="s2">"CMYK"</span><span class="p">:</span> <span class="p">(</span><span class="s1">'|u1'</span><span class="p">,</span> <span class="mi">4</span><span class="p">),</span>
<span class="s2">"YCbCr"</span><span class="p">:</span> <span class="p">(</span><span class="s1">'|u1'</span><span class="p">,</span> <span class="mi">3</span><span class="p">),</span>
<span class="s2">"LAB"</span><span class="p">:</span> <span class="p">(</span><span class="s1">'|u1'</span><span class="p">,</span> <span class="mi">3</span><span class="p">),</span> <span class="c1"># UNDONE - unsigned |u1i1i1</span>
<span class="s2">"HSV"</span><span class="p">:</span> <span class="p">(</span><span class="s1">'|u1'</span><span class="p">,</span> <span class="mi">3</span><span class="p">),</span>
<span class="c1"># I;16 == I;16L, and I;32 == I;32L</span>
<span class="s2">"I;16"</span><span class="p">:</span> <span class="p">(</span><span class="s1">'<u2'</span><span class="p">,</span> <span class="kc">None</span><span class="p">),</span>
<span class="s2">"I;16B"</span><span class="p">:</span> <span class="p">(</span><span class="s1">'>u2'</span><span class="p">,</span> <span class="kc">None</span><span class="p">),</span>
<span class="s2">"I;16L"</span><span class="p">:</span> <span class="p">(</span><span class="s1">'<u2'</span><span class="p">,</span> <span class="kc">None</span><span class="p">),</span>
<span class="s2">"I;16S"</span><span class="p">:</span> <span class="p">(</span><span class="s1">'<i2'</span><span class="p">,</span> <span class="kc">None</span><span class="p">),</span>
<span class="s2">"I;16BS"</span><span class="p">:</span> <span class="p">(</span><span class="s1">'>i2'</span><span class="p">,</span> <span class="kc">None</span><span class="p">),</span>
<span class="s2">"I;16LS"</span><span class="p">:</span> <span class="p">(</span><span class="s1">'<i2'</span><span class="p">,</span> <span class="kc">None</span><span class="p">),</span>
<span class="s2">"I;32"</span><span class="p">:</span> <span class="p">(</span><span class="s1">'<u4'</span><span class="p">,</span> <span class="kc">None</span><span class="p">),</span>
<span class="s2">"I;32B"</span><span class="p">:</span> <span class="p">(</span><span class="s1">'>u4'</span><span class="p">,</span> <span class="kc">None</span><span class="p">),</span>
<span class="s2">"I;32L"</span><span class="p">:</span> <span class="p">(</span><span class="s1">'<u4'</span><span class="p">,</span> <span class="kc">None</span><span class="p">),</span>
<span class="s2">"I;32S"</span><span class="p">:</span> <span class="p">(</span><span class="s1">'<i4'</span><span class="p">,</span> <span class="kc">None</span><span class="p">),</span>
<span class="s2">"I;32BS"</span><span class="p">:</span> <span class="p">(</span><span class="s1">'>i4'</span><span class="p">,</span> <span class="kc">None</span><span class="p">),</span>
<span class="s2">"I;32LS"</span><span class="p">:</span> <span class="p">(</span><span class="s1">'<i4'</span><span class="p">,</span> <span class="kc">None</span><span class="p">),</span>
<span class="p">}</span>
<span class="k">def</span> <span class="nf">_conv_type_shape</span><span class="p">(</span><span class="n">im</span><span class="p">):</span>
<span class="n">typ</span><span class="p">,</span> <span class="n">extra</span> <span class="o">=</span> <span class="n">_MODE_CONV</span><span class="p">[</span><span class="n">im</span><span class="o">.</span><span class="n">mode</span><span class="p">]</span>
<span class="k">if</span> <span class="n">extra</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="k">return</span> <span class="p">(</span><span class="n">im</span><span class="o">.</span><span class="n">size</span><span class="p">[</span><span class="mi">1</span><span class="p">],</span> <span class="n">im</span><span class="o">.</span><span class="n">size</span><span class="p">[</span><span class="mi">0</span><span class="p">]),</span> <span class="n">typ</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">return</span> <span class="p">(</span><span class="n">im</span><span class="o">.</span><span class="n">size</span><span class="p">[</span><span class="mi">1</span><span class="p">],</span> <span class="n">im</span><span class="o">.</span><span class="n">size</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="n">extra</span><span class="p">),</span> <span class="n">typ</span>
<span class="n">MODES</span> <span class="o">=</span> <span class="nb">sorted</span><span class="p">(</span><span class="n">_MODEINFO</span><span class="p">)</span>
<span class="c1"># raw modes that may be memory mapped. NOTE: if you change this, you</span>
<span class="c1"># may have to modify the stride calculation in map.c too!</span>
<span class="n">_MAPMODES</span> <span class="o">=</span> <span class="p">(</span><span class="s2">"L"</span><span class="p">,</span> <span class="s2">"P"</span><span class="p">,</span> <span class="s2">"RGBX"</span><span class="p">,</span> <span class="s2">"RGBA"</span><span class="p">,</span> <span class="s2">"CMYK"</span><span class="p">,</span> <span class="s2">"I;16"</span><span class="p">,</span> <span class="s2">"I;16L"</span><span class="p">,</span> <span class="s2">"I;16B"</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">getmodebase</span><span class="p">(</span><span class="n">mode</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Gets the "base" mode for given mode. This function returns "L" for</span>
<span class="sd"> images that contain grayscale data, and "RGB" for images that</span>
<span class="sd"> contain color data.</span>
<span class="sd"> :param mode: Input mode.</span>
<span class="sd"> :returns: "L" or "RGB".</span>
<span class="sd"> :exception KeyError: If the input mode was not a standard mode.</span>
<span class="sd"> """</span>
<span class="k">return</span> <span class="n">ImageMode</span><span class="o">.</span><span class="n">getmode</span><span class="p">(</span><span class="n">mode</span><span class="p">)</span><span class="o">.</span><span class="n">basemode</span>
<span class="k">def</span> <span class="nf">getmodetype</span><span class="p">(</span><span class="n">mode</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Gets the storage type mode. Given a mode, this function returns a</span>
<span class="sd"> single-layer mode suitable for storing individual bands.</span>
<span class="sd"> :param mode: Input mode.</span>
<span class="sd"> :returns: "L", "I", or "F".</span>
<span class="sd"> :exception KeyError: If the input mode was not a standard mode.</span>
<span class="sd"> """</span>
<span class="k">return</span> <span class="n">ImageMode</span><span class="o">.</span><span class="n">getmode</span><span class="p">(</span><span class="n">mode</span><span class="p">)</span><span class="o">.</span><span class="n">basetype</span>
<span class="k">def</span> <span class="nf">getmodebandnames</span><span class="p">(</span><span class="n">mode</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Gets a list of individual band names. Given a mode, this function returns</span>
<span class="sd"> a tuple containing the names of individual bands (use</span>
<span class="sd"> :py:method:`~PIL.Image.getmodetype` to get the mode used to store each</span>
<span class="sd"> individual band.</span>
<span class="sd"> :param mode: Input mode.</span>
<span class="sd"> :returns: A tuple containing band names. The length of the tuple</span>
<span class="sd"> gives the number of bands in an image of the given mode.</span>
<span class="sd"> :exception KeyError: If the input mode was not a standard mode.</span>
<span class="sd"> """</span>
<span class="k">return</span> <span class="n">ImageMode</span><span class="o">.</span><span class="n">getmode</span><span class="p">(</span><span class="n">mode</span><span class="p">)</span><span class="o">.</span><span class="n">bands</span>
<span class="k">def</span> <span class="nf">getmodebands</span><span class="p">(</span><span class="n">mode</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Gets the number of individual bands for this mode.</span>
<span class="sd"> :param mode: Input mode.</span>
<span class="sd"> :returns: The number of bands in this mode.</span>
<span class="sd"> :exception KeyError: If the input mode was not a standard mode.</span>
<span class="sd"> """</span>
<span class="k">return</span> <span class="nb">len</span><span class="p">(</span><span class="n">ImageMode</span><span class="o">.</span><span class="n">getmode</span><span class="p">(</span><span class="n">mode</span><span class="p">)</span><span class="o">.</span><span class="n">bands</span><span class="p">)</span>
<span class="c1"># --------------------------------------------------------------------</span>
<span class="c1"># Helpers</span>
<span class="n">_initialized</span> <span class="o">=</span> <span class="mi">0</span>
<span class="k">def</span> <span class="nf">preinit</span><span class="p">():</span>
<span class="sd">"""Explicitly load standard file format drivers."""</span>
<span class="k">global</span> <span class="n">_initialized</span>
<span class="k">if</span> <span class="n">_initialized</span> <span class="o">>=</span> <span class="mi">1</span><span class="p">:</span>
<span class="k">return</span>
<span class="k">try</span><span class="p">:</span>
<span class="kn">from</span> <span class="nn">.</span> <span class="k">import</span> <span class="n">BmpImagePlugin</span>
<span class="k">assert</span> <span class="n">BmpImagePlugin</span>
<span class="k">except</span> <span class="ne">ImportError</span><span class="p">:</span>
<span class="k">pass</span>
<span class="k">try</span><span class="p">:</span>
<span class="kn">from</span> <span class="nn">.</span> <span class="k">import</span> <span class="n">GifImagePlugin</span>
<span class="k">assert</span> <span class="n">GifImagePlugin</span>
<span class="k">except</span> <span class="ne">ImportError</span><span class="p">:</span>
<span class="k">pass</span>
<span class="k">try</span><span class="p">:</span>
<span class="kn">from</span> <span class="nn">.</span> <span class="k">import</span> <span class="n">JpegImagePlugin</span>
<span class="k">assert</span> <span class="n">JpegImagePlugin</span>
<span class="k">except</span> <span class="ne">ImportError</span><span class="p">:</span>
<span class="k">pass</span>
<span class="k">try</span><span class="p">:</span>
<span class="kn">from</span> <span class="nn">.</span> <span class="k">import</span> <span class="n">PpmImagePlugin</span>
<span class="k">assert</span> <span class="n">PpmImagePlugin</span>
<span class="k">except</span> <span class="ne">ImportError</span><span class="p">:</span>
<span class="k">pass</span>
<span class="k">try</span><span class="p">:</span>
<span class="kn">from</span> <span class="nn">.</span> <span class="k">import</span> <span class="n">PngImagePlugin</span>
<span class="k">assert</span> <span class="n">PngImagePlugin</span>
<span class="k">except</span> <span class="ne">ImportError</span><span class="p">:</span>
<span class="k">pass</span>
<span class="c1"># try:</span>
<span class="c1"># import TiffImagePlugin</span>
<span class="c1"># assert TiffImagePlugin</span>
<span class="c1"># except ImportError:</span>
<span class="c1"># pass</span>
<span class="n">_initialized</span> <span class="o">=</span> <span class="mi">1</span>
<span class="k">def</span> <span class="nf">init</span><span class="p">():</span>
<span class="sd">"""</span>
<span class="sd"> Explicitly initializes the Python Imaging Library. This function</span>
<span class="sd"> loads all available file format drivers.</span>
<span class="sd"> """</span>
<span class="k">global</span> <span class="n">_initialized</span>
<span class="k">if</span> <span class="n">_initialized</span> <span class="o">>=</span> <span class="mi">2</span><span class="p">:</span>
<span class="k">return</span> <span class="mi">0</span>
<span class="k">for</span> <span class="n">plugin</span> <span class="ow">in</span> <span class="n">_plugins</span><span class="p">:</span>
<span class="k">try</span><span class="p">:</span>
<span class="n">logger</span><span class="o">.</span><span class="n">debug</span><span class="p">(</span><span class="s2">"Importing </span><span class="si">%s</span><span class="s2">"</span><span class="p">,</span> <span class="n">plugin</span><span class="p">)</span>
<span class="nb">__import__</span><span class="p">(</span><span class="s2">"PIL.</span><span class="si">%s</span><span class="s2">"</span> <span class="o">%</span> <span class="n">plugin</span><span class="p">,</span> <span class="nb">globals</span><span class="p">(),</span> <span class="nb">locals</span><span class="p">(),</span> <span class="p">[])</span>
<span class="k">except</span> <span class="ne">ImportError</span> <span class="k">as</span> <span class="n">e</span><span class="p">:</span>
<span class="n">logger</span><span class="o">.</span><span class="n">debug</span><span class="p">(</span><span class="s2">"Image: failed to import </span><span class="si">%s</span><span class="s2">: </span><span class="si">%s</span><span class="s2">"</span><span class="p">,</span> <span class="n">plugin</span><span class="p">,</span> <span class="n">e</span><span class="p">)</span>
<span class="k">if</span> <span class="n">OPEN</span> <span class="ow">or</span> <span class="n">SAVE</span><span class="p">:</span>
<span class="n">_initialized</span> <span class="o">=</span> <span class="mi">2</span>
<span class="k">return</span> <span class="mi">1</span>
<span class="c1"># --------------------------------------------------------------------</span>
<span class="c1"># Codec factories (used by tobytes/frombytes and ImageFile.load)</span>
<span class="k">def</span> <span class="nf">_getdecoder</span><span class="p">(</span><span class="n">mode</span><span class="p">,</span> <span class="n">decoder_name</span><span class="p">,</span> <span class="n">args</span><span class="p">,</span> <span class="n">extra</span><span class="o">=</span><span class="p">()):</span>
<span class="c1"># tweak arguments</span>
<span class="k">if</span> <span class="n">args</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="n">args</span> <span class="o">=</span> <span class="p">()</span>
<span class="k">elif</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">args</span><span class="p">,</span> <span class="nb">tuple</span><span class="p">):</span>
<span class="n">args</span> <span class="o">=</span> <span class="p">(</span><span class="n">args</span><span class="p">,)</span>
<span class="k">try</span><span class="p">:</span>
<span class="n">decoder</span> <span class="o">=</span> <span class="n">DECODERS</span><span class="p">[</span><span class="n">decoder_name</span><span class="p">]</span>
<span class="k">return</span> <span class="n">decoder</span><span class="p">(</span><span class="n">mode</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span> <span class="o">+</span> <span class="n">extra</span><span class="p">)</span>
<span class="k">except</span> <span class="ne">KeyError</span><span class="p">:</span>
<span class="k">pass</span>
<span class="k">try</span><span class="p">:</span>
<span class="c1"># get decoder</span>
<span class="n">decoder</span> <span class="o">=</span> <span class="nb">getattr</span><span class="p">(</span><span class="n">core</span><span class="p">,</span> <span class="n">decoder_name</span> <span class="o">+</span> <span class="s2">"_decoder"</span><span class="p">)</span>
<span class="k">return</span> <span class="n">decoder</span><span class="p">(</span><span class="n">mode</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span> <span class="o">+</span> <span class="n">extra</span><span class="p">)</span>
<span class="k">except</span> <span class="ne">AttributeError</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">IOError</span><span class="p">(</span><span class="s2">"decoder </span><span class="si">%s</span><span class="s2"> not available"</span> <span class="o">%</span> <span class="n">decoder_name</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">_getencoder</span><span class="p">(</span><span class="n">mode</span><span class="p">,</span> <span class="n">encoder_name</span><span class="p">,</span> <span class="n">args</span><span class="p">,</span> <span class="n">extra</span><span class="o">=</span><span class="p">()):</span>
<span class="c1"># tweak arguments</span>
<span class="k">if</span> <span class="n">args</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="n">args</span> <span class="o">=</span> <span class="p">()</span>
<span class="k">elif</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">args</span><span class="p">,</span> <span class="nb">tuple</span><span class="p">):</span>
<span class="n">args</span> <span class="o">=</span> <span class="p">(</span><span class="n">args</span><span class="p">,)</span>
<span class="k">try</span><span class="p">:</span>
<span class="n">encoder</span> <span class="o">=</span> <span class="n">ENCODERS</span><span class="p">[</span><span class="n">encoder_name</span><span class="p">]</span>
<span class="k">return</span> <span class="n">encoder</span><span class="p">(</span><span class="n">mode</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span> <span class="o">+</span> <span class="n">extra</span><span class="p">)</span>
<span class="k">except</span> <span class="ne">KeyError</span><span class="p">:</span>
<span class="k">pass</span>
<span class="k">try</span><span class="p">:</span>
<span class="c1"># get encoder</span>
<span class="n">encoder</span> <span class="o">=</span> <span class="nb">getattr</span><span class="p">(</span><span class="n">core</span><span class="p">,</span> <span class="n">encoder_name</span> <span class="o">+</span> <span class="s2">"_encoder"</span><span class="p">)</span>
<span class="k">return</span> <span class="n">encoder</span><span class="p">(</span><span class="n">mode</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span> <span class="o">+</span> <span class="n">extra</span><span class="p">)</span>
<span class="k">except</span> <span class="ne">AttributeError</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">IOError</span><span class="p">(</span><span class="s2">"encoder </span><span class="si">%s</span><span class="s2"> not available"</span> <span class="o">%</span> <span class="n">encoder_name</span><span class="p">)</span>
<span class="c1"># --------------------------------------------------------------------</span>
<span class="c1"># Simple expression analyzer</span>
<span class="k">def</span> <span class="nf">coerce_e</span><span class="p">(</span><span class="n">value</span><span class="p">):</span>
<span class="k">return</span> <span class="n">value</span> <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">value</span><span class="p">,</span> <span class="n">_E</span><span class="p">)</span> <span class="k">else</span> <span class="n">_E</span><span class="p">(</span><span class="n">value</span><span class="p">)</span>
<span class="k">class</span> <span class="nc">_E</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
<span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">data</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">data</span> <span class="o">=</span> <span class="n">data</span>
<span class="k">def</span> <span class="nf">__add__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
<span class="k">return</span> <span class="n">_E</span><span class="p">((</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="p">,</span> <span class="s2">"__add__"</span><span class="p">,</span> <span class="n">coerce_e</span><span class="p">(</span><span class="n">other</span><span class="p">)</span><span class="o">.</span><span class="n">data</span><span class="p">))</span>
<span class="k">def</span> <span class="nf">__mul__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
<span class="k">return</span> <span class="n">_E</span><span class="p">((</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="p">,</span> <span class="s2">"__mul__"</span><span class="p">,</span> <span class="n">coerce_e</span><span class="p">(</span><span class="n">other</span><span class="p">)</span><span class="o">.</span><span class="n">data</span><span class="p">))</span>
<span class="k">def</span> <span class="nf">_getscaleoffset</span><span class="p">(</span><span class="n">expr</span><span class="p">):</span>
<span class="n">stub</span> <span class="o">=</span> <span class="p">[</span><span class="s2">"stub"</span><span class="p">]</span>
<span class="n">data</span> <span class="o">=</span> <span class="n">expr</span><span class="p">(</span><span class="n">_E</span><span class="p">(</span><span class="n">stub</span><span class="p">))</span><span class="o">.</span><span class="n">data</span>
<span class="k">try</span><span class="p">:</span>
<span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">,</span> <span class="n">c</span><span class="p">)</span> <span class="o">=</span> <span class="n">data</span> <span class="c1"># simplified syntax</span>
<span class="k">if</span> <span class="p">(</span><span class="n">a</span> <span class="ow">is</span> <span class="n">stub</span> <span class="ow">and</span> <span class="n">b</span> <span class="o">==</span> <span class="s2">"__mul__"</span> <span class="ow">and</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">c</span><span class="p">,</span> <span class="n">numbers</span><span class="o">.</span><span class="n">Number</span><span class="p">)):</span>
<span class="k">return</span> <span class="n">c</span><span class="p">,</span> <span class="mf">0.0</span>
<span class="k">if</span> <span class="n">a</span> <span class="ow">is</span> <span class="n">stub</span> <span class="ow">and</span> <span class="n">b</span> <span class="o">==</span> <span class="s2">"__add__"</span> <span class="ow">and</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">c</span><span class="p">,</span> <span class="n">numbers</span><span class="o">.</span><span class="n">Number</span><span class="p">):</span>
<span class="k">return</span> <span class="mf">1.0</span><span class="p">,</span> <span class="n">c</span>
<span class="k">except</span> <span class="ne">TypeError</span><span class="p">:</span>
<span class="k">pass</span>
<span class="k">try</span><span class="p">:</span>
<span class="p">((</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">,</span> <span class="n">c</span><span class="p">),</span> <span class="n">d</span><span class="p">,</span> <span class="n">e</span><span class="p">)</span> <span class="o">=</span> <span class="n">data</span> <span class="c1"># full syntax</span>
<span class="k">if</span> <span class="p">(</span><span class="n">a</span> <span class="ow">is</span> <span class="n">stub</span> <span class="ow">and</span> <span class="n">b</span> <span class="o">==</span> <span class="s2">"__mul__"</span> <span class="ow">and</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">c</span><span class="p">,</span> <span class="n">numbers</span><span class="o">.</span><span class="n">Number</span><span class="p">)</span> <span class="ow">and</span>
<span class="n">d</span> <span class="o">==</span> <span class="s2">"__add__"</span> <span class="ow">and</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">e</span><span class="p">,</span> <span class="n">numbers</span><span class="o">.</span><span class="n">Number</span><span class="p">)):</span>
<span class="k">return</span> <span class="n">c</span><span class="p">,</span> <span class="n">e</span>
<span class="k">except</span> <span class="ne">TypeError</span><span class="p">:</span>
<span class="k">pass</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"illegal expression"</span><span class="p">)</span>
<span class="c1"># --------------------------------------------------------------------</span>
<span class="c1"># Implementation wrapper</span>
<div class="viewcode-block" id="Image"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image">[docs]</a><span class="k">class</span> <span class="nc">Image</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> This class represents an image object. To create</span>
<span class="sd"> :py:class:`~PIL.Image.Image` objects, use the appropriate factory</span>
<span class="sd"> functions. There's hardly ever any reason to call the Image constructor</span>
<span class="sd"> directly.</span>
<span class="sd"> * :py:func:`~PIL.Image.open`</span>
<span class="sd"> * :py:func:`~PIL.Image.new`</span>
<span class="sd"> * :py:func:`~PIL.Image.frombytes`</span>
<span class="sd"> """</span>
<span class="nb">format</span> <span class="o">=</span> <span class="kc">None</span>
<span class="n">format_description</span> <span class="o">=</span> <span class="kc">None</span>
<span class="n">_close_exclusive_fp_after_loading</span> <span class="o">=</span> <span class="kc">True</span>
<span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="c1"># FIXME: take "new" parameters / other image?</span>
<span class="c1"># FIXME: turn mode and size into delegating properties?</span>
<span class="bp">self</span><span class="o">.</span><span class="n">im</span> <span class="o">=</span> <span class="kc">None</span>
<span class="bp">self</span><span class="o">.</span><span class="n">mode</span> <span class="o">=</span> <span class="s2">""</span>
<span class="bp">self</span><span class="o">.</span><span class="n">_size</span> <span class="o">=</span> <span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span>
<span class="bp">self</span><span class="o">.</span><span class="n">palette</span> <span class="o">=</span> <span class="kc">None</span>
<span class="bp">self</span><span class="o">.</span><span class="n">info</span> <span class="o">=</span> <span class="p">{}</span>
<span class="bp">self</span><span class="o">.</span><span class="n">category</span> <span class="o">=</span> <span class="n">NORMAL</span>
<span class="bp">self</span><span class="o">.</span><span class="n">readonly</span> <span class="o">=</span> <span class="mi">0</span>
<span class="bp">self</span><span class="o">.</span><span class="n">pyaccess</span> <span class="o">=</span> <span class="kc">None</span>
<span class="nd">@property</span>
<span class="k">def</span> <span class="nf">width</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">size</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
<span class="nd">@property</span>
<span class="k">def</span> <span class="nf">height</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">size</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span>
<span class="nd">@property</span>
<span class="k">def</span> <span class="nf">size</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_size</span>
<span class="k">def</span> <span class="nf">_new</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">im</span><span class="p">):</span>
<span class="n">new</span> <span class="o">=</span> <span class="n">Image</span><span class="p">()</span>
<span class="n">new</span><span class="o">.</span><span class="n">im</span> <span class="o">=</span> <span class="n">im</span>
<span class="n">new</span><span class="o">.</span><span class="n">mode</span> <span class="o">=</span> <span class="n">im</span><span class="o">.</span><span class="n">mode</span>
<span class="n">new</span><span class="o">.</span><span class="n">_size</span> <span class="o">=</span> <span class="n">im</span><span class="o">.</span><span class="n">size</span>
<span class="k">if</span> <span class="n">im</span><span class="o">.</span><span class="n">mode</span> <span class="ow">in</span> <span class="p">(</span><span class="s1">'P'</span><span class="p">,</span> <span class="s1">'PA'</span><span class="p">):</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">palette</span><span class="p">:</span>
<span class="n">new</span><span class="o">.</span><span class="n">palette</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">palette</span><span class="o">.</span><span class="n">copy</span><span class="p">()</span>
<span class="k">else</span><span class="p">:</span>
<span class="kn">from</span> <span class="nn">.</span> <span class="k">import</span> <span class="n">ImagePalette</span>
<span class="n">new</span><span class="o">.</span><span class="n">palette</span> <span class="o">=</span> <span class="n">ImagePalette</span><span class="o">.</span><span class="n">ImagePalette</span><span class="p">()</span>
<span class="n">new</span><span class="o">.</span><span class="n">info</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">info</span><span class="o">.</span><span class="n">copy</span><span class="p">()</span>
<span class="k">return</span> <span class="n">new</span>
<span class="c1"># Context manager support</span>
<span class="k">def</span> <span class="nf">__enter__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="k">return</span> <span class="bp">self</span>
<span class="k">def</span> <span class="nf">__exit__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
<div class="viewcode-block" id="Image.close"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image.close">[docs]</a> <span class="k">def</span> <span class="nf">close</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Closes the file pointer, if possible.</span>
<span class="sd"> This operation will destroy the image core and release its memory.</span>
<span class="sd"> The image data will be unusable afterward.</span>
<span class="sd"> This function is only required to close images that have not</span>
<span class="sd"> had their file read and closed by the</span>
<span class="sd"> :py:meth:`~PIL.Image.Image.load` method. See</span>
<span class="sd"> :ref:`file-handling` for more information.</span>
<span class="sd"> """</span>
<span class="k">try</span><span class="p">:</span>
<span class="k">if</span> <span class="nb">hasattr</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="s2">"_close__fp"</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">_close__fp</span><span class="p">()</span>
<span class="bp">self</span><span class="o">.</span><span class="n">fp</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
<span class="bp">self</span><span class="o">.</span><span class="n">fp</span> <span class="o">=</span> <span class="kc">None</span>
<span class="k">except</span> <span class="ne">Exception</span> <span class="k">as</span> <span class="n">msg</span><span class="p">:</span>
<span class="n">logger</span><span class="o">.</span><span class="n">debug</span><span class="p">(</span><span class="s2">"Error closing: </span><span class="si">%s</span><span class="s2">"</span><span class="p">,</span> <span class="n">msg</span><span class="p">)</span>
<span class="k">if</span> <span class="nb">getattr</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="s1">'map'</span><span class="p">,</span> <span class="kc">None</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">map</span> <span class="o">=</span> <span class="kc">None</span>
<span class="c1"># Instead of simply setting to None, we're setting up a</span>
<span class="c1"># deferred error that will better explain that the core image</span>
<span class="c1"># object is gone.</span>
<span class="bp">self</span><span class="o">.</span><span class="n">im</span> <span class="o">=</span> <span class="n">deferred_error</span><span class="p">(</span><span class="ne">ValueError</span><span class="p">(</span><span class="s2">"Operation on closed image"</span><span class="p">))</span></div>
<span class="k">if</span> <span class="n">sys</span><span class="o">.</span><span class="n">version_info</span><span class="o">.</span><span class="n">major</span> <span class="o">>=</span> <span class="mi">3</span><span class="p">:</span>
<span class="k">def</span> <span class="nf">__del__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="k">if</span> <span class="nb">hasattr</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="s2">"_close__fp"</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">_close__fp</span><span class="p">()</span>
<span class="k">if</span> <span class="p">(</span><span class="nb">hasattr</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="s1">'fp'</span><span class="p">)</span> <span class="ow">and</span> <span class="nb">hasattr</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="s1">'_exclusive_fp'</span><span class="p">)</span>
<span class="ow">and</span> <span class="bp">self</span><span class="o">.</span><span class="n">fp</span> <span class="ow">and</span> <span class="bp">self</span><span class="o">.</span><span class="n">_exclusive_fp</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">fp</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
<span class="bp">self</span><span class="o">.</span><span class="n">fp</span> <span class="o">=</span> <span class="kc">None</span>
<span class="k">def</span> <span class="nf">_copy</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">load</span><span class="p">()</span>
<span class="bp">self</span><span class="o">.</span><span class="n">im</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">copy</span><span class="p">()</span>
<span class="bp">self</span><span class="o">.</span><span class="n">pyaccess</span> <span class="o">=</span> <span class="kc">None</span>
<span class="bp">self</span><span class="o">.</span><span class="n">readonly</span> <span class="o">=</span> <span class="mi">0</span>
<span class="k">def</span> <span class="nf">_ensure_mutable</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">readonly</span><span class="p">:</span>
<span class="bp">self</span><span class="o">.</span><span class="n">_copy</span><span class="p">()</span>
<span class="k">else</span><span class="p">:</span>
<span class="bp">self</span><span class="o">.</span><span class="n">load</span><span class="p">()</span>
<span class="k">def</span> <span class="nf">_dump</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">file</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="nb">format</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="o">**</span><span class="n">options</span><span class="p">):</span>
<span class="kn">import</span> <span class="nn">tempfile</span>
<span class="n">suffix</span> <span class="o">=</span> <span class="s1">''</span>
<span class="k">if</span> <span class="nb">format</span><span class="p">:</span>
<span class="n">suffix</span> <span class="o">=</span> <span class="s1">'.'</span><span class="o">+</span><span class="nb">format</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">file</span><span class="p">:</span>
<span class="n">f</span><span class="p">,</span> <span class="n">filename</span> <span class="o">=</span> <span class="n">tempfile</span><span class="o">.</span><span class="n">mkstemp</span><span class="p">(</span><span class="n">suffix</span><span class="p">)</span>
<span class="n">os</span><span class="o">.</span><span class="n">close</span><span class="p">(</span><span class="n">f</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">filename</span> <span class="o">=</span> <span class="n">file</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">filename</span><span class="o">.</span><span class="n">endswith</span><span class="p">(</span><span class="n">suffix</span><span class="p">):</span>
<span class="n">filename</span> <span class="o">=</span> <span class="n">filename</span> <span class="o">+</span> <span class="n">suffix</span>
<span class="bp">self</span><span class="o">.</span><span class="n">load</span><span class="p">()</span>
<span class="k">if</span> <span class="ow">not</span> <span class="nb">format</span> <span class="ow">or</span> <span class="nb">format</span> <span class="o">==</span> <span class="s2">"PPM"</span><span class="p">:</span>
<span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">save_ppm</span><span class="p">(</span><span class="n">filename</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="bp">self</span><span class="o">.</span><span class="n">save</span><span class="p">(</span><span class="n">filename</span><span class="p">,</span> <span class="nb">format</span><span class="p">,</span> <span class="o">**</span><span class="n">options</span><span class="p">)</span>
<span class="k">return</span> <span class="n">filename</span>
<span class="k">def</span> <span class="nf">__eq__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
<span class="k">return</span> <span class="p">(</span><span class="nb">isinstance</span><span class="p">(</span><span class="n">other</span><span class="p">,</span> <span class="n">Image</span><span class="p">)</span> <span class="ow">and</span>
<span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="o">.</span><span class="vm">__name__</span> <span class="o">==</span> <span class="n">other</span><span class="o">.</span><span class="vm">__class__</span><span class="o">.</span><span class="vm">__name__</span> <span class="ow">and</span>
<span class="bp">self</span><span class="o">.</span><span class="n">mode</span> <span class="o">==</span> <span class="n">other</span><span class="o">.</span><span class="n">mode</span> <span class="ow">and</span>
<span class="bp">self</span><span class="o">.</span><span class="n">size</span> <span class="o">==</span> <span class="n">other</span><span class="o">.</span><span class="n">size</span> <span class="ow">and</span>
<span class="bp">self</span><span class="o">.</span><span class="n">info</span> <span class="o">==</span> <span class="n">other</span><span class="o">.</span><span class="n">info</span> <span class="ow">and</span>
<span class="bp">self</span><span class="o">.</span><span class="n">category</span> <span class="o">==</span> <span class="n">other</span><span class="o">.</span><span class="n">category</span> <span class="ow">and</span>
<span class="bp">self</span><span class="o">.</span><span class="n">readonly</span> <span class="o">==</span> <span class="n">other</span><span class="o">.</span><span class="n">readonly</span> <span class="ow">and</span>
<span class="bp">self</span><span class="o">.</span><span class="n">getpalette</span><span class="p">()</span> <span class="o">==</span> <span class="n">other</span><span class="o">.</span><span class="n">getpalette</span><span class="p">()</span> <span class="ow">and</span>
<span class="bp">self</span><span class="o">.</span><span class="n">tobytes</span><span class="p">()</span> <span class="o">==</span> <span class="n">other</span><span class="o">.</span><span class="n">tobytes</span><span class="p">())</span>
<span class="k">def</span> <span class="nf">__ne__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
<span class="n">eq</span> <span class="o">=</span> <span class="p">(</span><span class="bp">self</span> <span class="o">==</span> <span class="n">other</span><span class="p">)</span>
<span class="k">return</span> <span class="ow">not</span> <span class="n">eq</span>
<span class="k">def</span> <span class="nf">__repr__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="k">return</span> <span class="s2">"<</span><span class="si">%s</span><span class="s2">.</span><span class="si">%s</span><span class="s2"> image mode=</span><span class="si">%s</span><span class="s2"> size=</span><span class="si">%d</span><span class="s2">x</span><span class="si">%d</span><span class="s2"> at 0x</span><span class="si">%X</span><span class="s2">>"</span> <span class="o">%</span> <span class="p">(</span>
<span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="o">.</span><span class="vm">__module__</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="o">.</span><span class="vm">__name__</span><span class="p">,</span>
<span class="bp">self</span><span class="o">.</span><span class="n">mode</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">size</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="bp">self</span><span class="o">.</span><span class="n">size</span><span class="p">[</span><span class="mi">1</span><span class="p">],</span>
<span class="nb">id</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
<span class="p">)</span>
<span class="k">def</span> <span class="nf">_repr_png_</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">""" iPython display hook support</span>
<span class="sd"> :returns: png version of the image as bytes</span>
<span class="sd"> """</span>
<span class="kn">from</span> <span class="nn">io</span> <span class="k">import</span> <span class="n">BytesIO</span>
<span class="n">b</span> <span class="o">=</span> <span class="n">BytesIO</span><span class="p">()</span>
<span class="bp">self</span><span class="o">.</span><span class="n">save</span><span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="s1">'PNG'</span><span class="p">)</span>
<span class="k">return</span> <span class="n">b</span><span class="o">.</span><span class="n">getvalue</span><span class="p">()</span>
<span class="nd">@property</span>
<span class="k">def</span> <span class="nf">__array_interface__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="c1"># numpy array interface support</span>
<span class="n">new</span> <span class="o">=</span> <span class="p">{}</span>
<span class="n">shape</span><span class="p">,</span> <span class="n">typestr</span> <span class="o">=</span> <span class="n">_conv_type_shape</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
<span class="n">new</span><span class="p">[</span><span class="s1">'shape'</span><span class="p">]</span> <span class="o">=</span> <span class="n">shape</span>
<span class="n">new</span><span class="p">[</span><span class="s1">'typestr'</span><span class="p">]</span> <span class="o">=</span> <span class="n">typestr</span>
<span class="n">new</span><span class="p">[</span><span class="s1">'version'</span><span class="p">]</span> <span class="o">=</span> <span class="mi">3</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">mode</span> <span class="o">==</span> <span class="s1">'1'</span><span class="p">:</span>
<span class="c1"># Binary images need to be extended from bits to bytes</span>
<span class="c1"># See: https://github.com/python-pillow/Pillow/issues/350</span>
<span class="n">new</span><span class="p">[</span><span class="s1">'data'</span><span class="p">]</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">tobytes</span><span class="p">(</span><span class="s1">'raw'</span><span class="p">,</span> <span class="s1">'L'</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">new</span><span class="p">[</span><span class="s1">'data'</span><span class="p">]</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">tobytes</span><span class="p">()</span>
<span class="k">return</span> <span class="n">new</span>
<span class="k">def</span> <span class="nf">__getstate__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="k">return</span> <span class="p">[</span>
<span class="bp">self</span><span class="o">.</span><span class="n">info</span><span class="p">,</span>
<span class="bp">self</span><span class="o">.</span><span class="n">mode</span><span class="p">,</span>
<span class="bp">self</span><span class="o">.</span><span class="n">size</span><span class="p">,</span>
<span class="bp">self</span><span class="o">.</span><span class="n">getpalette</span><span class="p">(),</span>
<span class="bp">self</span><span class="o">.</span><span class="n">tobytes</span><span class="p">()]</span>
<span class="k">def</span> <span class="nf">__setstate__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">state</span><span class="p">):</span>
<span class="n">Image</span><span class="o">.</span><span class="fm">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
<span class="bp">self</span><span class="o">.</span><span class="n">tile</span> <span class="o">=</span> <span class="p">[]</span>
<span class="n">info</span><span class="p">,</span> <span class="n">mode</span><span class="p">,</span> <span class="n">size</span><span class="p">,</span> <span class="n">palette</span><span class="p">,</span> <span class="n">data</span> <span class="o">=</span> <span class="n">state</span>
<span class="bp">self</span><span class="o">.</span><span class="n">info</span> <span class="o">=</span> <span class="n">info</span>
<span class="bp">self</span><span class="o">.</span><span class="n">mode</span> <span class="o">=</span> <span class="n">mode</span>
<span class="bp">self</span><span class="o">.</span><span class="n">_size</span> <span class="o">=</span> <span class="n">size</span>
<span class="bp">self</span><span class="o">.</span><span class="n">im</span> <span class="o">=</span> <span class="n">core</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="n">mode</span><span class="p">,</span> <span class="n">size</span><span class="p">)</span>
<span class="k">if</span> <span class="n">mode</span> <span class="ow">in</span> <span class="p">(</span><span class="s2">"L"</span><span class="p">,</span> <span class="s2">"P"</span><span class="p">)</span> <span class="ow">and</span> <span class="n">palette</span><span class="p">:</span>
<span class="bp">self</span><span class="o">.</span><span class="n">putpalette</span><span class="p">(</span><span class="n">palette</span><span class="p">)</span>
<span class="bp">self</span><span class="o">.</span><span class="n">frombytes</span><span class="p">(</span><span class="n">data</span><span class="p">)</span>
<div class="viewcode-block" id="Image.tobytes"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image.tobytes">[docs]</a> <span class="k">def</span> <span class="nf">tobytes</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">encoder_name</span><span class="o">=</span><span class="s2">"raw"</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Return image as a bytes object.</span>
<span class="sd"> .. warning::</span>
<span class="sd"> This method returns the raw image data from the internal</span>
<span class="sd"> storage. For compressed image data (e.g. PNG, JPEG) use</span>
<span class="sd"> :meth:`~.save`, with a BytesIO parameter for in-memory</span>
<span class="sd"> data.</span>
<span class="sd"> :param encoder_name: What encoder to use. The default is to</span>
<span class="sd"> use the standard "raw" encoder.</span>
<span class="sd"> :param args: Extra arguments to the encoder.</span>
<span class="sd"> :rtype: A bytes object.</span>
<span class="sd"> """</span>
<span class="c1"># may pass tuple instead of argument list</span>
<span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="n">args</span><span class="p">)</span> <span class="o">==</span> <span class="mi">1</span> <span class="ow">and</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">args</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="nb">tuple</span><span class="p">):</span>
<span class="n">args</span> <span class="o">=</span> <span class="n">args</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
<span class="k">if</span> <span class="n">encoder_name</span> <span class="o">==</span> <span class="s2">"raw"</span> <span class="ow">and</span> <span class="n">args</span> <span class="o">==</span> <span class="p">():</span>
<span class="n">args</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">mode</span>
<span class="bp">self</span><span class="o">.</span><span class="n">load</span><span class="p">()</span>
<span class="c1"># unpack data</span>
<span class="n">e</span> <span class="o">=</span> <span class="n">_getencoder</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">mode</span><span class="p">,</span> <span class="n">encoder_name</span><span class="p">,</span> <span class="n">args</span><span class="p">)</span>
<span class="n">e</span><span class="o">.</span><span class="n">setimage</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="p">)</span>
<span class="n">bufsize</span> <span class="o">=</span> <span class="nb">max</span><span class="p">(</span><span class="mi">65536</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">size</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">*</span> <span class="mi">4</span><span class="p">)</span> <span class="c1"># see RawEncode.c</span>
<span class="n">data</span> <span class="o">=</span> <span class="p">[]</span>
<span class="k">while</span> <span class="kc">True</span><span class="p">:</span>
<span class="n">l</span><span class="p">,</span> <span class="n">s</span><span class="p">,</span> <span class="n">d</span> <span class="o">=</span> <span class="n">e</span><span class="o">.</span><span class="n">encode</span><span class="p">(</span><span class="n">bufsize</span><span class="p">)</span>
<span class="n">data</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">d</span><span class="p">)</span>
<span class="k">if</span> <span class="n">s</span><span class="p">:</span>
<span class="k">break</span>
<span class="k">if</span> <span class="n">s</span> <span class="o"><</span> <span class="mi">0</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">RuntimeError</span><span class="p">(</span><span class="s2">"encoder error </span><span class="si">%d</span><span class="s2"> in tobytes"</span> <span class="o">%</span> <span class="n">s</span><span class="p">)</span>
<span class="k">return</span> <span class="sa">b</span><span class="s2">""</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">data</span><span class="p">)</span></div>
<div class="viewcode-block" id="Image.tostring"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image.tostring">[docs]</a> <span class="k">def</span> <span class="nf">tostring</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kw</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">NotImplementedError</span><span class="p">(</span><span class="s2">"tostring() has been removed. "</span>
<span class="s2">"Please call tobytes() instead."</span><span class="p">)</span></div>
<div class="viewcode-block" id="Image.tobitmap"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image.tobitmap">[docs]</a> <span class="k">def</span> <span class="nf">tobitmap</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="o">=</span><span class="s2">"image"</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Returns the image converted to an X11 bitmap.</span>
<span class="sd"> .. note:: This method only works for mode "1" images.</span>
<span class="sd"> :param name: The name prefix to use for the bitmap variables.</span>
<span class="sd"> :returns: A string containing an X11 bitmap.</span>
<span class="sd"> :raises ValueError: If the mode is not "1"</span>
<span class="sd"> """</span>
<span class="bp">self</span><span class="o">.</span><span class="n">load</span><span class="p">()</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">mode</span> <span class="o">!=</span> <span class="s2">"1"</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"not a bitmap"</span><span class="p">)</span>
<span class="n">data</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">tobytes</span><span class="p">(</span><span class="s2">"xbm"</span><span class="p">)</span>
<span class="k">return</span> <span class="sa">b</span><span class="s2">""</span><span class="o">.</span><span class="n">join</span><span class="p">([</span>
<span class="p">(</span><span class="s2">"#define </span><span class="si">%s</span><span class="s2">_width </span><span class="si">%d</span><span class="se">\n</span><span class="s2">"</span> <span class="o">%</span> <span class="p">(</span><span class="n">name</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">size</span><span class="p">[</span><span class="mi">0</span><span class="p">]))</span><span class="o">.</span><span class="n">encode</span><span class="p">(</span><span class="s1">'ascii'</span><span class="p">),</span>
<span class="p">(</span><span class="s2">"#define </span><span class="si">%s</span><span class="s2">_height </span><span class="si">%d</span><span class="se">\n</span><span class="s2">"</span> <span class="o">%</span> <span class="p">(</span><span class="n">name</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">size</span><span class="p">[</span><span class="mi">1</span><span class="p">]))</span><span class="o">.</span><span class="n">encode</span><span class="p">(</span><span class="s1">'ascii'</span><span class="p">),</span>
<span class="p">(</span><span class="s2">"static char </span><span class="si">%s</span><span class="s2">_bits[] = {</span><span class="se">\n</span><span class="s2">"</span> <span class="o">%</span> <span class="n">name</span><span class="p">)</span><span class="o">.</span><span class="n">encode</span><span class="p">(</span><span class="s1">'ascii'</span><span class="p">),</span> <span class="n">data</span><span class="p">,</span> <span class="sa">b</span><span class="s2">"};"</span>
<span class="p">])</span></div>
<span class="k">def</span> <span class="nf">frombytes</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">data</span><span class="p">,</span> <span class="n">decoder_name</span><span class="o">=</span><span class="s2">"raw"</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Loads this image with pixel data from a bytes object.</span>
<span class="sd"> This method is similar to the :py:func:`~PIL.Image.frombytes` function,</span>
<span class="sd"> but loads data into this image instead of creating a new image object.</span>
<span class="sd"> """</span>
<span class="c1"># may pass tuple instead of argument list</span>
<span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="n">args</span><span class="p">)</span> <span class="o">==</span> <span class="mi">1</span> <span class="ow">and</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">args</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="nb">tuple</span><span class="p">):</span>
<span class="n">args</span> <span class="o">=</span> <span class="n">args</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
<span class="c1"># default format</span>
<span class="k">if</span> <span class="n">decoder_name</span> <span class="o">==</span> <span class="s2">"raw"</span> <span class="ow">and</span> <span class="n">args</span> <span class="o">==</span> <span class="p">():</span>
<span class="n">args</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">mode</span>
<span class="c1"># unpack data</span>
<span class="n">d</span> <span class="o">=</span> <span class="n">_getdecoder</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">mode</span><span class="p">,</span> <span class="n">decoder_name</span><span class="p">,</span> <span class="n">args</span><span class="p">)</span>
<span class="n">d</span><span class="o">.</span><span class="n">setimage</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="p">)</span>
<span class="n">s</span> <span class="o">=</span> <span class="n">d</span><span class="o">.</span><span class="n">decode</span><span class="p">(</span><span class="n">data</span><span class="p">)</span>
<span class="k">if</span> <span class="n">s</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">>=</span> <span class="mi">0</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"not enough image data"</span><span class="p">)</span>
<span class="k">if</span> <span class="n">s</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="o">!=</span> <span class="mi">0</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"cannot decode image data"</span><span class="p">)</span>
<div class="viewcode-block" id="Image.fromstring"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image.fromstring">[docs]</a> <span class="k">def</span> <span class="nf">fromstring</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kw</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">NotImplementedError</span><span class="p">(</span><span class="s2">"fromstring() has been removed. "</span>
<span class="s2">"Please call frombytes() instead."</span><span class="p">)</span></div>
<div class="viewcode-block" id="Image.load"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image.load">[docs]</a> <span class="k">def</span> <span class="nf">load</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Allocates storage for the image and loads the pixel data. In</span>
<span class="sd"> normal cases, you don't need to call this method, since the</span>
<span class="sd"> Image class automatically loads an opened image when it is</span>
<span class="sd"> accessed for the first time.</span>
<span class="sd"> If the file associated with the image was opened by Pillow, then this</span>
<span class="sd"> method will close it. The exception to this is if the image has</span>
<span class="sd"> multiple frames, in which case the file will be left open for seek</span>
<span class="sd"> operations. See :ref:`file-handling` for more information.</span>
<span class="sd"> :returns: An image access object.</span>
<span class="sd"> :rtype: :ref:`PixelAccess` or :py:class:`PIL.PyAccess`</span>
<span class="sd"> """</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">im</span> <span class="ow">and</span> <span class="bp">self</span><span class="o">.</span><span class="n">palette</span> <span class="ow">and</span> <span class="bp">self</span><span class="o">.</span><span class="n">palette</span><span class="o">.</span><span class="n">dirty</span><span class="p">:</span>
<span class="c1"># realize palette</span>
<span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">putpalette</span><span class="p">(</span><span class="o">*</span><span class="bp">self</span><span class="o">.</span><span class="n">palette</span><span class="o">.</span><span class="n">getdata</span><span class="p">())</span>
<span class="bp">self</span><span class="o">.</span><span class="n">palette</span><span class="o">.</span><span class="n">dirty</span> <span class="o">=</span> <span class="mi">0</span>
<span class="bp">self</span><span class="o">.</span><span class="n">palette</span><span class="o">.</span><span class="n">mode</span> <span class="o">=</span> <span class="s2">"RGB"</span>
<span class="bp">self</span><span class="o">.</span><span class="n">palette</span><span class="o">.</span><span class="n">rawmode</span> <span class="o">=</span> <span class="kc">None</span>
<span class="k">if</span> <span class="s2">"transparency"</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">info</span><span class="p">:</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">info</span><span class="p">[</span><span class="s2">"transparency"</span><span class="p">],</span> <span class="nb">int</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">putpalettealpha</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">info</span><span class="p">[</span><span class="s2">"transparency"</span><span class="p">],</span> <span class="mi">0</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">putpalettealphas</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">info</span><span class="p">[</span><span class="s2">"transparency"</span><span class="p">])</span>
<span class="bp">self</span><span class="o">.</span><span class="n">palette</span><span class="o">.</span><span class="n">mode</span> <span class="o">=</span> <span class="s2">"RGBA"</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="p">:</span>
<span class="k">if</span> <span class="n">cffi</span> <span class="ow">and</span> <span class="n">USE_CFFI_ACCESS</span><span class="p">:</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">pyaccess</span><span class="p">:</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">pyaccess</span>
<span class="kn">from</span> <span class="nn">.</span> <span class="k">import</span> <span class="n">PyAccess</span>
<span class="bp">self</span><span class="o">.</span><span class="n">pyaccess</span> <span class="o">=</span> <span class="n">PyAccess</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">readonly</span><span class="p">)</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">pyaccess</span><span class="p">:</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">pyaccess</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">pixel_access</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">readonly</span><span class="p">)</span></div>
<div class="viewcode-block" id="Image.verify"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image.verify">[docs]</a> <span class="k">def</span> <span class="nf">verify</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Verifies the contents of a file. For data read from a file, this</span>
<span class="sd"> method attempts to determine if the file is broken, without</span>
<span class="sd"> actually decoding the image data. If this method finds any</span>
<span class="sd"> problems, it raises suitable exceptions. If you need to load</span>
<span class="sd"> the image after using this method, you must reopen the image</span>
<span class="sd"> file.</span>
<span class="sd"> """</span>
<span class="k">pass</span></div>
<div class="viewcode-block" id="Image.convert"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image.convert">[docs]</a> <span class="k">def</span> <span class="nf">convert</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">matrix</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">dither</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span>
<span class="n">palette</span><span class="o">=</span><span class="n">WEB</span><span class="p">,</span> <span class="n">colors</span><span class="o">=</span><span class="mi">256</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Returns a converted copy of this image. For the "P" mode, this</span>
<span class="sd"> method translates pixels through the palette. If mode is</span>
<span class="sd"> omitted, a mode is chosen so that all information in the image</span>
<span class="sd"> and the palette can be represented without a palette.</span>
<span class="sd"> The current version supports all possible conversions between</span>
<span class="sd"> "L", "RGB" and "CMYK." The **matrix** argument only supports "L"</span>
<span class="sd"> and "RGB".</span>
<span class="sd"> When translating a color image to greyscale (mode "L"),</span>
<span class="sd"> the library uses the ITU-R 601-2 luma transform::</span>
<span class="sd"> L = R * 299/1000 + G * 587/1000 + B * 114/1000</span>
<span class="sd"> The default method of converting a greyscale ("L") or "RGB"</span>
<span class="sd"> image into a bilevel (mode "1") image uses Floyd-Steinberg</span>
<span class="sd"> dither to approximate the original image luminosity levels. If</span>
<span class="sd"> dither is NONE, all values larger than 128 are set to 255 (white),</span>
<span class="sd"> all other values to 0 (black). To use other thresholds, use the</span>
<span class="sd"> :py:meth:`~PIL.Image.Image.point` method.</span>
<span class="sd"> When converting from "RGBA" to "P" without a **matrix** argument,</span>
<span class="sd"> this passes the operation to :py:meth:`~PIL.Image.Image.quantize`,</span>
<span class="sd"> and **dither** and **palette** are ignored.</span>
<span class="sd"> :param mode: The requested mode. See: :ref:`concept-modes`.</span>
<span class="sd"> :param matrix: An optional conversion matrix. If given, this</span>
<span class="sd"> should be 4- or 12-tuple containing floating point values.</span>
<span class="sd"> :param dither: Dithering method, used when converting from</span>
<span class="sd"> mode "RGB" to "P" or from "RGB" or "L" to "1".</span>
<span class="sd"> Available methods are NONE or FLOYDSTEINBERG (default).</span>
<span class="sd"> Note that this is not used when **matrix** is supplied.</span>
<span class="sd"> :param palette: Palette to use when converting from mode "RGB"</span>
<span class="sd"> to "P". Available palettes are WEB or ADAPTIVE.</span>
<span class="sd"> :param colors: Number of colors to use for the ADAPTIVE palette.</span>
<span class="sd"> Defaults to 256.</span>
<span class="sd"> :rtype: :py:class:`~PIL.Image.Image`</span>
<span class="sd"> :returns: An :py:class:`~PIL.Image.Image` object.</span>
<span class="sd"> """</span>
<span class="bp">self</span><span class="o">.</span><span class="n">load</span><span class="p">()</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">mode</span> <span class="ow">and</span> <span class="bp">self</span><span class="o">.</span><span class="n">mode</span> <span class="o">==</span> <span class="s2">"P"</span><span class="p">:</span>
<span class="c1"># determine default mode</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">palette</span><span class="p">:</span>
<span class="n">mode</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">palette</span><span class="o">.</span><span class="n">mode</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">mode</span> <span class="o">=</span> <span class="s2">"RGB"</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">mode</span> <span class="ow">or</span> <span class="p">(</span><span class="n">mode</span> <span class="o">==</span> <span class="bp">self</span><span class="o">.</span><span class="n">mode</span> <span class="ow">and</span> <span class="ow">not</span> <span class="n">matrix</span><span class="p">):</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">copy</span><span class="p">()</span>
<span class="n">has_transparency</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">info</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s1">'transparency'</span><span class="p">)</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span>
<span class="k">if</span> <span class="n">matrix</span><span class="p">:</span>
<span class="c1"># matrix conversion</span>
<span class="k">if</span> <span class="n">mode</span> <span class="ow">not</span> <span class="ow">in</span> <span class="p">(</span><span class="s2">"L"</span><span class="p">,</span> <span class="s2">"RGB"</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"illegal conversion"</span><span class="p">)</span>
<span class="n">im</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">convert_matrix</span><span class="p">(</span><span class="n">mode</span><span class="p">,</span> <span class="n">matrix</span><span class="p">)</span>
<span class="n">new</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_new</span><span class="p">(</span><span class="n">im</span><span class="p">)</span>
<span class="k">if</span> <span class="n">has_transparency</span> <span class="ow">and</span> <span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">bands</span> <span class="o">==</span> <span class="mi">3</span><span class="p">:</span>
<span class="n">transparency</span> <span class="o">=</span> <span class="n">new</span><span class="o">.</span><span class="n">info</span><span class="p">[</span><span class="s1">'transparency'</span><span class="p">]</span>
<span class="k">def</span> <span class="nf">convert_transparency</span><span class="p">(</span><span class="n">m</span><span class="p">,</span> <span class="n">v</span><span class="p">):</span>
<span class="n">v</span> <span class="o">=</span> <span class="n">m</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">*</span><span class="n">v</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">+</span> <span class="n">m</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="o">*</span><span class="n">v</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="o">+</span> <span class="n">m</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span><span class="o">*</span><span class="n">v</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span> <span class="o">+</span> <span class="n">m</span><span class="p">[</span><span class="mi">3</span><span class="p">]</span><span class="o">*</span><span class="mf">0.5</span>
<span class="k">return</span> <span class="nb">max</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="nb">min</span><span class="p">(</span><span class="mi">255</span><span class="p">,</span> <span class="nb">int</span><span class="p">(</span><span class="n">v</span><span class="p">)))</span>
<span class="k">if</span> <span class="n">mode</span> <span class="o">==</span> <span class="s2">"L"</span><span class="p">:</span>
<span class="n">transparency</span> <span class="o">=</span> <span class="n">convert_transparency</span><span class="p">(</span><span class="n">matrix</span><span class="p">,</span> <span class="n">transparency</span><span class="p">)</span>
<span class="k">elif</span> <span class="nb">len</span><span class="p">(</span><span class="n">mode</span><span class="p">)</span> <span class="o">==</span> <span class="mi">3</span><span class="p">:</span>
<span class="n">transparency</span> <span class="o">=</span> <span class="nb">tuple</span><span class="p">([</span>
<span class="n">convert_transparency</span><span class="p">(</span><span class="n">matrix</span><span class="p">[</span><span class="n">i</span><span class="o">*</span><span class="mi">4</span><span class="p">:</span><span class="n">i</span><span class="o">*</span><span class="mi">4</span><span class="o">+</span><span class="mi">4</span><span class="p">],</span> <span class="n">transparency</span><span class="p">)</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">transparency</span><span class="p">))</span>
<span class="p">])</span>
<span class="n">new</span><span class="o">.</span><span class="n">info</span><span class="p">[</span><span class="s1">'transparency'</span><span class="p">]</span> <span class="o">=</span> <span class="n">transparency</span>
<span class="k">return</span> <span class="n">new</span>
<span class="k">if</span> <span class="n">mode</span> <span class="o">==</span> <span class="s2">"P"</span> <span class="ow">and</span> <span class="bp">self</span><span class="o">.</span><span class="n">mode</span> <span class="o">==</span> <span class="s2">"RGBA"</span><span class="p">:</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">quantize</span><span class="p">(</span><span class="n">colors</span><span class="p">)</span>
<span class="n">trns</span> <span class="o">=</span> <span class="kc">None</span>
<span class="n">delete_trns</span> <span class="o">=</span> <span class="kc">False</span>
<span class="c1"># transparency handling</span>
<span class="k">if</span> <span class="n">has_transparency</span><span class="p">:</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">mode</span> <span class="ow">in</span> <span class="p">(</span><span class="s1">'L'</span><span class="p">,</span> <span class="s1">'RGB'</span><span class="p">)</span> <span class="ow">and</span> <span class="n">mode</span> <span class="o">==</span> <span class="s1">'RGBA'</span><span class="p">:</span>
<span class="c1"># Use transparent conversion to promote from transparent</span>
<span class="c1"># color to an alpha channel.</span>
<span class="n">new_im</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_new</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">convert_transparent</span><span class="p">(</span>
<span class="n">mode</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">info</span><span class="p">[</span><span class="s1">'transparency'</span><span class="p">]))</span>
<span class="k">del</span><span class="p">(</span><span class="n">new_im</span><span class="o">.</span><span class="n">info</span><span class="p">[</span><span class="s1">'transparency'</span><span class="p">])</span>
<span class="k">return</span> <span class="n">new_im</span>
<span class="k">elif</span> <span class="bp">self</span><span class="o">.</span><span class="n">mode</span> <span class="ow">in</span> <span class="p">(</span><span class="s1">'L'</span><span class="p">,</span> <span class="s1">'RGB'</span><span class="p">,</span> <span class="s1">'P'</span><span class="p">)</span> <span class="ow">and</span> <span class="n">mode</span> <span class="ow">in</span> <span class="p">(</span><span class="s1">'L'</span><span class="p">,</span> <span class="s1">'RGB'</span><span class="p">,</span> <span class="s1">'P'</span><span class="p">):</span>
<span class="n">t</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">info</span><span class="p">[</span><span class="s1">'transparency'</span><span class="p">]</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">t</span><span class="p">,</span> <span class="nb">bytes</span><span class="p">):</span>
<span class="c1"># Dragons. This can't be represented by a single color</span>
<span class="n">warnings</span><span class="o">.</span><span class="n">warn</span><span class="p">(</span><span class="s1">'Palette images with Transparency '</span> <span class="o">+</span>
<span class="s1">' expressed in bytes should be converted '</span> <span class="o">+</span>
<span class="s1">'to RGBA images'</span><span class="p">)</span>
<span class="n">delete_trns</span> <span class="o">=</span> <span class="kc">True</span>
<span class="k">else</span><span class="p">:</span>
<span class="c1"># get the new transparency color.</span>
<span class="c1"># use existing conversions</span>
<span class="n">trns_im</span> <span class="o">=</span> <span class="n">Image</span><span class="p">()</span><span class="o">.</span><span class="n">_new</span><span class="p">(</span><span class="n">core</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">mode</span><span class="p">,</span> <span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">)))</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">mode</span> <span class="o">==</span> <span class="s1">'P'</span><span class="p">:</span>
<span class="n">trns_im</span><span class="o">.</span><span class="n">putpalette</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">palette</span><span class="p">)</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">t</span><span class="p">,</span> <span class="nb">tuple</span><span class="p">):</span>
<span class="k">try</span><span class="p">:</span>
<span class="n">t</span> <span class="o">=</span> <span class="n">trns_im</span><span class="o">.</span><span class="n">palette</span><span class="o">.</span><span class="n">getcolor</span><span class="p">(</span><span class="n">t</span><span class="p">)</span>
<span class="k">except</span> <span class="ne">Exception</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"Couldn't allocate a palette "</span>
<span class="s2">"color for transparency"</span><span class="p">)</span>
<span class="n">trns_im</span><span class="o">.</span><span class="n">putpixel</span><span class="p">((</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">),</span> <span class="n">t</span><span class="p">)</span>
<span class="k">if</span> <span class="n">mode</span> <span class="ow">in</span> <span class="p">(</span><span class="s1">'L'</span><span class="p">,</span> <span class="s1">'RGB'</span><span class="p">):</span>
<span class="n">trns_im</span> <span class="o">=</span> <span class="n">trns_im</span><span class="o">.</span><span class="n">convert</span><span class="p">(</span><span class="n">mode</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="c1"># can't just retrieve the palette number, got to do it</span>
<span class="c1"># after quantization.</span>
<span class="n">trns_im</span> <span class="o">=</span> <span class="n">trns_im</span><span class="o">.</span><span class="n">convert</span><span class="p">(</span><span class="s1">'RGB'</span><span class="p">)</span>
<span class="n">trns</span> <span class="o">=</span> <span class="n">trns_im</span><span class="o">.</span><span class="n">getpixel</span><span class="p">((</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">))</span>
<span class="k">elif</span> <span class="bp">self</span><span class="o">.</span><span class="n">mode</span> <span class="o">==</span> <span class="s1">'P'</span> <span class="ow">and</span> <span class="n">mode</span> <span class="o">==</span> <span class="s1">'RGBA'</span><span class="p">:</span>
<span class="n">t</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">info</span><span class="p">[</span><span class="s1">'transparency'</span><span class="p">]</span>
<span class="n">delete_trns</span> <span class="o">=</span> <span class="kc">True</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">t</span><span class="p">,</span> <span class="nb">bytes</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">putpalettealphas</span><span class="p">(</span><span class="n">t</span><span class="p">)</span>
<span class="k">elif</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">t</span><span class="p">,</span> <span class="nb">int</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">putpalettealpha</span><span class="p">(</span><span class="n">t</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"Transparency for P mode should"</span> <span class="o">+</span>
<span class="s2">" be bytes or int"</span><span class="p">)</span>
<span class="k">if</span> <span class="n">mode</span> <span class="o">==</span> <span class="s2">"P"</span> <span class="ow">and</span> <span class="n">palette</span> <span class="o">==</span> <span class="n">ADAPTIVE</span><span class="p">:</span>
<span class="n">im</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">quantize</span><span class="p">(</span><span class="n">colors</span><span class="p">)</span>
<span class="n">new</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_new</span><span class="p">(</span><span class="n">im</span><span class="p">)</span>
<span class="kn">from</span> <span class="nn">.</span> <span class="k">import</span> <span class="n">ImagePalette</span>
<span class="n">new</span><span class="o">.</span><span class="n">palette</span> <span class="o">=</span> <span class="n">ImagePalette</span><span class="o">.</span><span class="n">raw</span><span class="p">(</span><span class="s2">"RGB"</span><span class="p">,</span> <span class="n">new</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">getpalette</span><span class="p">(</span><span class="s2">"RGB"</span><span class="p">))</span>
<span class="k">if</span> <span class="n">delete_trns</span><span class="p">:</span>
<span class="c1"># This could possibly happen if we requantize to fewer colors.</span>
<span class="c1"># The transparency would be totally off in that case.</span>
<span class="k">del</span><span class="p">(</span><span class="n">new</span><span class="o">.</span><span class="n">info</span><span class="p">[</span><span class="s1">'transparency'</span><span class="p">])</span>
<span class="k">if</span> <span class="n">trns</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
<span class="k">try</span><span class="p">:</span>
<span class="n">new</span><span class="o">.</span><span class="n">info</span><span class="p">[</span><span class="s1">'transparency'</span><span class="p">]</span> <span class="o">=</span> <span class="n">new</span><span class="o">.</span><span class="n">palette</span><span class="o">.</span><span class="n">getcolor</span><span class="p">(</span><span class="n">trns</span><span class="p">)</span>
<span class="k">except</span> <span class="ne">Exception</span><span class="p">:</span>
<span class="c1"># if we can't make a transparent color, don't leave the old</span>
<span class="c1"># transparency hanging around to mess us up.</span>
<span class="k">del</span><span class="p">(</span><span class="n">new</span><span class="o">.</span><span class="n">info</span><span class="p">[</span><span class="s1">'transparency'</span><span class="p">])</span>
<span class="n">warnings</span><span class="o">.</span><span class="n">warn</span><span class="p">(</span><span class="s2">"Couldn't allocate palette entry "</span> <span class="o">+</span>
<span class="s2">"for transparency"</span><span class="p">)</span>
<span class="k">return</span> <span class="n">new</span>
<span class="c1"># colorspace conversion</span>
<span class="k">if</span> <span class="n">dither</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="n">dither</span> <span class="o">=</span> <span class="n">FLOYDSTEINBERG</span>
<span class="k">try</span><span class="p">:</span>
<span class="n">im</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">convert</span><span class="p">(</span><span class="n">mode</span><span class="p">,</span> <span class="n">dither</span><span class="p">)</span>
<span class="k">except</span> <span class="ne">ValueError</span><span class="p">:</span>
<span class="k">try</span><span class="p">:</span>
<span class="c1"># normalize source image and try again</span>
<span class="n">im</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">convert</span><span class="p">(</span><span class="n">getmodebase</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">mode</span><span class="p">))</span>
<span class="n">im</span> <span class="o">=</span> <span class="n">im</span><span class="o">.</span><span class="n">convert</span><span class="p">(</span><span class="n">mode</span><span class="p">,</span> <span class="n">dither</span><span class="p">)</span>
<span class="k">except</span> <span class="ne">KeyError</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"illegal conversion"</span><span class="p">)</span>
<span class="n">new_im</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_new</span><span class="p">(</span><span class="n">im</span><span class="p">)</span>
<span class="k">if</span> <span class="n">delete_trns</span><span class="p">:</span>
<span class="c1"># crash fail if we leave a bytes transparency in an rgb/l mode.</span>
<span class="k">del</span><span class="p">(</span><span class="n">new_im</span><span class="o">.</span><span class="n">info</span><span class="p">[</span><span class="s1">'transparency'</span><span class="p">])</span>
<span class="k">if</span> <span class="n">trns</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
<span class="k">if</span> <span class="n">new_im</span><span class="o">.</span><span class="n">mode</span> <span class="o">==</span> <span class="s1">'P'</span><span class="p">:</span>
<span class="k">try</span><span class="p">:</span>
<span class="n">new_im</span><span class="o">.</span><span class="n">info</span><span class="p">[</span><span class="s1">'transparency'</span><span class="p">]</span> <span class="o">=</span> <span class="n">new_im</span><span class="o">.</span><span class="n">palette</span><span class="o">.</span><span class="n">getcolor</span><span class="p">(</span><span class="n">trns</span><span class="p">)</span>
<span class="k">except</span> <span class="ne">Exception</span><span class="p">:</span>
<span class="k">del</span><span class="p">(</span><span class="n">new_im</span><span class="o">.</span><span class="n">info</span><span class="p">[</span><span class="s1">'transparency'</span><span class="p">])</span>
<span class="n">warnings</span><span class="o">.</span><span class="n">warn</span><span class="p">(</span><span class="s2">"Couldn't allocate palette entry "</span> <span class="o">+</span>
<span class="s2">"for transparency"</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">new_im</span><span class="o">.</span><span class="n">info</span><span class="p">[</span><span class="s1">'transparency'</span><span class="p">]</span> <span class="o">=</span> <span class="n">trns</span>
<span class="k">return</span> <span class="n">new_im</span></div>
<div class="viewcode-block" id="Image.quantize"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image.quantize">[docs]</a> <span class="k">def</span> <span class="nf">quantize</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">colors</span><span class="o">=</span><span class="mi">256</span><span class="p">,</span> <span class="n">method</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">kmeans</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">palette</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Convert the image to 'P' mode with the specified number</span>
<span class="sd"> of colors.</span>
<span class="sd"> :param colors: The desired number of colors, <= 256</span>
<span class="sd"> :param method: 0 = median cut</span>
<span class="sd"> 1 = maximum coverage</span>
<span class="sd"> 2 = fast octree</span>
<span class="sd"> 3 = libimagequant</span>
<span class="sd"> :param kmeans: Integer</span>
<span class="sd"> :param palette: Quantize to the palette of given</span>
<span class="sd"> :py:class:`PIL.Image.Image`.</span>
<span class="sd"> :returns: A new image</span>
<span class="sd"> """</span>
<span class="bp">self</span><span class="o">.</span><span class="n">load</span><span class="p">()</span>
<span class="k">if</span> <span class="n">method</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="c1"># defaults:</span>
<span class="n">method</span> <span class="o">=</span> <span class="mi">0</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">mode</span> <span class="o">==</span> <span class="s1">'RGBA'</span><span class="p">:</span>
<span class="n">method</span> <span class="o">=</span> <span class="mi">2</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">mode</span> <span class="o">==</span> <span class="s1">'RGBA'</span> <span class="ow">and</span> <span class="n">method</span> <span class="ow">not</span> <span class="ow">in</span> <span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">):</span>
<span class="c1"># Caller specified an invalid mode.</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span>
<span class="s1">'Fast Octree (method == 2) and libimagequant (method == 3) '</span> <span class="o">+</span>
<span class="s1">'are the only valid methods for quantizing RGBA images'</span><span class="p">)</span>
<span class="k">if</span> <span class="n">palette</span><span class="p">:</span>
<span class="c1"># use palette from reference image</span>
<span class="n">palette</span><span class="o">.</span><span class="n">load</span><span class="p">()</span>
<span class="k">if</span> <span class="n">palette</span><span class="o">.</span><span class="n">mode</span> <span class="o">!=</span> <span class="s2">"P"</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"bad mode for palette image"</span><span class="p">)</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">mode</span> <span class="o">!=</span> <span class="s2">"RGB"</span> <span class="ow">and</span> <span class="bp">self</span><span class="o">.</span><span class="n">mode</span> <span class="o">!=</span> <span class="s2">"L"</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span>
<span class="s2">"only RGB or L mode images can be quantized to a palette"</span>
<span class="p">)</span>
<span class="n">im</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">convert</span><span class="p">(</span><span class="s2">"P"</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="n">palette</span><span class="o">.</span><span class="n">im</span><span class="p">)</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_new</span><span class="p">(</span><span class="n">im</span><span class="p">)</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_new</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">quantize</span><span class="p">(</span><span class="n">colors</span><span class="p">,</span> <span class="n">method</span><span class="p">,</span> <span class="n">kmeans</span><span class="p">))</span></div>
<div class="viewcode-block" id="Image.copy"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image.copy">[docs]</a> <span class="k">def</span> <span class="nf">copy</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Copies this image. Use this method if you wish to paste things</span>
<span class="sd"> into an image, but still retain the original.</span>
<span class="sd"> :rtype: :py:class:`~PIL.Image.Image`</span>
<span class="sd"> :returns: An :py:class:`~PIL.Image.Image` object.</span>
<span class="sd"> """</span>
<span class="bp">self</span><span class="o">.</span><span class="n">load</span><span class="p">()</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_new</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">copy</span><span class="p">())</span></div>
<span class="n">__copy__</span> <span class="o">=</span> <span class="n">copy</span>
<div class="viewcode-block" id="Image.crop"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image.crop">[docs]</a> <span class="k">def</span> <span class="nf">crop</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">box</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Returns a rectangular region from this image. The box is a</span>
<span class="sd"> 4-tuple defining the left, upper, right, and lower pixel</span>
<span class="sd"> coordinate. See :ref:`coordinate-system`.</span>
<span class="sd"> Note: Prior to Pillow 3.4.0, this was a lazy operation.</span>
<span class="sd"> :param box: The crop rectangle, as a (left, upper, right, lower)-tuple.</span>
<span class="sd"> :rtype: :py:class:`~PIL.Image.Image`</span>
<span class="sd"> :returns: An :py:class:`~PIL.Image.Image` object.</span>
<span class="sd"> """</span>
<span class="k">if</span> <span class="n">box</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">copy</span><span class="p">()</span>
<span class="bp">self</span><span class="o">.</span><span class="n">load</span><span class="p">()</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_new</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_crop</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="p">,</span> <span class="n">box</span><span class="p">))</span></div>
<span class="k">def</span> <span class="nf">_crop</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">im</span><span class="p">,</span> <span class="n">box</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Returns a rectangular region from the core image object im.</span>
<span class="sd"> This is equivalent to calling im.crop((x0, y0, x1, y1)), but</span>
<span class="sd"> includes additional sanity checks.</span>
<span class="sd"> :param im: a core image object</span>
<span class="sd"> :param box: The crop rectangle, as a (left, upper, right, lower)-tuple.</span>
<span class="sd"> :returns: A core image object.</span>
<span class="sd"> """</span>
<span class="n">x0</span><span class="p">,</span> <span class="n">y0</span><span class="p">,</span> <span class="n">x1</span><span class="p">,</span> <span class="n">y1</span> <span class="o">=</span> <span class="nb">map</span><span class="p">(</span><span class="nb">int</span><span class="p">,</span> <span class="nb">map</span><span class="p">(</span><span class="nb">round</span><span class="p">,</span> <span class="n">box</span><span class="p">))</span>
<span class="n">absolute_values</span> <span class="o">=</span> <span class="p">(</span><span class="nb">abs</span><span class="p">(</span><span class="n">x1</span> <span class="o">-</span> <span class="n">x0</span><span class="p">),</span> <span class="nb">abs</span><span class="p">(</span><span class="n">y1</span> <span class="o">-</span> <span class="n">y0</span><span class="p">))</span>
<span class="n">_decompression_bomb_check</span><span class="p">(</span><span class="n">absolute_values</span><span class="p">)</span>
<span class="k">return</span> <span class="n">im</span><span class="o">.</span><span class="n">crop</span><span class="p">((</span><span class="n">x0</span><span class="p">,</span> <span class="n">y0</span><span class="p">,</span> <span class="n">x1</span><span class="p">,</span> <span class="n">y1</span><span class="p">))</span>
<div class="viewcode-block" id="Image.draft"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image.draft">[docs]</a> <span class="k">def</span> <span class="nf">draft</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">mode</span><span class="p">,</span> <span class="n">size</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Configures the image file loader so it returns a version of the</span>
<span class="sd"> image that as closely as possible matches the given mode and</span>
<span class="sd"> size. For example, you can use this method to convert a color</span>
<span class="sd"> JPEG to greyscale while loading it, or to extract a 128x192</span>
<span class="sd"> version from a PCD file.</span>
<span class="sd"> Note that this method modifies the :py:class:`~PIL.Image.Image` object</span>
<span class="sd"> in place. If the image has already been loaded, this method has no</span>
<span class="sd"> effect.</span>
<span class="sd"> Note: This method is not implemented for most images. It is</span>
<span class="sd"> currently implemented only for JPEG and PCD images.</span>
<span class="sd"> :param mode: The requested mode.</span>
<span class="sd"> :param size: The requested size.</span>
<span class="sd"> """</span>
<span class="k">pass</span></div>
<span class="k">def</span> <span class="nf">_expand</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">xmargin</span><span class="p">,</span> <span class="n">ymargin</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
<span class="k">if</span> <span class="n">ymargin</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="n">ymargin</span> <span class="o">=</span> <span class="n">xmargin</span>
<span class="bp">self</span><span class="o">.</span><span class="n">load</span><span class="p">()</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_new</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">expand</span><span class="p">(</span><span class="n">xmargin</span><span class="p">,</span> <span class="n">ymargin</span><span class="p">,</span> <span class="mi">0</span><span class="p">))</span>
<div class="viewcode-block" id="Image.filter"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image.filter">[docs]</a> <span class="k">def</span> <span class="nf">filter</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="nb">filter</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Filters this image using the given filter. For a list of</span>
<span class="sd"> available filters, see the :py:mod:`~PIL.ImageFilter` module.</span>
<span class="sd"> :param filter: Filter kernel.</span>
<span class="sd"> :returns: An :py:class:`~PIL.Image.Image` object. """</span>
<span class="kn">from</span> <span class="nn">.</span> <span class="k">import</span> <span class="n">ImageFilter</span>
<span class="bp">self</span><span class="o">.</span><span class="n">load</span><span class="p">()</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="nb">filter</span><span class="p">,</span> <span class="n">Callable</span><span class="p">):</span>
<span class="nb">filter</span> <span class="o">=</span> <span class="nb">filter</span><span class="p">()</span>
<span class="k">if</span> <span class="ow">not</span> <span class="nb">hasattr</span><span class="p">(</span><span class="nb">filter</span><span class="p">,</span> <span class="s2">"filter"</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s2">"filter argument should be ImageFilter.Filter "</span> <span class="o">+</span>
<span class="s2">"instance or class"</span><span class="p">)</span>
<span class="n">multiband</span> <span class="o">=</span> <span class="nb">isinstance</span><span class="p">(</span><span class="nb">filter</span><span class="p">,</span> <span class="n">ImageFilter</span><span class="o">.</span><span class="n">MultibandFilter</span><span class="p">)</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">bands</span> <span class="o">==</span> <span class="mi">1</span> <span class="ow">or</span> <span class="n">multiband</span><span class="p">:</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_new</span><span class="p">(</span><span class="nb">filter</span><span class="o">.</span><span class="n">filter</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="p">))</span>
<span class="n">ims</span> <span class="o">=</span> <span class="p">[]</span>
<span class="k">for</span> <span class="n">c</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">bands</span><span class="p">):</span>
<span class="n">ims</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_new</span><span class="p">(</span><span class="nb">filter</span><span class="o">.</span><span class="n">filter</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">getband</span><span class="p">(</span><span class="n">c</span><span class="p">))))</span>
<span class="k">return</span> <span class="n">merge</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">mode</span><span class="p">,</span> <span class="n">ims</span><span class="p">)</span></div>
<div class="viewcode-block" id="Image.getbands"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image.getbands">[docs]</a> <span class="k">def</span> <span class="nf">getbands</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Returns a tuple containing the name of each band in this image.</span>
<span class="sd"> For example, **getbands** on an RGB image returns ("R", "G", "B").</span>
<span class="sd"> :returns: A tuple containing band names.</span>
<span class="sd"> :rtype: tuple</span>
<span class="sd"> """</span>
<span class="k">return</span> <span class="n">ImageMode</span><span class="o">.</span><span class="n">getmode</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">mode</span><span class="p">)</span><span class="o">.</span><span class="n">bands</span></div>
<div class="viewcode-block" id="Image.getbbox"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image.getbbox">[docs]</a> <span class="k">def</span> <span class="nf">getbbox</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Calculates the bounding box of the non-zero regions in the</span>
<span class="sd"> image.</span>
<span class="sd"> :returns: The bounding box is returned as a 4-tuple defining the</span>
<span class="sd"> left, upper, right, and lower pixel coordinate. See</span>
<span class="sd"> :ref:`coordinate-system`. If the image is completely empty, this</span>
<span class="sd"> method returns None.</span>
<span class="sd"> """</span>
<span class="bp">self</span><span class="o">.</span><span class="n">load</span><span class="p">()</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">getbbox</span><span class="p">()</span></div>
<div class="viewcode-block" id="Image.getcolors"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image.getcolors">[docs]</a> <span class="k">def</span> <span class="nf">getcolors</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">maxcolors</span><span class="o">=</span><span class="mi">256</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Returns a list of colors used in this image.</span>
<span class="sd"> :param maxcolors: Maximum number of colors. If this number is</span>
<span class="sd"> exceeded, this method returns None. The default limit is</span>
<span class="sd"> 256 colors.</span>
<span class="sd"> :returns: An unsorted list of (count, pixel) values.</span>
<span class="sd"> """</span>
<span class="bp">self</span><span class="o">.</span><span class="n">load</span><span class="p">()</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">mode</span> <span class="ow">in</span> <span class="p">(</span><span class="s2">"1"</span><span class="p">,</span> <span class="s2">"L"</span><span class="p">,</span> <span class="s2">"P"</span><span class="p">):</span>
<span class="n">h</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">histogram</span><span class="p">()</span>
<span class="n">out</span> <span class="o">=</span> <span class="p">[]</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">256</span><span class="p">):</span>
<span class="k">if</span> <span class="n">h</span><span class="p">[</span><span class="n">i</span><span class="p">]:</span>
<span class="n">out</span><span class="o">.</span><span class="n">append</span><span class="p">((</span><span class="n">h</span><span class="p">[</span><span class="n">i</span><span class="p">],</span> <span class="n">i</span><span class="p">))</span>
<span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="n">out</span><span class="p">)</span> <span class="o">></span> <span class="n">maxcolors</span><span class="p">:</span>
<span class="k">return</span> <span class="kc">None</span>
<span class="k">return</span> <span class="n">out</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">getcolors</span><span class="p">(</span><span class="n">maxcolors</span><span class="p">)</span></div>
<div class="viewcode-block" id="Image.getdata"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image.getdata">[docs]</a> <span class="k">def</span> <span class="nf">getdata</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">band</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Returns the contents of this image as a sequence object</span>
<span class="sd"> containing pixel values. The sequence object is flattened, so</span>
<span class="sd"> that values for line one follow directly after the values of</span>
<span class="sd"> line zero, and so on.</span>
<span class="sd"> Note that the sequence object returned by this method is an</span>
<span class="sd"> internal PIL data type, which only supports certain sequence</span>
<span class="sd"> operations. To convert it to an ordinary sequence (e.g. for</span>
<span class="sd"> printing), use **list(im.getdata())**.</span>
<span class="sd"> :param band: What band to return. The default is to return</span>
<span class="sd"> all bands. To return a single band, pass in the index</span>
<span class="sd"> value (e.g. 0 to get the "R" band from an "RGB" image).</span>
<span class="sd"> :returns: A sequence-like object.</span>
<span class="sd"> """</span>
<span class="bp">self</span><span class="o">.</span><span class="n">load</span><span class="p">()</span>
<span class="k">if</span> <span class="n">band</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">getband</span><span class="p">(</span><span class="n">band</span><span class="p">)</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">im</span> <span class="c1"># could be abused</span></div>
<div class="viewcode-block" id="Image.getextrema"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image.getextrema">[docs]</a> <span class="k">def</span> <span class="nf">getextrema</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Gets the the minimum and maximum pixel values for each band in</span>
<span class="sd"> the image.</span>
<span class="sd"> :returns: For a single-band image, a 2-tuple containing the</span>
<span class="sd"> minimum and maximum pixel value. For a multi-band image,</span>
<span class="sd"> a tuple containing one 2-tuple for each band.</span>
<span class="sd"> """</span>
<span class="bp">self</span><span class="o">.</span><span class="n">load</span><span class="p">()</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">bands</span> <span class="o">></span> <span class="mi">1</span><span class="p">:</span>
<span class="n">extrema</span> <span class="o">=</span> <span class="p">[]</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">bands</span><span class="p">):</span>
<span class="n">extrema</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">getband</span><span class="p">(</span><span class="n">i</span><span class="p">)</span><span class="o">.</span><span class="n">getextrema</span><span class="p">())</span>
<span class="k">return</span> <span class="nb">tuple</span><span class="p">(</span><span class="n">extrema</span><span class="p">)</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">getextrema</span><span class="p">()</span></div>
<span class="k">def</span> <span class="nf">getim</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Returns a capsule that points to the internal image memory.</span>
<span class="sd"> :returns: A capsule object.</span>
<span class="sd"> """</span>
<span class="bp">self</span><span class="o">.</span><span class="n">load</span><span class="p">()</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">ptr</span>
<div class="viewcode-block" id="Image.getpalette"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image.getpalette">[docs]</a> <span class="k">def</span> <span class="nf">getpalette</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Returns the image palette as a list.</span>
<span class="sd"> :returns: A list of color values [r, g, b, ...], or None if the</span>
<span class="sd"> image has no palette.</span>
<span class="sd"> """</span>
<span class="bp">self</span><span class="o">.</span><span class="n">load</span><span class="p">()</span>
<span class="k">try</span><span class="p">:</span>
<span class="k">if</span> <span class="n">py3</span><span class="p">:</span>
<span class="k">return</span> <span class="nb">list</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">getpalette</span><span class="p">())</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">return</span> <span class="p">[</span><span class="n">i8</span><span class="p">(</span><span class="n">c</span><span class="p">)</span> <span class="k">for</span> <span class="n">c</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">getpalette</span><span class="p">()]</span>
<span class="k">except</span> <span class="ne">ValueError</span><span class="p">:</span>
<span class="k">return</span> <span class="kc">None</span> <span class="c1"># no palette</span></div>
<div class="viewcode-block" id="Image.getpixel"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image.getpixel">[docs]</a> <span class="k">def</span> <span class="nf">getpixel</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">xy</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Returns the pixel value at a given position.</span>
<span class="sd"> :param xy: The coordinate, given as (x, y). See</span>
<span class="sd"> :ref:`coordinate-system`.</span>
<span class="sd"> :returns: The pixel value. If the image is a multi-layer image,</span>
<span class="sd"> this method returns a tuple.</span>
<span class="sd"> """</span>
<span class="bp">self</span><span class="o">.</span><span class="n">load</span><span class="p">()</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">pyaccess</span><span class="p">:</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">pyaccess</span><span class="o">.</span><span class="n">getpixel</span><span class="p">(</span><span class="n">xy</span><span class="p">)</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">getpixel</span><span class="p">(</span><span class="n">xy</span><span class="p">)</span></div>
<span class="k">def</span> <span class="nf">getprojection</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Get projection to x and y axes</span>
<span class="sd"> :returns: Two sequences, indicating where there are non-zero</span>
<span class="sd"> pixels along the X-axis and the Y-axis, respectively.</span>
<span class="sd"> """</span>
<span class="bp">self</span><span class="o">.</span><span class="n">load</span><span class="p">()</span>
<span class="n">x</span><span class="p">,</span> <span class="n">y</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">getprojection</span><span class="p">()</span>
<span class="k">return</span> <span class="p">[</span><span class="n">i8</span><span class="p">(</span><span class="n">c</span><span class="p">)</span> <span class="k">for</span> <span class="n">c</span> <span class="ow">in</span> <span class="n">x</span><span class="p">],</span> <span class="p">[</span><span class="n">i8</span><span class="p">(</span><span class="n">c</span><span class="p">)</span> <span class="k">for</span> <span class="n">c</span> <span class="ow">in</span> <span class="n">y</span><span class="p">]</span>
<div class="viewcode-block" id="Image.histogram"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image.histogram">[docs]</a> <span class="k">def</span> <span class="nf">histogram</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">mask</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">extrema</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Returns a histogram for the image. The histogram is returned as</span>
<span class="sd"> a list of pixel counts, one for each pixel value in the source</span>
<span class="sd"> image. If the image has more than one band, the histograms for</span>
<span class="sd"> all bands are concatenated (for example, the histogram for an</span>
<span class="sd"> "RGB" image contains 768 values).</span>
<span class="sd"> A bilevel image (mode "1") is treated as a greyscale ("L") image</span>
<span class="sd"> by this method.</span>
<span class="sd"> If a mask is provided, the method returns a histogram for those</span>
<span class="sd"> parts of the image where the mask image is non-zero. The mask</span>
<span class="sd"> image must have the same size as the image, and be either a</span>
<span class="sd"> bi-level image (mode "1") or a greyscale image ("L").</span>
<span class="sd"> :param mask: An optional mask.</span>
<span class="sd"> :returns: A list containing pixel counts.</span>
<span class="sd"> """</span>
<span class="bp">self</span><span class="o">.</span><span class="n">load</span><span class="p">()</span>
<span class="k">if</span> <span class="n">mask</span><span class="p">:</span>
<span class="n">mask</span><span class="o">.</span><span class="n">load</span><span class="p">()</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">histogram</span><span class="p">((</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">),</span> <span class="n">mask</span><span class="o">.</span><span class="n">im</span><span class="p">)</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">mode</span> <span class="ow">in</span> <span class="p">(</span><span class="s2">"I"</span><span class="p">,</span> <span class="s2">"F"</span><span class="p">):</span>
<span class="k">if</span> <span class="n">extrema</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="n">extrema</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">getextrema</span><span class="p">()</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">histogram</span><span class="p">(</span><span class="n">extrema</span><span class="p">)</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">histogram</span><span class="p">()</span></div>
<div class="viewcode-block" id="Image.offset"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image.offset">[docs]</a> <span class="k">def</span> <span class="nf">offset</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">xoffset</span><span class="p">,</span> <span class="n">yoffset</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">NotImplementedError</span><span class="p">(</span><span class="s2">"offset() has been removed. "</span>
<span class="s2">"Please call ImageChops.offset() instead."</span><span class="p">)</span></div>
<div class="viewcode-block" id="Image.paste"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image.paste">[docs]</a> <span class="k">def</span> <span class="nf">paste</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">im</span><span class="p">,</span> <span class="n">box</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">mask</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Pastes another image into this image. The box argument is either</span>
<span class="sd"> a 2-tuple giving the upper left corner, a 4-tuple defining the</span>
<span class="sd"> left, upper, right, and lower pixel coordinate, or None (same as</span>
<span class="sd"> (0, 0)). See :ref:`coordinate-system`. If a 4-tuple is given, the size</span>
<span class="sd"> of the pasted image must match the size of the region.</span>
<span class="sd"> If the modes don't match, the pasted image is converted to the mode of</span>
<span class="sd"> this image (see the :py:meth:`~PIL.Image.Image.convert` method for</span>
<span class="sd"> details).</span>
<span class="sd"> Instead of an image, the source can be a integer or tuple</span>
<span class="sd"> containing pixel values. The method then fills the region</span>
<span class="sd"> with the given color. When creating RGB images, you can</span>
<span class="sd"> also use color strings as supported by the ImageColor module.</span>
<span class="sd"> If a mask is given, this method updates only the regions</span>
<span class="sd"> indicated by the mask. You can use either "1", "L" or "RGBA"</span>
<span class="sd"> images (in the latter case, the alpha band is used as mask).</span>
<span class="sd"> Where the mask is 255, the given image is copied as is. Where</span>
<span class="sd"> the mask is 0, the current value is preserved. Intermediate</span>
<span class="sd"> values will mix the two images together, including their alpha</span>
<span class="sd"> channels if they have them.</span>
<span class="sd"> See :py:meth:`~PIL.Image.Image.alpha_composite` if you want to</span>
<span class="sd"> combine images with respect to their alpha channels.</span>
<span class="sd"> :param im: Source image or pixel value (integer or tuple).</span>
<span class="sd"> :param box: An optional 4-tuple giving the region to paste into.</span>
<span class="sd"> If a 2-tuple is used instead, it's treated as the upper left</span>
<span class="sd"> corner. If omitted or None, the source is pasted into the</span>
<span class="sd"> upper left corner.</span>
<span class="sd"> If an image is given as the second argument and there is no</span>
<span class="sd"> third, the box defaults to (0, 0), and the second argument</span>
<span class="sd"> is interpreted as a mask image.</span>
<span class="sd"> :param mask: An optional mask image.</span>
<span class="sd"> """</span>
<span class="k">if</span> <span class="n">isImageType</span><span class="p">(</span><span class="n">box</span><span class="p">)</span> <span class="ow">and</span> <span class="n">mask</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="c1"># abbreviated paste(im, mask) syntax</span>
<span class="n">mask</span> <span class="o">=</span> <span class="n">box</span>
<span class="n">box</span> <span class="o">=</span> <span class="kc">None</span>
<span class="k">if</span> <span class="n">box</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="n">box</span> <span class="o">=</span> <span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span>
<span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="n">box</span><span class="p">)</span> <span class="o">==</span> <span class="mi">2</span><span class="p">:</span>
<span class="c1"># upper left corner given; get size from image or mask</span>
<span class="k">if</span> <span class="n">isImageType</span><span class="p">(</span><span class="n">im</span><span class="p">):</span>
<span class="n">size</span> <span class="o">=</span> <span class="n">im</span><span class="o">.</span><span class="n">size</span>
<span class="k">elif</span> <span class="n">isImageType</span><span class="p">(</span><span class="n">mask</span><span class="p">):</span>
<span class="n">size</span> <span class="o">=</span> <span class="n">mask</span><span class="o">.</span><span class="n">size</span>
<span class="k">else</span><span class="p">:</span>
<span class="c1"># FIXME: use self.size here?</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span>
<span class="s2">"cannot determine region size; use 4-item box"</span>
<span class="p">)</span>
<span class="n">box</span> <span class="o">+=</span> <span class="p">(</span><span class="n">box</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">+</span><span class="n">size</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="n">box</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="o">+</span><span class="n">size</span><span class="p">[</span><span class="mi">1</span><span class="p">])</span>
<span class="k">if</span> <span class="n">isStringType</span><span class="p">(</span><span class="n">im</span><span class="p">):</span>
<span class="kn">from</span> <span class="nn">.</span> <span class="k">import</span> <span class="n">ImageColor</span>
<span class="n">im</span> <span class="o">=</span> <span class="n">ImageColor</span><span class="o">.</span><span class="n">getcolor</span><span class="p">(</span><span class="n">im</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">mode</span><span class="p">)</span>
<span class="k">elif</span> <span class="n">isImageType</span><span class="p">(</span><span class="n">im</span><span class="p">):</span>
<span class="n">im</span><span class="o">.</span><span class="n">load</span><span class="p">()</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">mode</span> <span class="o">!=</span> <span class="n">im</span><span class="o">.</span><span class="n">mode</span><span class="p">:</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">mode</span> <span class="o">!=</span> <span class="s2">"RGB"</span> <span class="ow">or</span> <span class="n">im</span><span class="o">.</span><span class="n">mode</span> <span class="ow">not</span> <span class="ow">in</span> <span class="p">(</span><span class="s2">"RGBA"</span><span class="p">,</span> <span class="s2">"RGBa"</span><span class="p">):</span>
<span class="c1"># should use an adapter for this!</span>
<span class="n">im</span> <span class="o">=</span> <span class="n">im</span><span class="o">.</span><span class="n">convert</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">mode</span><span class="p">)</span>
<span class="n">im</span> <span class="o">=</span> <span class="n">im</span><span class="o">.</span><span class="n">im</span>
<span class="bp">self</span><span class="o">.</span><span class="n">_ensure_mutable</span><span class="p">()</span>
<span class="k">if</span> <span class="n">mask</span><span class="p">:</span>
<span class="n">mask</span><span class="o">.</span><span class="n">load</span><span class="p">()</span>
<span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">paste</span><span class="p">(</span><span class="n">im</span><span class="p">,</span> <span class="n">box</span><span class="p">,</span> <span class="n">mask</span><span class="o">.</span><span class="n">im</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">paste</span><span class="p">(</span><span class="n">im</span><span class="p">,</span> <span class="n">box</span><span class="p">)</span></div>
<div class="viewcode-block" id="Image.alpha_composite"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image.alpha_composite">[docs]</a> <span class="k">def</span> <span class="nf">alpha_composite</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">im</span><span class="p">,</span> <span class="n">dest</span><span class="o">=</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">),</span> <span class="n">source</span><span class="o">=</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">)):</span>
<span class="sd">""" 'In-place' analog of Image.alpha_composite. Composites an image</span>
<span class="sd"> onto this image.</span>
<span class="sd"> :param im: image to composite over this one</span>
<span class="sd"> :param dest: Optional 2 tuple (left, top) specifying the upper</span>
<span class="sd"> left corner in this (destination) image.</span>
<span class="sd"> :param source: Optional 2 (left, top) tuple for the upper left</span>
<span class="sd"> corner in the overlay source image, or 4 tuple (left, top, right,</span>
<span class="sd"> bottom) for the bounds of the source rectangle</span>
<span class="sd"> Performance Note: Not currently implemented in-place in the core layer.</span>
<span class="sd"> """</span>
<span class="k">if</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">source</span><span class="p">,</span> <span class="p">(</span><span class="nb">list</span><span class="p">,</span> <span class="nb">tuple</span><span class="p">)):</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"Source must be a tuple"</span><span class="p">)</span>
<span class="k">if</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">dest</span><span class="p">,</span> <span class="p">(</span><span class="nb">list</span><span class="p">,</span> <span class="nb">tuple</span><span class="p">)):</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"Destination must be a tuple"</span><span class="p">)</span>
<span class="k">if</span> <span class="ow">not</span> <span class="nb">len</span><span class="p">(</span><span class="n">source</span><span class="p">)</span> <span class="ow">in</span> <span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">4</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"Source must be a 2 or 4-tuple"</span><span class="p">)</span>
<span class="k">if</span> <span class="ow">not</span> <span class="nb">len</span><span class="p">(</span><span class="n">dest</span><span class="p">)</span> <span class="o">==</span> <span class="mi">2</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"Destination must be a 2-tuple"</span><span class="p">)</span>
<span class="k">if</span> <span class="nb">min</span><span class="p">(</span><span class="n">source</span><span class="p">)</span> <span class="o"><</span> <span class="mi">0</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"Source must be non-negative"</span><span class="p">)</span>
<span class="k">if</span> <span class="nb">min</span><span class="p">(</span><span class="n">dest</span><span class="p">)</span> <span class="o"><</span> <span class="mi">0</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"Destination must be non-negative"</span><span class="p">)</span>
<span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="n">source</span><span class="p">)</span> <span class="o">==</span> <span class="mi">2</span><span class="p">:</span>
<span class="n">source</span> <span class="o">=</span> <span class="n">source</span> <span class="o">+</span> <span class="n">im</span><span class="o">.</span><span class="n">size</span>
<span class="c1"># over image, crop if it's not the whole thing.</span>
<span class="k">if</span> <span class="n">source</span> <span class="o">==</span> <span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span> <span class="o">+</span> <span class="n">im</span><span class="o">.</span><span class="n">size</span><span class="p">:</span>
<span class="n">overlay</span> <span class="o">=</span> <span class="n">im</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">overlay</span> <span class="o">=</span> <span class="n">im</span><span class="o">.</span><span class="n">crop</span><span class="p">(</span><span class="n">source</span><span class="p">)</span>
<span class="c1"># target for the paste</span>
<span class="n">box</span> <span class="o">=</span> <span class="n">dest</span> <span class="o">+</span> <span class="p">(</span><span class="n">dest</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">+</span> <span class="n">overlay</span><span class="o">.</span><span class="n">width</span><span class="p">,</span> <span class="n">dest</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="o">+</span> <span class="n">overlay</span><span class="o">.</span><span class="n">height</span><span class="p">)</span>
<span class="c1"># destination image. don't copy if we're using the whole image.</span>
<span class="k">if</span> <span class="n">box</span> <span class="o">==</span> <span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span> <span class="o">+</span> <span class="bp">self</span><span class="o">.</span><span class="n">size</span><span class="p">:</span>
<span class="n">background</span> <span class="o">=</span> <span class="bp">self</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">background</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">crop</span><span class="p">(</span><span class="n">box</span><span class="p">)</span>
<span class="n">result</span> <span class="o">=</span> <span class="n">alpha_composite</span><span class="p">(</span><span class="n">background</span><span class="p">,</span> <span class="n">overlay</span><span class="p">)</span>
<span class="bp">self</span><span class="o">.</span><span class="n">paste</span><span class="p">(</span><span class="n">result</span><span class="p">,</span> <span class="n">box</span><span class="p">)</span></div>
<div class="viewcode-block" id="Image.point"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image.point">[docs]</a> <span class="k">def</span> <span class="nf">point</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">lut</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Maps this image through a lookup table or function.</span>
<span class="sd"> :param lut: A lookup table, containing 256 (or 65536 if</span>
<span class="sd"> self.mode=="I" and mode == "L") values per band in the</span>
<span class="sd"> image. A function can be used instead, it should take a</span>
<span class="sd"> single argument. The function is called once for each</span>
<span class="sd"> possible pixel value, and the resulting table is applied to</span>
<span class="sd"> all bands of the image.</span>
<span class="sd"> :param mode: Output mode (default is same as input). In the</span>
<span class="sd"> current version, this can only be used if the source image</span>
<span class="sd"> has mode "L" or "P", and the output has mode "1" or the</span>
<span class="sd"> source image mode is "I" and the output mode is "L".</span>
<span class="sd"> :returns: An :py:class:`~PIL.Image.Image` object.</span>
<span class="sd"> """</span>
<span class="bp">self</span><span class="o">.</span><span class="n">load</span><span class="p">()</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">lut</span><span class="p">,</span> <span class="n">ImagePointHandler</span><span class="p">):</span>
<span class="k">return</span> <span class="n">lut</span><span class="o">.</span><span class="n">point</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
<span class="k">if</span> <span class="n">callable</span><span class="p">(</span><span class="n">lut</span><span class="p">):</span>
<span class="c1"># if it isn't a list, it should be a function</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">mode</span> <span class="ow">in</span> <span class="p">(</span><span class="s2">"I"</span><span class="p">,</span> <span class="s2">"I;16"</span><span class="p">,</span> <span class="s2">"F"</span><span class="p">):</span>
<span class="c1"># check if the function can be used with point_transform</span>
<span class="c1"># UNDONE wiredfool -- I think this prevents us from ever doing</span>
<span class="c1"># a gamma function point transform on > 8bit images.</span>
<span class="n">scale</span><span class="p">,</span> <span class="n">offset</span> <span class="o">=</span> <span class="n">_getscaleoffset</span><span class="p">(</span><span class="n">lut</span><span class="p">)</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_new</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">point_transform</span><span class="p">(</span><span class="n">scale</span><span class="p">,</span> <span class="n">offset</span><span class="p">))</span>
<span class="c1"># for other modes, convert the function to a table</span>
<span class="n">lut</span> <span class="o">=</span> <span class="p">[</span><span class="n">lut</span><span class="p">(</span><span class="n">i</span><span class="p">)</span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">256</span><span class="p">)]</span> <span class="o">*</span> <span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">bands</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">mode</span> <span class="o">==</span> <span class="s2">"F"</span><span class="p">:</span>
<span class="c1"># FIXME: _imaging returns a confusing error message for this case</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"point operation not supported for this mode"</span><span class="p">)</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_new</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">point</span><span class="p">(</span><span class="n">lut</span><span class="p">,</span> <span class="n">mode</span><span class="p">))</span></div>
<div class="viewcode-block" id="Image.putalpha"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image.putalpha">[docs]</a> <span class="k">def</span> <span class="nf">putalpha</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">alpha</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Adds or replaces the alpha layer in this image. If the image</span>
<span class="sd"> does not have an alpha layer, it's converted to "LA" or "RGBA".</span>
<span class="sd"> The new layer must be either "L" or "1".</span>
<span class="sd"> :param alpha: The new alpha layer. This can either be an "L" or "1"</span>
<span class="sd"> image having the same size as this image, or an integer or</span>
<span class="sd"> other color value.</span>
<span class="sd"> """</span>
<span class="bp">self</span><span class="o">.</span><span class="n">_ensure_mutable</span><span class="p">()</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">mode</span> <span class="ow">not</span> <span class="ow">in</span> <span class="p">(</span><span class="s2">"LA"</span><span class="p">,</span> <span class="s2">"RGBA"</span><span class="p">):</span>
<span class="c1"># attempt to promote self to a matching alpha mode</span>
<span class="k">try</span><span class="p">:</span>
<span class="n">mode</span> <span class="o">=</span> <span class="n">getmodebase</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">mode</span><span class="p">)</span> <span class="o">+</span> <span class="s2">"A"</span>
<span class="k">try</span><span class="p">:</span>
<span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">setmode</span><span class="p">(</span><span class="n">mode</span><span class="p">)</span>
<span class="k">except</span> <span class="p">(</span><span class="ne">AttributeError</span><span class="p">,</span> <span class="ne">ValueError</span><span class="p">):</span>
<span class="c1"># do things the hard way</span>
<span class="n">im</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">convert</span><span class="p">(</span><span class="n">mode</span><span class="p">)</span>
<span class="k">if</span> <span class="n">im</span><span class="o">.</span><span class="n">mode</span> <span class="ow">not</span> <span class="ow">in</span> <span class="p">(</span><span class="s2">"LA"</span><span class="p">,</span> <span class="s2">"RGBA"</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">ValueError</span> <span class="c1"># sanity check</span>
<span class="bp">self</span><span class="o">.</span><span class="n">im</span> <span class="o">=</span> <span class="n">im</span>
<span class="bp">self</span><span class="o">.</span><span class="n">pyaccess</span> <span class="o">=</span> <span class="kc">None</span>
<span class="bp">self</span><span class="o">.</span><span class="n">mode</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">mode</span>
<span class="k">except</span> <span class="p">(</span><span class="ne">KeyError</span><span class="p">,</span> <span class="ne">ValueError</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"illegal image mode"</span><span class="p">)</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">mode</span> <span class="o">==</span> <span class="s2">"LA"</span><span class="p">:</span>
<span class="n">band</span> <span class="o">=</span> <span class="mi">1</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">band</span> <span class="o">=</span> <span class="mi">3</span>
<span class="k">if</span> <span class="n">isImageType</span><span class="p">(</span><span class="n">alpha</span><span class="p">):</span>
<span class="c1"># alpha layer</span>
<span class="k">if</span> <span class="n">alpha</span><span class="o">.</span><span class="n">mode</span> <span class="ow">not</span> <span class="ow">in</span> <span class="p">(</span><span class="s2">"1"</span><span class="p">,</span> <span class="s2">"L"</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"illegal image mode"</span><span class="p">)</span>
<span class="n">alpha</span><span class="o">.</span><span class="n">load</span><span class="p">()</span>
<span class="k">if</span> <span class="n">alpha</span><span class="o">.</span><span class="n">mode</span> <span class="o">==</span> <span class="s2">"1"</span><span class="p">:</span>
<span class="n">alpha</span> <span class="o">=</span> <span class="n">alpha</span><span class="o">.</span><span class="n">convert</span><span class="p">(</span><span class="s2">"L"</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="c1"># constant alpha</span>
<span class="k">try</span><span class="p">:</span>
<span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">fillband</span><span class="p">(</span><span class="n">band</span><span class="p">,</span> <span class="n">alpha</span><span class="p">)</span>
<span class="k">except</span> <span class="p">(</span><span class="ne">AttributeError</span><span class="p">,</span> <span class="ne">ValueError</span><span class="p">):</span>
<span class="c1"># do things the hard way</span>
<span class="n">alpha</span> <span class="o">=</span> <span class="n">new</span><span class="p">(</span><span class="s2">"L"</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">size</span><span class="p">,</span> <span class="n">alpha</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">return</span>
<span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">putband</span><span class="p">(</span><span class="n">alpha</span><span class="o">.</span><span class="n">im</span><span class="p">,</span> <span class="n">band</span><span class="p">)</span></div>
<div class="viewcode-block" id="Image.putdata"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image.putdata">[docs]</a> <span class="k">def</span> <span class="nf">putdata</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">data</span><span class="p">,</span> <span class="n">scale</span><span class="o">=</span><span class="mf">1.0</span><span class="p">,</span> <span class="n">offset</span><span class="o">=</span><span class="mf">0.0</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Copies pixel data to this image. This method copies data from a</span>
<span class="sd"> sequence object into the image, starting at the upper left</span>
<span class="sd"> corner (0, 0), and continuing until either the image or the</span>
<span class="sd"> sequence ends. The scale and offset values are used to adjust</span>
<span class="sd"> the sequence values: **pixel = value*scale + offset**.</span>
<span class="sd"> :param data: A sequence object.</span>
<span class="sd"> :param scale: An optional scale value. The default is 1.0.</span>
<span class="sd"> :param offset: An optional offset value. The default is 0.0.</span>
<span class="sd"> """</span>
<span class="bp">self</span><span class="o">.</span><span class="n">_ensure_mutable</span><span class="p">()</span>
<span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">putdata</span><span class="p">(</span><span class="n">data</span><span class="p">,</span> <span class="n">scale</span><span class="p">,</span> <span class="n">offset</span><span class="p">)</span></div>
<div class="viewcode-block" id="Image.putpalette"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image.putpalette">[docs]</a> <span class="k">def</span> <span class="nf">putpalette</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">data</span><span class="p">,</span> <span class="n">rawmode</span><span class="o">=</span><span class="s2">"RGB"</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Attaches a palette to this image. The image must be a "P" or</span>
<span class="sd"> "L" image, and the palette sequence must contain 768 integer</span>
<span class="sd"> values, where each group of three values represent the red,</span>
<span class="sd"> green, and blue values for the corresponding pixel</span>
<span class="sd"> index. Instead of an integer sequence, you can use an 8-bit</span>
<span class="sd"> string.</span>
<span class="sd"> :param data: A palette sequence (either a list or a string).</span>
<span class="sd"> :param rawmode: The raw mode of the palette.</span>
<span class="sd"> """</span>
<span class="kn">from</span> <span class="nn">.</span> <span class="k">import</span> <span class="n">ImagePalette</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">mode</span> <span class="ow">not</span> <span class="ow">in</span> <span class="p">(</span><span class="s2">"L"</span><span class="p">,</span> <span class="s2">"P"</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"illegal image mode"</span><span class="p">)</span>
<span class="bp">self</span><span class="o">.</span><span class="n">load</span><span class="p">()</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">data</span><span class="p">,</span> <span class="n">ImagePalette</span><span class="o">.</span><span class="n">ImagePalette</span><span class="p">):</span>
<span class="n">palette</span> <span class="o">=</span> <span class="n">ImagePalette</span><span class="o">.</span><span class="n">raw</span><span class="p">(</span><span class="n">data</span><span class="o">.</span><span class="n">rawmode</span><span class="p">,</span> <span class="n">data</span><span class="o">.</span><span class="n">palette</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">if</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">data</span><span class="p">,</span> <span class="nb">bytes</span><span class="p">):</span>
<span class="k">if</span> <span class="n">py3</span><span class="p">:</span>
<span class="n">data</span> <span class="o">=</span> <span class="nb">bytes</span><span class="p">(</span><span class="n">data</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">data</span> <span class="o">=</span> <span class="s2">""</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="nb">chr</span><span class="p">(</span><span class="n">x</span><span class="p">)</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="n">data</span><span class="p">)</span>
<span class="n">palette</span> <span class="o">=</span> <span class="n">ImagePalette</span><span class="o">.</span><span class="n">raw</span><span class="p">(</span><span class="n">rawmode</span><span class="p">,</span> <span class="n">data</span><span class="p">)</span>
<span class="bp">self</span><span class="o">.</span><span class="n">mode</span> <span class="o">=</span> <span class="s2">"P"</span>
<span class="bp">self</span><span class="o">.</span><span class="n">palette</span> <span class="o">=</span> <span class="n">palette</span>
<span class="bp">self</span><span class="o">.</span><span class="n">palette</span><span class="o">.</span><span class="n">mode</span> <span class="o">=</span> <span class="s2">"RGB"</span>
<span class="bp">self</span><span class="o">.</span><span class="n">load</span><span class="p">()</span> <span class="c1"># install new palette</span></div>
<div class="viewcode-block" id="Image.putpixel"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image.putpixel">[docs]</a> <span class="k">def</span> <span class="nf">putpixel</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">xy</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Modifies the pixel at the given position. The color is given as</span>
<span class="sd"> a single numerical value for single-band images, and a tuple for</span>
<span class="sd"> multi-band images. In addition to this, RGB and RGBA tuples are</span>
<span class="sd"> accepted for P images.</span>
<span class="sd"> Note that this method is relatively slow. For more extensive changes,</span>
<span class="sd"> use :py:meth:`~PIL.Image.Image.paste` or the :py:mod:`~PIL.ImageDraw`</span>
<span class="sd"> module instead.</span>
<span class="sd"> See:</span>
<span class="sd"> * :py:meth:`~PIL.Image.Image.paste`</span>
<span class="sd"> * :py:meth:`~PIL.Image.Image.putdata`</span>
<span class="sd"> * :py:mod:`~PIL.ImageDraw`</span>
<span class="sd"> :param xy: The pixel coordinate, given as (x, y). See</span>
<span class="sd"> :ref:`coordinate-system`.</span>
<span class="sd"> :param value: The pixel value.</span>
<span class="sd"> """</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">readonly</span><span class="p">:</span>
<span class="bp">self</span><span class="o">.</span><span class="n">_copy</span><span class="p">()</span>
<span class="bp">self</span><span class="o">.</span><span class="n">load</span><span class="p">()</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">pyaccess</span><span class="p">:</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">pyaccess</span><span class="o">.</span><span class="n">putpixel</span><span class="p">(</span><span class="n">xy</span><span class="p">,</span> <span class="n">value</span><span class="p">)</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">mode</span> <span class="o">==</span> <span class="s2">"P"</span> <span class="ow">and</span> \
<span class="nb">isinstance</span><span class="p">(</span><span class="n">value</span><span class="p">,</span> <span class="p">(</span><span class="nb">list</span><span class="p">,</span> <span class="nb">tuple</span><span class="p">))</span> <span class="ow">and</span> <span class="nb">len</span><span class="p">(</span><span class="n">value</span><span class="p">)</span> <span class="ow">in</span> <span class="p">[</span><span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">]:</span>
<span class="c1"># RGB or RGBA value for a P image</span>
<span class="n">value</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">palette</span><span class="o">.</span><span class="n">getcolor</span><span class="p">(</span><span class="n">value</span><span class="p">)</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">putpixel</span><span class="p">(</span><span class="n">xy</span><span class="p">,</span> <span class="n">value</span><span class="p">)</span></div>
<div class="viewcode-block" id="Image.remap_palette"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image.remap_palette">[docs]</a> <span class="k">def</span> <span class="nf">remap_palette</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">dest_map</span><span class="p">,</span> <span class="n">source_palette</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Rewrites the image to reorder the palette.</span>
<span class="sd"> :param dest_map: A list of indexes into the original palette.</span>
<span class="sd"> e.g. [1,0] would swap a two item palette, and list(range(255))</span>
<span class="sd"> is the identity transform.</span>
<span class="sd"> :param source_palette: Bytes or None.</span>
<span class="sd"> :returns: An :py:class:`~PIL.Image.Image` object.</span>
<span class="sd"> """</span>
<span class="kn">from</span> <span class="nn">.</span> <span class="k">import</span> <span class="n">ImagePalette</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">mode</span> <span class="ow">not</span> <span class="ow">in</span> <span class="p">(</span><span class="s2">"L"</span><span class="p">,</span> <span class="s2">"P"</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"illegal image mode"</span><span class="p">)</span>
<span class="k">if</span> <span class="n">source_palette</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">mode</span> <span class="o">==</span> <span class="s2">"P"</span><span class="p">:</span>
<span class="n">real_source_palette</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">getpalette</span><span class="p">(</span><span class="s2">"RGB"</span><span class="p">)[:</span><span class="mi">768</span><span class="p">]</span>
<span class="k">else</span><span class="p">:</span> <span class="c1"># L-mode</span>
<span class="n">real_source_palette</span> <span class="o">=</span> <span class="nb">bytearray</span><span class="p">(</span><span class="n">i</span><span class="o">//</span><span class="mi">3</span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">768</span><span class="p">))</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">real_source_palette</span> <span class="o">=</span> <span class="n">source_palette</span>
<span class="n">palette_bytes</span> <span class="o">=</span> <span class="sa">b</span><span class="s2">""</span>
<span class="n">new_positions</span> <span class="o">=</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">*</span><span class="mi">256</span>
<span class="c1"># pick only the used colors from the palette</span>
<span class="k">for</span> <span class="n">i</span><span class="p">,</span> <span class="n">oldPosition</span> <span class="ow">in</span> <span class="nb">enumerate</span><span class="p">(</span><span class="n">dest_map</span><span class="p">):</span>
<span class="n">palette_bytes</span> <span class="o">+=</span> <span class="n">real_source_palette</span><span class="p">[</span><span class="n">oldPosition</span><span class="o">*</span><span class="mi">3</span><span class="p">:</span><span class="n">oldPosition</span><span class="o">*</span><span class="mi">3</span><span class="o">+</span><span class="mi">3</span><span class="p">]</span>
<span class="n">new_positions</span><span class="p">[</span><span class="n">oldPosition</span><span class="p">]</span> <span class="o">=</span> <span class="n">i</span>
<span class="c1"># replace the palette color id of all pixel with the new id</span>
<span class="c1"># Palette images are [0..255], mapped through a 1 or 3</span>
<span class="c1"># byte/color map. We need to remap the whole image</span>
<span class="c1"># from palette 1 to palette 2. New_positions is</span>
<span class="c1"># an array of indexes into palette 1. Palette 2 is</span>
<span class="c1"># palette 1 with any holes removed.</span>
<span class="c1"># We're going to leverage the convert mechanism to use the</span>
<span class="c1"># C code to remap the image from palette 1 to palette 2,</span>
<span class="c1"># by forcing the source image into 'L' mode and adding a</span>
<span class="c1"># mapping 'L' mode palette, then converting back to 'L'</span>
<span class="c1"># sans palette thus converting the image bytes, then</span>
<span class="c1"># assigning the optimized RGB palette.</span>
<span class="c1"># perf reference, 9500x4000 gif, w/~135 colors</span>
<span class="c1"># 14 sec prepatch, 1 sec postpatch with optimization forced.</span>
<span class="n">mapping_palette</span> <span class="o">=</span> <span class="nb">bytearray</span><span class="p">(</span><span class="n">new_positions</span><span class="p">)</span>
<span class="n">m_im</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">copy</span><span class="p">()</span>
<span class="n">m_im</span><span class="o">.</span><span class="n">mode</span> <span class="o">=</span> <span class="s1">'P'</span>
<span class="n">m_im</span><span class="o">.</span><span class="n">palette</span> <span class="o">=</span> <span class="n">ImagePalette</span><span class="o">.</span><span class="n">ImagePalette</span><span class="p">(</span><span class="s2">"RGB"</span><span class="p">,</span>
<span class="n">palette</span><span class="o">=</span><span class="n">mapping_palette</span><span class="o">*</span><span class="mi">3</span><span class="p">,</span>
<span class="n">size</span><span class="o">=</span><span class="mi">768</span><span class="p">)</span>
<span class="c1"># possibly set palette dirty, then</span>
<span class="c1"># m_im.putpalette(mapping_palette, 'L') # converts to 'P'</span>
<span class="c1"># or just force it.</span>
<span class="c1"># UNDONE -- this is part of the general issue with palettes</span>
<span class="n">m_im</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">putpalette</span><span class="p">(</span><span class="o">*</span><span class="n">m_im</span><span class="o">.</span><span class="n">palette</span><span class="o">.</span><span class="n">getdata</span><span class="p">())</span>
<span class="n">m_im</span> <span class="o">=</span> <span class="n">m_im</span><span class="o">.</span><span class="n">convert</span><span class="p">(</span><span class="s1">'L'</span><span class="p">)</span>
<span class="c1"># Internally, we require 768 bytes for a palette.</span>
<span class="n">new_palette_bytes</span> <span class="o">=</span> <span class="p">(</span><span class="n">palette_bytes</span> <span class="o">+</span>
<span class="p">(</span><span class="mi">768</span> <span class="o">-</span> <span class="nb">len</span><span class="p">(</span><span class="n">palette_bytes</span><span class="p">))</span> <span class="o">*</span> <span class="sa">b</span><span class="s1">'</span><span class="se">\x00</span><span class="s1">'</span><span class="p">)</span>
<span class="n">m_im</span><span class="o">.</span><span class="n">putpalette</span><span class="p">(</span><span class="n">new_palette_bytes</span><span class="p">)</span>
<span class="n">m_im</span><span class="o">.</span><span class="n">palette</span> <span class="o">=</span> <span class="n">ImagePalette</span><span class="o">.</span><span class="n">ImagePalette</span><span class="p">(</span><span class="s2">"RGB"</span><span class="p">,</span>
<span class="n">palette</span><span class="o">=</span><span class="n">palette_bytes</span><span class="p">,</span>
<span class="n">size</span><span class="o">=</span><span class="nb">len</span><span class="p">(</span><span class="n">palette_bytes</span><span class="p">))</span>
<span class="k">return</span> <span class="n">m_im</span></div>
<div class="viewcode-block" id="Image.resize"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image.resize">[docs]</a> <span class="k">def</span> <span class="nf">resize</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">size</span><span class="p">,</span> <span class="n">resample</span><span class="o">=</span><span class="n">NEAREST</span><span class="p">,</span> <span class="n">box</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Returns a resized copy of this image.</span>
<span class="sd"> :param size: The requested size in pixels, as a 2-tuple:</span>
<span class="sd"> (width, height).</span>
<span class="sd"> :param resample: An optional resampling filter. This can be</span>
<span class="sd"> one of :py:attr:`PIL.Image.NEAREST`, :py:attr:`PIL.Image.BOX`,</span>
<span class="sd"> :py:attr:`PIL.Image.BILINEAR`, :py:attr:`PIL.Image.HAMMING`,</span>
<span class="sd"> :py:attr:`PIL.Image.BICUBIC` or :py:attr:`PIL.Image.LANCZOS`.</span>
<span class="sd"> If omitted, or if the image has mode "1" or "P", it is</span>
<span class="sd"> set :py:attr:`PIL.Image.NEAREST`.</span>
<span class="sd"> See: :ref:`concept-filters`.</span>
<span class="sd"> :param box: An optional 4-tuple of floats giving the region</span>
<span class="sd"> of the source image which should be scaled.</span>
<span class="sd"> The values should be within (0, 0, width, height) rectangle.</span>
<span class="sd"> If omitted or None, the entire source is used.</span>
<span class="sd"> :returns: An :py:class:`~PIL.Image.Image` object.</span>
<span class="sd"> """</span>
<span class="k">if</span> <span class="n">resample</span> <span class="ow">not</span> <span class="ow">in</span> <span class="p">(</span>
<span class="n">NEAREST</span><span class="p">,</span> <span class="n">BILINEAR</span><span class="p">,</span> <span class="n">BICUBIC</span><span class="p">,</span> <span class="n">LANCZOS</span><span class="p">,</span> <span class="n">BOX</span><span class="p">,</span> <span class="n">HAMMING</span><span class="p">,</span>
<span class="p">):</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"unknown resampling filter"</span><span class="p">)</span>
<span class="n">size</span> <span class="o">=</span> <span class="nb">tuple</span><span class="p">(</span><span class="n">size</span><span class="p">)</span>
<span class="k">if</span> <span class="n">box</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="n">box</span> <span class="o">=</span> <span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span> <span class="o">+</span> <span class="bp">self</span><span class="o">.</span><span class="n">size</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">box</span> <span class="o">=</span> <span class="nb">tuple</span><span class="p">(</span><span class="n">box</span><span class="p">)</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">size</span> <span class="o">==</span> <span class="n">size</span> <span class="ow">and</span> <span class="n">box</span> <span class="o">==</span> <span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span> <span class="o">+</span> <span class="bp">self</span><span class="o">.</span><span class="n">size</span><span class="p">:</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">copy</span><span class="p">()</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">mode</span> <span class="ow">in</span> <span class="p">(</span><span class="s2">"1"</span><span class="p">,</span> <span class="s2">"P"</span><span class="p">):</span>
<span class="n">resample</span> <span class="o">=</span> <span class="n">NEAREST</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">mode</span> <span class="ow">in</span> <span class="p">[</span><span class="s1">'LA'</span><span class="p">,</span> <span class="s1">'RGBA'</span><span class="p">]:</span>
<span class="n">im</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">convert</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">mode</span><span class="p">[:</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span><span class="o">+</span><span class="s1">'a'</span><span class="p">)</span>
<span class="n">im</span> <span class="o">=</span> <span class="n">im</span><span class="o">.</span><span class="n">resize</span><span class="p">(</span><span class="n">size</span><span class="p">,</span> <span class="n">resample</span><span class="p">,</span> <span class="n">box</span><span class="p">)</span>
<span class="k">return</span> <span class="n">im</span><span class="o">.</span><span class="n">convert</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">mode</span><span class="p">)</span>
<span class="bp">self</span><span class="o">.</span><span class="n">load</span><span class="p">()</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_new</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">resize</span><span class="p">(</span><span class="n">size</span><span class="p">,</span> <span class="n">resample</span><span class="p">,</span> <span class="n">box</span><span class="p">))</span></div>
<div class="viewcode-block" id="Image.rotate"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image.rotate">[docs]</a> <span class="k">def</span> <span class="nf">rotate</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">angle</span><span class="p">,</span> <span class="n">resample</span><span class="o">=</span><span class="n">NEAREST</span><span class="p">,</span> <span class="n">expand</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">center</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span>
<span class="n">translate</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">fillcolor</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Returns a rotated copy of this image. This method returns a</span>
<span class="sd"> copy of this image, rotated the given number of degrees counter</span>
<span class="sd"> clockwise around its centre.</span>
<span class="sd"> :param angle: In degrees counter clockwise.</span>
<span class="sd"> :param resample: An optional resampling filter. This can be</span>
<span class="sd"> one of :py:attr:`PIL.Image.NEAREST` (use nearest neighbour),</span>
<span class="sd"> :py:attr:`PIL.Image.BILINEAR` (linear interpolation in a 2x2</span>
<span class="sd"> environment), or :py:attr:`PIL.Image.BICUBIC`</span>
<span class="sd"> (cubic spline interpolation in a 4x4 environment).</span>
<span class="sd"> If omitted, or if the image has mode "1" or "P", it is</span>
<span class="sd"> set :py:attr:`PIL.Image.NEAREST`. See :ref:`concept-filters`.</span>
<span class="sd"> :param expand: Optional expansion flag. If true, expands the output</span>
<span class="sd"> image to make it large enough to hold the entire rotated image.</span>
<span class="sd"> If false or omitted, make the output image the same size as the</span>
<span class="sd"> input image. Note that the expand flag assumes rotation around</span>
<span class="sd"> the center and no translation.</span>
<span class="sd"> :param center: Optional center of rotation (a 2-tuple). Origin is</span>
<span class="sd"> the upper left corner. Default is the center of the image.</span>
<span class="sd"> :param translate: An optional post-rotate translation (a 2-tuple).</span>
<span class="sd"> :param fillcolor: An optional color for area outside the rotated image.</span>
<span class="sd"> :returns: An :py:class:`~PIL.Image.Image` object.</span>
<span class="sd"> """</span>
<span class="n">angle</span> <span class="o">=</span> <span class="n">angle</span> <span class="o">%</span> <span class="mf">360.0</span>
<span class="c1"># Fast paths regardless of filter, as long as we're not</span>
<span class="c1"># translating or changing the center.</span>
<span class="k">if</span> <span class="ow">not</span> <span class="p">(</span><span class="n">center</span> <span class="ow">or</span> <span class="n">translate</span><span class="p">):</span>
<span class="k">if</span> <span class="n">angle</span> <span class="o">==</span> <span class="mi">0</span><span class="p">:</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">copy</span><span class="p">()</span>
<span class="k">if</span> <span class="n">angle</span> <span class="o">==</span> <span class="mi">180</span><span class="p">:</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">transpose</span><span class="p">(</span><span class="n">ROTATE_180</span><span class="p">)</span>
<span class="k">if</span> <span class="n">angle</span> <span class="o">==</span> <span class="mi">90</span> <span class="ow">and</span> <span class="n">expand</span><span class="p">:</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">transpose</span><span class="p">(</span><span class="n">ROTATE_90</span><span class="p">)</span>
<span class="k">if</span> <span class="n">angle</span> <span class="o">==</span> <span class="mi">270</span> <span class="ow">and</span> <span class="n">expand</span><span class="p">:</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">transpose</span><span class="p">(</span><span class="n">ROTATE_270</span><span class="p">)</span>
<span class="c1"># Calculate the affine matrix. Note that this is the reverse</span>
<span class="c1"># transformation (from destination image to source) because we</span>
<span class="c1"># want to interpolate the (discrete) destination pixel from</span>
<span class="c1"># the local area around the (floating) source pixel.</span>
<span class="c1"># The matrix we actually want (note that it operates from the right):</span>
<span class="c1"># (1, 0, tx) (1, 0, cx) ( cos a, sin a, 0) (1, 0, -cx)</span>
<span class="c1"># (0, 1, ty) * (0, 1, cy) * (-sin a, cos a, 0) * (0, 1, -cy)</span>
<span class="c1"># (0, 0, 1) (0, 0, 1) ( 0, 0, 1) (0, 0, 1)</span>
<span class="c1"># The reverse matrix is thus:</span>
<span class="c1"># (1, 0, cx) ( cos -a, sin -a, 0) (1, 0, -cx) (1, 0, -tx)</span>
<span class="c1"># (0, 1, cy) * (-sin -a, cos -a, 0) * (0, 1, -cy) * (0, 1, -ty)</span>
<span class="c1"># (0, 0, 1) ( 0, 0, 1) (0, 0, 1) (0, 0, 1)</span>
<span class="c1"># In any case, the final translation may be updated at the end to</span>
<span class="c1"># compensate for the expand flag.</span>
<span class="n">w</span><span class="p">,</span> <span class="n">h</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">size</span>
<span class="k">if</span> <span class="n">translate</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="n">post_trans</span> <span class="o">=</span> <span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">post_trans</span> <span class="o">=</span> <span class="n">translate</span>
<span class="k">if</span> <span class="n">center</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="c1"># FIXME These should be rounded to ints?</span>
<span class="n">rotn_center</span> <span class="o">=</span> <span class="p">(</span><span class="n">w</span> <span class="o">/</span> <span class="mf">2.0</span><span class="p">,</span> <span class="n">h</span> <span class="o">/</span> <span class="mf">2.0</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">rotn_center</span> <span class="o">=</span> <span class="n">center</span>
<span class="n">angle</span> <span class="o">=</span> <span class="o">-</span> <span class="n">math</span><span class="o">.</span><span class="n">radians</span><span class="p">(</span><span class="n">angle</span><span class="p">)</span>
<span class="n">matrix</span> <span class="o">=</span> <span class="p">[</span>
<span class="nb">round</span><span class="p">(</span><span class="n">math</span><span class="o">.</span><span class="n">cos</span><span class="p">(</span><span class="n">angle</span><span class="p">),</span> <span class="mi">15</span><span class="p">),</span> <span class="nb">round</span><span class="p">(</span><span class="n">math</span><span class="o">.</span><span class="n">sin</span><span class="p">(</span><span class="n">angle</span><span class="p">),</span> <span class="mi">15</span><span class="p">),</span> <span class="mf">0.0</span><span class="p">,</span>
<span class="nb">round</span><span class="p">(</span><span class="o">-</span><span class="n">math</span><span class="o">.</span><span class="n">sin</span><span class="p">(</span><span class="n">angle</span><span class="p">),</span> <span class="mi">15</span><span class="p">),</span> <span class="nb">round</span><span class="p">(</span><span class="n">math</span><span class="o">.</span><span class="n">cos</span><span class="p">(</span><span class="n">angle</span><span class="p">),</span> <span class="mi">15</span><span class="p">),</span> <span class="mf">0.0</span>
<span class="p">]</span>
<span class="k">def</span> <span class="nf">transform</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="n">matrix</span><span class="p">):</span>
<span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">,</span> <span class="n">c</span><span class="p">,</span> <span class="n">d</span><span class="p">,</span> <span class="n">e</span><span class="p">,</span> <span class="n">f</span><span class="p">)</span> <span class="o">=</span> <span class="n">matrix</span>
<span class="k">return</span> <span class="n">a</span><span class="o">*</span><span class="n">x</span> <span class="o">+</span> <span class="n">b</span><span class="o">*</span><span class="n">y</span> <span class="o">+</span> <span class="n">c</span><span class="p">,</span> <span class="n">d</span><span class="o">*</span><span class="n">x</span> <span class="o">+</span> <span class="n">e</span><span class="o">*</span><span class="n">y</span> <span class="o">+</span> <span class="n">f</span>
<span class="n">matrix</span><span class="p">[</span><span class="mi">2</span><span class="p">],</span> <span class="n">matrix</span><span class="p">[</span><span class="mi">5</span><span class="p">]</span> <span class="o">=</span> <span class="n">transform</span><span class="p">(</span><span class="o">-</span><span class="n">rotn_center</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">-</span> <span class="n">post_trans</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span>
<span class="o">-</span><span class="n">rotn_center</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="o">-</span> <span class="n">post_trans</span><span class="p">[</span><span class="mi">1</span><span class="p">],</span>
<span class="n">matrix</span><span class="p">)</span>
<span class="n">matrix</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span> <span class="o">+=</span> <span class="n">rotn_center</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
<span class="n">matrix</span><span class="p">[</span><span class="mi">5</span><span class="p">]</span> <span class="o">+=</span> <span class="n">rotn_center</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span>
<span class="k">if</span> <span class="n">expand</span><span class="p">:</span>
<span class="c1"># calculate output size</span>
<span class="n">xx</span> <span class="o">=</span> <span class="p">[]</span>
<span class="n">yy</span> <span class="o">=</span> <span class="p">[]</span>
<span class="k">for</span> <span class="n">x</span><span class="p">,</span> <span class="n">y</span> <span class="ow">in</span> <span class="p">((</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">),</span> <span class="p">(</span><span class="n">w</span><span class="p">,</span> <span class="mi">0</span><span class="p">),</span> <span class="p">(</span><span class="n">w</span><span class="p">,</span> <span class="n">h</span><span class="p">),</span> <span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="n">h</span><span class="p">)):</span>
<span class="n">x</span><span class="p">,</span> <span class="n">y</span> <span class="o">=</span> <span class="n">transform</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="n">matrix</span><span class="p">)</span>
<span class="n">xx</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
<span class="n">yy</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">y</span><span class="p">)</span>
<span class="n">nw</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">math</span><span class="o">.</span><span class="n">ceil</span><span class="p">(</span><span class="nb">max</span><span class="p">(</span><span class="n">xx</span><span class="p">))</span> <span class="o">-</span> <span class="n">math</span><span class="o">.</span><span class="n">floor</span><span class="p">(</span><span class="nb">min</span><span class="p">(</span><span class="n">xx</span><span class="p">)))</span>
<span class="n">nh</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">math</span><span class="o">.</span><span class="n">ceil</span><span class="p">(</span><span class="nb">max</span><span class="p">(</span><span class="n">yy</span><span class="p">))</span> <span class="o">-</span> <span class="n">math</span><span class="o">.</span><span class="n">floor</span><span class="p">(</span><span class="nb">min</span><span class="p">(</span><span class="n">yy</span><span class="p">)))</span>
<span class="c1"># We multiply a translation matrix from the right. Because of its</span>
<span class="c1"># special form, this is the same as taking the image of the</span>
<span class="c1"># translation vector as new translation vector.</span>
<span class="n">matrix</span><span class="p">[</span><span class="mi">2</span><span class="p">],</span> <span class="n">matrix</span><span class="p">[</span><span class="mi">5</span><span class="p">]</span> <span class="o">=</span> <span class="n">transform</span><span class="p">(</span><span class="o">-</span><span class="p">(</span><span class="n">nw</span> <span class="o">-</span> <span class="n">w</span><span class="p">)</span> <span class="o">/</span> <span class="mf">2.0</span><span class="p">,</span>
<span class="o">-</span><span class="p">(</span><span class="n">nh</span> <span class="o">-</span> <span class="n">h</span><span class="p">)</span> <span class="o">/</span> <span class="mf">2.0</span><span class="p">,</span>
<span class="n">matrix</span><span class="p">)</span>
<span class="n">w</span><span class="p">,</span> <span class="n">h</span> <span class="o">=</span> <span class="n">nw</span><span class="p">,</span> <span class="n">nh</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">transform</span><span class="p">((</span><span class="n">w</span><span class="p">,</span> <span class="n">h</span><span class="p">),</span> <span class="n">AFFINE</span><span class="p">,</span> <span class="n">matrix</span><span class="p">,</span> <span class="n">resample</span><span class="p">,</span>
<span class="n">fillcolor</span><span class="o">=</span><span class="n">fillcolor</span><span class="p">)</span></div>
<div class="viewcode-block" id="Image.save"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image.save">[docs]</a> <span class="k">def</span> <span class="nf">save</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">fp</span><span class="p">,</span> <span class="nb">format</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="o">**</span><span class="n">params</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Saves this image under the given filename. If no format is</span>
<span class="sd"> specified, the format to use is determined from the filename</span>
<span class="sd"> extension, if possible.</span>
<span class="sd"> Keyword options can be used to provide additional instructions</span>
<span class="sd"> to the writer. If a writer doesn't recognise an option, it is</span>
<span class="sd"> silently ignored. The available options are described in the</span>
<span class="sd"> :doc:`image format documentation</span>
<span class="sd"> <../handbook/image-file-formats>` for each writer.</span>
<span class="sd"> You can use a file object instead of a filename. In this case,</span>
<span class="sd"> you must always specify the format. The file object must</span>
<span class="sd"> implement the ``seek``, ``tell``, and ``write``</span>
<span class="sd"> methods, and be opened in binary mode.</span>
<span class="sd"> :param fp: A filename (string), pathlib.Path object or file object.</span>
<span class="sd"> :param format: Optional format override. If omitted, the</span>
<span class="sd"> format to use is determined from the filename extension.</span>
<span class="sd"> If a file object was used instead of a filename, this</span>
<span class="sd"> parameter should always be used.</span>
<span class="sd"> :param params: Extra parameters to the image writer.</span>
<span class="sd"> :returns: None</span>
<span class="sd"> :exception ValueError: If the output format could not be determined</span>
<span class="sd"> from the file name. Use the format option to solve this.</span>
<span class="sd"> :exception IOError: If the file could not be written. The file</span>
<span class="sd"> may have been created, and may contain partial data.</span>
<span class="sd"> """</span>
<span class="n">filename</span> <span class="o">=</span> <span class="s2">""</span>
<span class="n">open_fp</span> <span class="o">=</span> <span class="kc">False</span>
<span class="k">if</span> <span class="n">isPath</span><span class="p">(</span><span class="n">fp</span><span class="p">):</span>
<span class="n">filename</span> <span class="o">=</span> <span class="n">fp</span>
<span class="n">open_fp</span> <span class="o">=</span> <span class="kc">True</span>
<span class="k">elif</span> <span class="n">HAS_PATHLIB</span> <span class="ow">and</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">fp</span><span class="p">,</span> <span class="n">Path</span><span class="p">):</span>
<span class="n">filename</span> <span class="o">=</span> <span class="nb">str</span><span class="p">(</span><span class="n">fp</span><span class="p">)</span>
<span class="n">open_fp</span> <span class="o">=</span> <span class="kc">True</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">filename</span> <span class="ow">and</span> <span class="nb">hasattr</span><span class="p">(</span><span class="n">fp</span><span class="p">,</span> <span class="s2">"name"</span><span class="p">)</span> <span class="ow">and</span> <span class="n">isPath</span><span class="p">(</span><span class="n">fp</span><span class="o">.</span><span class="n">name</span><span class="p">):</span>
<span class="c1"># only set the name for metadata purposes</span>
<span class="n">filename</span> <span class="o">=</span> <span class="n">fp</span><span class="o">.</span><span class="n">name</span>
<span class="c1"># may mutate self!</span>
<span class="bp">self</span><span class="o">.</span><span class="n">load</span><span class="p">()</span>
<span class="n">save_all</span> <span class="o">=</span> <span class="n">params</span><span class="o">.</span><span class="n">pop</span><span class="p">(</span><span class="s1">'save_all'</span><span class="p">,</span> <span class="kc">False</span><span class="p">)</span>
<span class="bp">self</span><span class="o">.</span><span class="n">encoderinfo</span> <span class="o">=</span> <span class="n">params</span>
<span class="bp">self</span><span class="o">.</span><span class="n">encoderconfig</span> <span class="o">=</span> <span class="p">()</span>
<span class="n">preinit</span><span class="p">()</span>
<span class="n">ext</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">splitext</span><span class="p">(</span><span class="n">filename</span><span class="p">)[</span><span class="mi">1</span><span class="p">]</span><span class="o">.</span><span class="n">lower</span><span class="p">()</span>
<span class="k">if</span> <span class="ow">not</span> <span class="nb">format</span><span class="p">:</span>
<span class="k">if</span> <span class="n">ext</span> <span class="ow">not</span> <span class="ow">in</span> <span class="n">EXTENSION</span><span class="p">:</span>
<span class="n">init</span><span class="p">()</span>
<span class="k">try</span><span class="p">:</span>
<span class="nb">format</span> <span class="o">=</span> <span class="n">EXTENSION</span><span class="p">[</span><span class="n">ext</span><span class="p">]</span>
<span class="k">except</span> <span class="ne">KeyError</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s1">'unknown file extension: </span><span class="si">{}</span><span class="s1">'</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">ext</span><span class="p">))</span>
<span class="k">if</span> <span class="nb">format</span><span class="o">.</span><span class="n">upper</span><span class="p">()</span> <span class="ow">not</span> <span class="ow">in</span> <span class="n">SAVE</span><span class="p">:</span>
<span class="n">init</span><span class="p">()</span>
<span class="k">if</span> <span class="n">save_all</span><span class="p">:</span>
<span class="n">save_handler</span> <span class="o">=</span> <span class="n">SAVE_ALL</span><span class="p">[</span><span class="nb">format</span><span class="o">.</span><span class="n">upper</span><span class="p">()]</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">save_handler</span> <span class="o">=</span> <span class="n">SAVE</span><span class="p">[</span><span class="nb">format</span><span class="o">.</span><span class="n">upper</span><span class="p">()]</span>
<span class="k">if</span> <span class="n">open_fp</span><span class="p">:</span>
<span class="k">if</span> <span class="n">params</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s1">'append'</span><span class="p">,</span> <span class="kc">False</span><span class="p">):</span>
<span class="n">fp</span> <span class="o">=</span> <span class="n">builtins</span><span class="o">.</span><span class="n">open</span><span class="p">(</span><span class="n">filename</span><span class="p">,</span> <span class="s2">"r+b"</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="c1"># Open also for reading ("+"), because TIFF save_all</span>
<span class="c1"># writer needs to go back and edit the written data.</span>
<span class="n">fp</span> <span class="o">=</span> <span class="n">builtins</span><span class="o">.</span><span class="n">open</span><span class="p">(</span><span class="n">filename</span><span class="p">,</span> <span class="s2">"w+b"</span><span class="p">)</span>
<span class="k">try</span><span class="p">:</span>
<span class="n">save_handler</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">fp</span><span class="p">,</span> <span class="n">filename</span><span class="p">)</span>
<span class="k">finally</span><span class="p">:</span>
<span class="c1"># do what we can to clean up</span>
<span class="k">if</span> <span class="n">open_fp</span><span class="p">:</span>
<span class="n">fp</span><span class="o">.</span><span class="n">close</span><span class="p">()</span></div>
<div class="viewcode-block" id="Image.seek"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image.seek">[docs]</a> <span class="k">def</span> <span class="nf">seek</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">frame</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Seeks to the given frame in this sequence file. If you seek</span>
<span class="sd"> beyond the end of the sequence, the method raises an</span>
<span class="sd"> **EOFError** exception. When a sequence file is opened, the</span>
<span class="sd"> library automatically seeks to frame 0.</span>
<span class="sd"> Note that in the current version of the library, most sequence</span>
<span class="sd"> formats only allows you to seek to the next frame.</span>
<span class="sd"> See :py:meth:`~PIL.Image.Image.tell`.</span>
<span class="sd"> :param frame: Frame number, starting at 0.</span>
<span class="sd"> :exception EOFError: If the call attempts to seek beyond the end</span>
<span class="sd"> of the sequence.</span>
<span class="sd"> """</span>
<span class="c1"># overridden by file handlers</span>
<span class="k">if</span> <span class="n">frame</span> <span class="o">!=</span> <span class="mi">0</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">EOFError</span></div>
<div class="viewcode-block" id="Image.show"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image.show">[docs]</a> <span class="k">def</span> <span class="nf">show</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">title</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">command</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Displays this image. This method is mainly intended for</span>
<span class="sd"> debugging purposes.</span>
<span class="sd"> On Unix platforms, this method saves the image to a temporary</span>
<span class="sd"> PPM file, and calls either the **xv** utility or the **display**</span>
<span class="sd"> utility, depending on which one can be found.</span>
<span class="sd"> On macOS, this method saves the image to a temporary BMP file, and</span>
<span class="sd"> opens it with the native Preview application.</span>
<span class="sd"> On Windows, it saves the image to a temporary BMP file, and uses</span>
<span class="sd"> the standard BMP display utility to show it (usually Paint).</span>
<span class="sd"> :param title: Optional title to use for the image window,</span>
<span class="sd"> where possible.</span>
<span class="sd"> :param command: command used to show the image</span>
<span class="sd"> """</span>
<span class="n">_show</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">title</span><span class="o">=</span><span class="n">title</span><span class="p">,</span> <span class="n">command</span><span class="o">=</span><span class="n">command</span><span class="p">)</span></div>
<div class="viewcode-block" id="Image.split"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image.split">[docs]</a> <span class="k">def</span> <span class="nf">split</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Split this image into individual bands. This method returns a</span>
<span class="sd"> tuple of individual image bands from an image. For example,</span>
<span class="sd"> splitting an "RGB" image creates three new images each</span>
<span class="sd"> containing a copy of one of the original bands (red, green,</span>
<span class="sd"> blue).</span>
<span class="sd"> If you need only one band, :py:meth:`~PIL.Image.Image.getchannel`</span>
<span class="sd"> method can be more convenient and faster.</span>
<span class="sd"> :returns: A tuple containing bands.</span>
<span class="sd"> """</span>
<span class="bp">self</span><span class="o">.</span><span class="n">load</span><span class="p">()</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">bands</span> <span class="o">==</span> <span class="mi">1</span><span class="p">:</span>
<span class="n">ims</span> <span class="o">=</span> <span class="p">[</span><span class="bp">self</span><span class="o">.</span><span class="n">copy</span><span class="p">()]</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">ims</span> <span class="o">=</span> <span class="nb">map</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_new</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">split</span><span class="p">())</span>
<span class="k">return</span> <span class="nb">tuple</span><span class="p">(</span><span class="n">ims</span><span class="p">)</span></div>
<div class="viewcode-block" id="Image.getchannel"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image.getchannel">[docs]</a> <span class="k">def</span> <span class="nf">getchannel</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">channel</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Returns an image containing a single channel of the source image.</span>
<span class="sd"> :param channel: What channel to return. Could be index</span>
<span class="sd"> (0 for "R" channel of "RGB") or channel name</span>
<span class="sd"> ("A" for alpha channel of "RGBA").</span>
<span class="sd"> :returns: An image in "L" mode.</span>
<span class="sd"> .. versionadded:: 4.3.0</span>
<span class="sd"> """</span>
<span class="bp">self</span><span class="o">.</span><span class="n">load</span><span class="p">()</span>
<span class="k">if</span> <span class="n">isStringType</span><span class="p">(</span><span class="n">channel</span><span class="p">):</span>
<span class="k">try</span><span class="p">:</span>
<span class="n">channel</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">getbands</span><span class="p">()</span><span class="o">.</span><span class="n">index</span><span class="p">(</span><span class="n">channel</span><span class="p">)</span>
<span class="k">except</span> <span class="ne">ValueError</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span>
<span class="s1">'The image has no channel "</span><span class="si">{}</span><span class="s1">"'</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">channel</span><span class="p">))</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_new</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">getband</span><span class="p">(</span><span class="n">channel</span><span class="p">))</span></div>
<div class="viewcode-block" id="Image.tell"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image.tell">[docs]</a> <span class="k">def</span> <span class="nf">tell</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Returns the current frame number. See :py:meth:`~PIL.Image.Image.seek`.</span>
<span class="sd"> :returns: Frame number, starting with 0.</span>
<span class="sd"> """</span>
<span class="k">return</span> <span class="mi">0</span></div>
<div class="viewcode-block" id="Image.thumbnail"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image.thumbnail">[docs]</a> <span class="k">def</span> <span class="nf">thumbnail</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">size</span><span class="p">,</span> <span class="n">resample</span><span class="o">=</span><span class="n">BICUBIC</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Make this image into a thumbnail. This method modifies the</span>
<span class="sd"> image to contain a thumbnail version of itself, no larger than</span>
<span class="sd"> the given size. This method calculates an appropriate thumbnail</span>
<span class="sd"> size to preserve the aspect of the image, calls the</span>
<span class="sd"> :py:meth:`~PIL.Image.Image.draft` method to configure the file reader</span>
<span class="sd"> (where applicable), and finally resizes the image.</span>
<span class="sd"> Note that this function modifies the :py:class:`~PIL.Image.Image`</span>
<span class="sd"> object in place. If you need to use the full resolution image as well,</span>
<span class="sd"> apply this method to a :py:meth:`~PIL.Image.Image.copy` of the original</span>
<span class="sd"> image.</span>
<span class="sd"> :param size: Requested size.</span>
<span class="sd"> :param resample: Optional resampling filter. This can be one</span>
<span class="sd"> of :py:attr:`PIL.Image.NEAREST`, :py:attr:`PIL.Image.BILINEAR`,</span>
<span class="sd"> :py:attr:`PIL.Image.BICUBIC`, or :py:attr:`PIL.Image.LANCZOS`.</span>
<span class="sd"> If omitted, it defaults to :py:attr:`PIL.Image.BICUBIC`.</span>
<span class="sd"> (was :py:attr:`PIL.Image.NEAREST` prior to version 2.5.0)</span>
<span class="sd"> :returns: None</span>
<span class="sd"> """</span>
<span class="c1"># preserve aspect ratio</span>
<span class="n">x</span><span class="p">,</span> <span class="n">y</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">size</span>
<span class="k">if</span> <span class="n">x</span> <span class="o">></span> <span class="n">size</span><span class="p">[</span><span class="mi">0</span><span class="p">]:</span>
<span class="n">y</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="nb">max</span><span class="p">(</span><span class="n">y</span> <span class="o">*</span> <span class="n">size</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">/</span> <span class="n">x</span><span class="p">,</span> <span class="mi">1</span><span class="p">))</span>
<span class="n">x</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">size</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span>
<span class="k">if</span> <span class="n">y</span> <span class="o">></span> <span class="n">size</span><span class="p">[</span><span class="mi">1</span><span class="p">]:</span>
<span class="n">x</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="nb">max</span><span class="p">(</span><span class="n">x</span> <span class="o">*</span> <span class="n">size</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="o">/</span> <span class="n">y</span><span class="p">,</span> <span class="mi">1</span><span class="p">))</span>
<span class="n">y</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">size</span><span class="p">[</span><span class="mi">1</span><span class="p">])</span>
<span class="n">size</span> <span class="o">=</span> <span class="n">x</span><span class="p">,</span> <span class="n">y</span>
<span class="k">if</span> <span class="n">size</span> <span class="o">==</span> <span class="bp">self</span><span class="o">.</span><span class="n">size</span><span class="p">:</span>
<span class="k">return</span>
<span class="bp">self</span><span class="o">.</span><span class="n">draft</span><span class="p">(</span><span class="kc">None</span><span class="p">,</span> <span class="n">size</span><span class="p">)</span>
<span class="n">im</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">resize</span><span class="p">(</span><span class="n">size</span><span class="p">,</span> <span class="n">resample</span><span class="p">)</span>
<span class="bp">self</span><span class="o">.</span><span class="n">im</span> <span class="o">=</span> <span class="n">im</span><span class="o">.</span><span class="n">im</span>
<span class="bp">self</span><span class="o">.</span><span class="n">mode</span> <span class="o">=</span> <span class="n">im</span><span class="o">.</span><span class="n">mode</span>
<span class="bp">self</span><span class="o">.</span><span class="n">_size</span> <span class="o">=</span> <span class="n">size</span>
<span class="bp">self</span><span class="o">.</span><span class="n">readonly</span> <span class="o">=</span> <span class="mi">0</span>
<span class="bp">self</span><span class="o">.</span><span class="n">pyaccess</span> <span class="o">=</span> <span class="kc">None</span></div>
<span class="c1"># FIXME: the different transform methods need further explanation</span>
<span class="c1"># instead of bloating the method docs, add a separate chapter.</span>
<div class="viewcode-block" id="Image.transform"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image.transform">[docs]</a> <span class="k">def</span> <span class="nf">transform</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">size</span><span class="p">,</span> <span class="n">method</span><span class="p">,</span> <span class="n">data</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">resample</span><span class="o">=</span><span class="n">NEAREST</span><span class="p">,</span>
<span class="n">fill</span><span class="o">=</span><span class="mi">1</span><span class="p">,</span> <span class="n">fillcolor</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Transforms this image. This method creates a new image with the</span>
<span class="sd"> given size, and the same mode as the original, and copies data</span>
<span class="sd"> to the new image using the given transform.</span>
<span class="sd"> :param size: The output size.</span>
<span class="sd"> :param method: The transformation method. This is one of</span>
<span class="sd"> :py:attr:`PIL.Image.EXTENT` (cut out a rectangular subregion),</span>
<span class="sd"> :py:attr:`PIL.Image.AFFINE` (affine transform),</span>
<span class="sd"> :py:attr:`PIL.Image.PERSPECTIVE` (perspective transform),</span>
<span class="sd"> :py:attr:`PIL.Image.QUAD` (map a quadrilateral to a rectangle), or</span>
<span class="sd"> :py:attr:`PIL.Image.MESH` (map a number of source quadrilaterals</span>
<span class="sd"> in one operation).</span>
<span class="sd"> It may also be an :py:class:`~PIL.Image.ImageTransformHandler`</span>
<span class="sd"> object::</span>
<span class="sd"> class Example(Image.ImageTransformHandler):</span>
<span class="sd"> def transform(size, method, data, resample, fill=1):</span>
<span class="sd"> # Return result</span>
<span class="sd"> It may also be an object with a :py:meth:`~method.getdata` method</span>
<span class="sd"> that returns a tuple supplying new **method** and **data** values::</span>
<span class="sd"> class Example(object):</span>
<span class="sd"> def getdata(self):</span>
<span class="sd"> method = Image.EXTENT</span>
<span class="sd"> data = (0, 0, 100, 100)</span>
<span class="sd"> return method, data</span>
<span class="sd"> :param data: Extra data to the transformation method.</span>
<span class="sd"> :param resample: Optional resampling filter. It can be one of</span>
<span class="sd"> :py:attr:`PIL.Image.NEAREST` (use nearest neighbour),</span>
<span class="sd"> :py:attr:`PIL.Image.BILINEAR` (linear interpolation in a 2x2</span>
<span class="sd"> environment), or :py:attr:`PIL.Image.BICUBIC` (cubic spline</span>
<span class="sd"> interpolation in a 4x4 environment). If omitted, or if the image</span>
<span class="sd"> has mode "1" or "P", it is set to :py:attr:`PIL.Image.NEAREST`.</span>
<span class="sd"> :param fill: If **method** is an</span>
<span class="sd"> :py:class:`~PIL.Image.ImageTransformHandler` object, this is one of</span>
<span class="sd"> the arguments passed to it. Otherwise, it is unused.</span>
<span class="sd"> :param fillcolor: Optional fill color for the area outside the</span>
<span class="sd"> transform in the output image.</span>
<span class="sd"> :returns: An :py:class:`~PIL.Image.Image` object.</span>
<span class="sd"> """</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">mode</span> <span class="o">==</span> <span class="s1">'LA'</span><span class="p">:</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">convert</span><span class="p">(</span><span class="s1">'La'</span><span class="p">)</span><span class="o">.</span><span class="n">transform</span><span class="p">(</span>
<span class="n">size</span><span class="p">,</span> <span class="n">method</span><span class="p">,</span> <span class="n">data</span><span class="p">,</span> <span class="n">resample</span><span class="p">,</span> <span class="n">fill</span><span class="p">,</span> <span class="n">fillcolor</span><span class="p">)</span><span class="o">.</span><span class="n">convert</span><span class="p">(</span><span class="s1">'LA'</span><span class="p">)</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">mode</span> <span class="o">==</span> <span class="s1">'RGBA'</span><span class="p">:</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">convert</span><span class="p">(</span><span class="s1">'RGBa'</span><span class="p">)</span><span class="o">.</span><span class="n">transform</span><span class="p">(</span>
<span class="n">size</span><span class="p">,</span> <span class="n">method</span><span class="p">,</span> <span class="n">data</span><span class="p">,</span> <span class="n">resample</span><span class="p">,</span> <span class="n">fill</span><span class="p">,</span> <span class="n">fillcolor</span><span class="p">)</span><span class="o">.</span><span class="n">convert</span><span class="p">(</span><span class="s1">'RGBA'</span><span class="p">)</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">method</span><span class="p">,</span> <span class="n">ImageTransformHandler</span><span class="p">):</span>
<span class="k">return</span> <span class="n">method</span><span class="o">.</span><span class="n">transform</span><span class="p">(</span><span class="n">size</span><span class="p">,</span> <span class="bp">self</span><span class="p">,</span> <span class="n">resample</span><span class="o">=</span><span class="n">resample</span><span class="p">,</span> <span class="n">fill</span><span class="o">=</span><span class="n">fill</span><span class="p">)</span>
<span class="k">if</span> <span class="nb">hasattr</span><span class="p">(</span><span class="n">method</span><span class="p">,</span> <span class="s2">"getdata"</span><span class="p">):</span>
<span class="c1"># compatibility w. old-style transform objects</span>
<span class="n">method</span><span class="p">,</span> <span class="n">data</span> <span class="o">=</span> <span class="n">method</span><span class="o">.</span><span class="n">getdata</span><span class="p">()</span>
<span class="k">if</span> <span class="n">data</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"missing method data"</span><span class="p">)</span>
<span class="n">im</span> <span class="o">=</span> <span class="n">new</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">mode</span><span class="p">,</span> <span class="n">size</span><span class="p">,</span> <span class="n">fillcolor</span><span class="p">)</span>
<span class="k">if</span> <span class="n">method</span> <span class="o">==</span> <span class="n">MESH</span><span class="p">:</span>
<span class="c1"># list of quads</span>
<span class="k">for</span> <span class="n">box</span><span class="p">,</span> <span class="n">quad</span> <span class="ow">in</span> <span class="n">data</span><span class="p">:</span>
<span class="n">im</span><span class="o">.</span><span class="n">__transformer</span><span class="p">(</span><span class="n">box</span><span class="p">,</span> <span class="bp">self</span><span class="p">,</span> <span class="n">QUAD</span><span class="p">,</span> <span class="n">quad</span><span class="p">,</span> <span class="n">resample</span><span class="p">,</span>
<span class="n">fillcolor</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">im</span><span class="o">.</span><span class="n">__transformer</span><span class="p">((</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span><span class="o">+</span><span class="n">size</span><span class="p">,</span> <span class="bp">self</span><span class="p">,</span> <span class="n">method</span><span class="p">,</span> <span class="n">data</span><span class="p">,</span>
<span class="n">resample</span><span class="p">,</span> <span class="n">fillcolor</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">)</span>
<span class="k">return</span> <span class="n">im</span></div>
<span class="k">def</span> <span class="nf">__transformer</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">box</span><span class="p">,</span> <span class="n">image</span><span class="p">,</span> <span class="n">method</span><span class="p">,</span> <span class="n">data</span><span class="p">,</span>
<span class="n">resample</span><span class="o">=</span><span class="n">NEAREST</span><span class="p">,</span> <span class="n">fill</span><span class="o">=</span><span class="mi">1</span><span class="p">):</span>
<span class="n">w</span> <span class="o">=</span> <span class="n">box</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span> <span class="o">-</span> <span class="n">box</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
<span class="n">h</span> <span class="o">=</span> <span class="n">box</span><span class="p">[</span><span class="mi">3</span><span class="p">]</span> <span class="o">-</span> <span class="n">box</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span>
<span class="k">if</span> <span class="n">method</span> <span class="o">==</span> <span class="n">AFFINE</span><span class="p">:</span>
<span class="n">data</span> <span class="o">=</span> <span class="n">data</span><span class="p">[</span><span class="mi">0</span><span class="p">:</span><span class="mi">6</span><span class="p">]</span>
<span class="k">elif</span> <span class="n">method</span> <span class="o">==</span> <span class="n">EXTENT</span><span class="p">:</span>
<span class="c1"># convert extent to an affine transform</span>
<span class="n">x0</span><span class="p">,</span> <span class="n">y0</span><span class="p">,</span> <span class="n">x1</span><span class="p">,</span> <span class="n">y1</span> <span class="o">=</span> <span class="n">data</span>
<span class="n">xs</span> <span class="o">=</span> <span class="nb">float</span><span class="p">(</span><span class="n">x1</span> <span class="o">-</span> <span class="n">x0</span><span class="p">)</span> <span class="o">/</span> <span class="n">w</span>
<span class="n">ys</span> <span class="o">=</span> <span class="nb">float</span><span class="p">(</span><span class="n">y1</span> <span class="o">-</span> <span class="n">y0</span><span class="p">)</span> <span class="o">/</span> <span class="n">h</span>
<span class="n">method</span> <span class="o">=</span> <span class="n">AFFINE</span>
<span class="n">data</span> <span class="o">=</span> <span class="p">(</span><span class="n">xs</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="n">x0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="n">ys</span><span class="p">,</span> <span class="n">y0</span><span class="p">)</span>
<span class="k">elif</span> <span class="n">method</span> <span class="o">==</span> <span class="n">PERSPECTIVE</span><span class="p">:</span>
<span class="n">data</span> <span class="o">=</span> <span class="n">data</span><span class="p">[</span><span class="mi">0</span><span class="p">:</span><span class="mi">8</span><span class="p">]</span>
<span class="k">elif</span> <span class="n">method</span> <span class="o">==</span> <span class="n">QUAD</span><span class="p">:</span>
<span class="c1"># quadrilateral warp. data specifies the four corners</span>
<span class="c1"># given as NW, SW, SE, and NE.</span>
<span class="n">nw</span> <span class="o">=</span> <span class="n">data</span><span class="p">[</span><span class="mi">0</span><span class="p">:</span><span class="mi">2</span><span class="p">]</span>
<span class="n">sw</span> <span class="o">=</span> <span class="n">data</span><span class="p">[</span><span class="mi">2</span><span class="p">:</span><span class="mi">4</span><span class="p">]</span>
<span class="n">se</span> <span class="o">=</span> <span class="n">data</span><span class="p">[</span><span class="mi">4</span><span class="p">:</span><span class="mi">6</span><span class="p">]</span>
<span class="n">ne</span> <span class="o">=</span> <span class="n">data</span><span class="p">[</span><span class="mi">6</span><span class="p">:</span><span class="mi">8</span><span class="p">]</span>
<span class="n">x0</span><span class="p">,</span> <span class="n">y0</span> <span class="o">=</span> <span class="n">nw</span>
<span class="n">As</span> <span class="o">=</span> <span class="mf">1.0</span> <span class="o">/</span> <span class="n">w</span>
<span class="n">At</span> <span class="o">=</span> <span class="mf">1.0</span> <span class="o">/</span> <span class="n">h</span>
<span class="n">data</span> <span class="o">=</span> <span class="p">(</span><span class="n">x0</span><span class="p">,</span> <span class="p">(</span><span class="n">ne</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">-</span><span class="n">x0</span><span class="p">)</span><span class="o">*</span><span class="n">As</span><span class="p">,</span> <span class="p">(</span><span class="n">sw</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">-</span><span class="n">x0</span><span class="p">)</span><span class="o">*</span><span class="n">At</span><span class="p">,</span>
<span class="p">(</span><span class="n">se</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">-</span><span class="n">sw</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">-</span><span class="n">ne</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">+</span><span class="n">x0</span><span class="p">)</span><span class="o">*</span><span class="n">As</span><span class="o">*</span><span class="n">At</span><span class="p">,</span>
<span class="n">y0</span><span class="p">,</span> <span class="p">(</span><span class="n">ne</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="o">-</span><span class="n">y0</span><span class="p">)</span><span class="o">*</span><span class="n">As</span><span class="p">,</span> <span class="p">(</span><span class="n">sw</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="o">-</span><span class="n">y0</span><span class="p">)</span><span class="o">*</span><span class="n">At</span><span class="p">,</span>
<span class="p">(</span><span class="n">se</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="o">-</span><span class="n">sw</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="o">-</span><span class="n">ne</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="o">+</span><span class="n">y0</span><span class="p">)</span><span class="o">*</span><span class="n">As</span><span class="o">*</span><span class="n">At</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"unknown transformation method"</span><span class="p">)</span>
<span class="k">if</span> <span class="n">resample</span> <span class="ow">not</span> <span class="ow">in</span> <span class="p">(</span><span class="n">NEAREST</span><span class="p">,</span> <span class="n">BILINEAR</span><span class="p">,</span> <span class="n">BICUBIC</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"unknown resampling filter"</span><span class="p">)</span>
<span class="n">image</span><span class="o">.</span><span class="n">load</span><span class="p">()</span>
<span class="bp">self</span><span class="o">.</span><span class="n">load</span><span class="p">()</span>
<span class="k">if</span> <span class="n">image</span><span class="o">.</span><span class="n">mode</span> <span class="ow">in</span> <span class="p">(</span><span class="s2">"1"</span><span class="p">,</span> <span class="s2">"P"</span><span class="p">):</span>
<span class="n">resample</span> <span class="o">=</span> <span class="n">NEAREST</span>
<span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">transform2</span><span class="p">(</span><span class="n">box</span><span class="p">,</span> <span class="n">image</span><span class="o">.</span><span class="n">im</span><span class="p">,</span> <span class="n">method</span><span class="p">,</span> <span class="n">data</span><span class="p">,</span> <span class="n">resample</span><span class="p">,</span> <span class="n">fill</span><span class="p">)</span>
<div class="viewcode-block" id="Image.transpose"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.Image.transpose">[docs]</a> <span class="k">def</span> <span class="nf">transpose</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">method</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Transpose image (flip or rotate in 90 degree steps)</span>
<span class="sd"> :param method: One of :py:attr:`PIL.Image.FLIP_LEFT_RIGHT`,</span>
<span class="sd"> :py:attr:`PIL.Image.FLIP_TOP_BOTTOM`, :py:attr:`PIL.Image.ROTATE_90`,</span>
<span class="sd"> :py:attr:`PIL.Image.ROTATE_180`, :py:attr:`PIL.Image.ROTATE_270`,</span>
<span class="sd"> :py:attr:`PIL.Image.TRANSPOSE` or :py:attr:`PIL.Image.TRANSVERSE`.</span>
<span class="sd"> :returns: Returns a flipped or rotated copy of this image.</span>
<span class="sd"> """</span>
<span class="bp">self</span><span class="o">.</span><span class="n">load</span><span class="p">()</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_new</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">transpose</span><span class="p">(</span><span class="n">method</span><span class="p">))</span></div>
<span class="k">def</span> <span class="nf">effect_spread</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">distance</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Randomly spread pixels in an image.</span>
<span class="sd"> :param distance: Distance to spread pixels.</span>
<span class="sd"> """</span>
<span class="bp">self</span><span class="o">.</span><span class="n">load</span><span class="p">()</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_new</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">im</span><span class="o">.</span><span class="n">effect_spread</span><span class="p">(</span><span class="n">distance</span><span class="p">))</span>
<span class="k">def</span> <span class="nf">toqimage</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">"""Returns a QImage copy of this image"""</span>
<span class="kn">from</span> <span class="nn">.</span> <span class="k">import</span> <span class="n">ImageQt</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">ImageQt</span><span class="o">.</span><span class="n">qt_is_installed</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ImportError</span><span class="p">(</span><span class="s2">"Qt bindings are not installed"</span><span class="p">)</span>
<span class="k">return</span> <span class="n">ImageQt</span><span class="o">.</span><span class="n">toqimage</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">toqpixmap</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">"""Returns a QPixmap copy of this image"""</span>
<span class="kn">from</span> <span class="nn">.</span> <span class="k">import</span> <span class="n">ImageQt</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">ImageQt</span><span class="o">.</span><span class="n">qt_is_installed</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ImportError</span><span class="p">(</span><span class="s2">"Qt bindings are not installed"</span><span class="p">)</span>
<span class="k">return</span> <span class="n">ImageQt</span><span class="o">.</span><span class="n">toqpixmap</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span></div>
<span class="c1"># --------------------------------------------------------------------</span>
<span class="c1"># Abstract handlers.</span>
<span class="k">class</span> <span class="nc">ImagePointHandler</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
<span class="c1"># used as a mixin by point transforms (for use with im.point)</span>
<span class="k">pass</span>
<span class="k">class</span> <span class="nc">ImageTransformHandler</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
<span class="c1"># used as a mixin by geometry transforms (for use with im.transform)</span>
<span class="k">pass</span>
<span class="c1"># --------------------------------------------------------------------</span>
<span class="c1"># Factories</span>
<span class="c1">#</span>
<span class="c1"># Debugging</span>
<span class="k">def</span> <span class="nf">_wedge</span><span class="p">():</span>
<span class="sd">"""Create greyscale wedge (for debugging only)"""</span>
<span class="k">return</span> <span class="n">Image</span><span class="p">()</span><span class="o">.</span><span class="n">_new</span><span class="p">(</span><span class="n">core</span><span class="o">.</span><span class="n">wedge</span><span class="p">(</span><span class="s2">"L"</span><span class="p">))</span>
<span class="k">def</span> <span class="nf">_check_size</span><span class="p">(</span><span class="n">size</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Common check to enforce type and sanity check on size tuples</span>
<span class="sd"> :param size: Should be a 2 tuple of (width, height)</span>
<span class="sd"> :returns: True, or raises a ValueError</span>
<span class="sd"> """</span>
<span class="k">if</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">size</span><span class="p">,</span> <span class="p">(</span><span class="nb">list</span><span class="p">,</span> <span class="nb">tuple</span><span class="p">)):</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"Size must be a tuple"</span><span class="p">)</span>
<span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="n">size</span><span class="p">)</span> <span class="o">!=</span> <span class="mi">2</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"Size must be a tuple of length 2"</span><span class="p">)</span>
<span class="k">if</span> <span class="n">size</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o"><</span> <span class="mi">0</span> <span class="ow">or</span> <span class="n">size</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="o"><</span> <span class="mi">0</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"Width and height must be >= 0"</span><span class="p">)</span>
<span class="k">return</span> <span class="kc">True</span>
<div class="viewcode-block" id="new"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.new">[docs]</a><span class="k">def</span> <span class="nf">new</span><span class="p">(</span><span class="n">mode</span><span class="p">,</span> <span class="n">size</span><span class="p">,</span> <span class="n">color</span><span class="o">=</span><span class="mi">0</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Creates a new image with the given mode and size.</span>
<span class="sd"> :param mode: The mode to use for the new image. See:</span>
<span class="sd"> :ref:`concept-modes`.</span>
<span class="sd"> :param size: A 2-tuple, containing (width, height) in pixels.</span>
<span class="sd"> :param color: What color to use for the image. Default is black.</span>
<span class="sd"> If given, this should be a single integer or floating point value</span>
<span class="sd"> for single-band modes, and a tuple for multi-band modes (one value</span>
<span class="sd"> per band). When creating RGB images, you can also use color</span>
<span class="sd"> strings as supported by the ImageColor module. If the color is</span>
<span class="sd"> None, the image is not initialised.</span>
<span class="sd"> :returns: An :py:class:`~PIL.Image.Image` object.</span>
<span class="sd"> """</span>
<span class="n">_check_size</span><span class="p">(</span><span class="n">size</span><span class="p">)</span>
<span class="k">if</span> <span class="n">color</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="c1"># don't initialize</span>
<span class="k">return</span> <span class="n">Image</span><span class="p">()</span><span class="o">.</span><span class="n">_new</span><span class="p">(</span><span class="n">core</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="n">mode</span><span class="p">,</span> <span class="n">size</span><span class="p">))</span>
<span class="k">if</span> <span class="n">isStringType</span><span class="p">(</span><span class="n">color</span><span class="p">):</span>
<span class="c1"># css3-style specifier</span>
<span class="kn">from</span> <span class="nn">.</span> <span class="k">import</span> <span class="n">ImageColor</span>
<span class="n">color</span> <span class="o">=</span> <span class="n">ImageColor</span><span class="o">.</span><span class="n">getcolor</span><span class="p">(</span><span class="n">color</span><span class="p">,</span> <span class="n">mode</span><span class="p">)</span>
<span class="k">return</span> <span class="n">Image</span><span class="p">()</span><span class="o">.</span><span class="n">_new</span><span class="p">(</span><span class="n">core</span><span class="o">.</span><span class="n">fill</span><span class="p">(</span><span class="n">mode</span><span class="p">,</span> <span class="n">size</span><span class="p">,</span> <span class="n">color</span><span class="p">))</span></div>
<div class="viewcode-block" id="frombytes"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.frombytes">[docs]</a><span class="k">def</span> <span class="nf">frombytes</span><span class="p">(</span><span class="n">mode</span><span class="p">,</span> <span class="n">size</span><span class="p">,</span> <span class="n">data</span><span class="p">,</span> <span class="n">decoder_name</span><span class="o">=</span><span class="s2">"raw"</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Creates a copy of an image memory from pixel data in a buffer.</span>
<span class="sd"> In its simplest form, this function takes three arguments</span>
<span class="sd"> (mode, size, and unpacked pixel data).</span>
<span class="sd"> You can also use any pixel decoder supported by PIL. For more</span>
<span class="sd"> information on available decoders, see the section</span>
<span class="sd"> :ref:`Writing Your Own File Decoder <file-decoders>`.</span>
<span class="sd"> Note that this function decodes pixel data only, not entire images.</span>
<span class="sd"> If you have an entire image in a string, wrap it in a</span>
<span class="sd"> :py:class:`~io.BytesIO` object, and use :py:func:`~PIL.Image.open` to load</span>
<span class="sd"> it.</span>
<span class="sd"> :param mode: The image mode. See: :ref:`concept-modes`.</span>
<span class="sd"> :param size: The image size.</span>
<span class="sd"> :param data: A byte buffer containing raw data for the given mode.</span>
<span class="sd"> :param decoder_name: What decoder to use.</span>
<span class="sd"> :param args: Additional parameters for the given decoder.</span>
<span class="sd"> :returns: An :py:class:`~PIL.Image.Image` object.</span>
<span class="sd"> """</span>
<span class="n">_check_size</span><span class="p">(</span><span class="n">size</span><span class="p">)</span>
<span class="c1"># may pass tuple instead of argument list</span>
<span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="n">args</span><span class="p">)</span> <span class="o">==</span> <span class="mi">1</span> <span class="ow">and</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">args</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="nb">tuple</span><span class="p">):</span>
<span class="n">args</span> <span class="o">=</span> <span class="n">args</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
<span class="k">if</span> <span class="n">decoder_name</span> <span class="o">==</span> <span class="s2">"raw"</span> <span class="ow">and</span> <span class="n">args</span> <span class="o">==</span> <span class="p">():</span>
<span class="n">args</span> <span class="o">=</span> <span class="n">mode</span>
<span class="n">im</span> <span class="o">=</span> <span class="n">new</span><span class="p">(</span><span class="n">mode</span><span class="p">,</span> <span class="n">size</span><span class="p">)</span>
<span class="n">im</span><span class="o">.</span><span class="n">frombytes</span><span class="p">(</span><span class="n">data</span><span class="p">,</span> <span class="n">decoder_name</span><span class="p">,</span> <span class="n">args</span><span class="p">)</span>
<span class="k">return</span> <span class="n">im</span></div>
<div class="viewcode-block" id="fromstring"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.fromstring">[docs]</a><span class="k">def</span> <span class="nf">fromstring</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kw</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">NotImplementedError</span><span class="p">(</span><span class="s2">"fromstring() has been removed. "</span> <span class="o">+</span>
<span class="s2">"Please call frombytes() instead."</span><span class="p">)</span></div>
<div class="viewcode-block" id="frombuffer"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.frombuffer">[docs]</a><span class="k">def</span> <span class="nf">frombuffer</span><span class="p">(</span><span class="n">mode</span><span class="p">,</span> <span class="n">size</span><span class="p">,</span> <span class="n">data</span><span class="p">,</span> <span class="n">decoder_name</span><span class="o">=</span><span class="s2">"raw"</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Creates an image memory referencing pixel data in a byte buffer.</span>
<span class="sd"> This function is similar to :py:func:`~PIL.Image.frombytes`, but uses data</span>
<span class="sd"> in the byte buffer, where possible. This means that changes to the</span>
<span class="sd"> original buffer object are reflected in this image). Not all modes can</span>
<span class="sd"> share memory; supported modes include "L", "RGBX", "RGBA", and "CMYK".</span>
<span class="sd"> Note that this function decodes pixel data only, not entire images.</span>
<span class="sd"> If you have an entire image file in a string, wrap it in a</span>
<span class="sd"> **BytesIO** object, and use :py:func:`~PIL.Image.open` to load it.</span>
<span class="sd"> In the current version, the default parameters used for the "raw" decoder</span>
<span class="sd"> differs from that used for :py:func:`~PIL.Image.frombytes`. This is a</span>
<span class="sd"> bug, and will probably be fixed in a future release. The current release</span>
<span class="sd"> issues a warning if you do this; to disable the warning, you should provide</span>
<span class="sd"> the full set of parameters. See below for details.</span>
<span class="sd"> :param mode: The image mode. See: :ref:`concept-modes`.</span>
<span class="sd"> :param size: The image size.</span>
<span class="sd"> :param data: A bytes or other buffer object containing raw</span>
<span class="sd"> data for the given mode.</span>
<span class="sd"> :param decoder_name: What decoder to use.</span>
<span class="sd"> :param args: Additional parameters for the given decoder. For the</span>
<span class="sd"> default encoder ("raw"), it's recommended that you provide the</span>
<span class="sd"> full set of parameters::</span>
<span class="sd"> frombuffer(mode, size, data, "raw", mode, 0, 1)</span>
<span class="sd"> :returns: An :py:class:`~PIL.Image.Image` object.</span>
<span class="sd"> .. versionadded:: 1.1.4</span>
<span class="sd"> """</span>
<span class="n">_check_size</span><span class="p">(</span><span class="n">size</span><span class="p">)</span>
<span class="c1"># may pass tuple instead of argument list</span>
<span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="n">args</span><span class="p">)</span> <span class="o">==</span> <span class="mi">1</span> <span class="ow">and</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">args</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="nb">tuple</span><span class="p">):</span>
<span class="n">args</span> <span class="o">=</span> <span class="n">args</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
<span class="k">if</span> <span class="n">decoder_name</span> <span class="o">==</span> <span class="s2">"raw"</span><span class="p">:</span>
<span class="k">if</span> <span class="n">args</span> <span class="o">==</span> <span class="p">():</span>
<span class="n">warnings</span><span class="o">.</span><span class="n">warn</span><span class="p">(</span>
<span class="s2">"the frombuffer defaults may change in a future release; "</span>
<span class="s2">"for portability, change the call to read:</span><span class="se">\n</span><span class="s2">"</span>
<span class="s2">" frombuffer(mode, size, data, 'raw', mode, 0, 1)"</span><span class="p">,</span>
<span class="ne">RuntimeWarning</span><span class="p">,</span> <span class="n">stacklevel</span><span class="o">=</span><span class="mi">2</span>
<span class="p">)</span>
<span class="n">args</span> <span class="o">=</span> <span class="n">mode</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span> <span class="c1"># may change to (mode, 0, 1) post-1.1.6</span>
<span class="k">if</span> <span class="n">args</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="ow">in</span> <span class="n">_MAPMODES</span><span class="p">:</span>
<span class="n">im</span> <span class="o">=</span> <span class="n">new</span><span class="p">(</span><span class="n">mode</span><span class="p">,</span> <span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">))</span>
<span class="n">im</span> <span class="o">=</span> <span class="n">im</span><span class="o">.</span><span class="n">_new</span><span class="p">(</span>
<span class="n">core</span><span class="o">.</span><span class="n">map_buffer</span><span class="p">(</span><span class="n">data</span><span class="p">,</span> <span class="n">size</span><span class="p">,</span> <span class="n">decoder_name</span><span class="p">,</span> <span class="kc">None</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="n">args</span><span class="p">)</span>
<span class="p">)</span>
<span class="n">im</span><span class="o">.</span><span class="n">readonly</span> <span class="o">=</span> <span class="mi">1</span>
<span class="k">return</span> <span class="n">im</span>
<span class="k">return</span> <span class="n">frombytes</span><span class="p">(</span><span class="n">mode</span><span class="p">,</span> <span class="n">size</span><span class="p">,</span> <span class="n">data</span><span class="p">,</span> <span class="n">decoder_name</span><span class="p">,</span> <span class="n">args</span><span class="p">)</span></div>
<div class="viewcode-block" id="fromarray"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.fromarray">[docs]</a><span class="k">def</span> <span class="nf">fromarray</span><span class="p">(</span><span class="n">obj</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Creates an image memory from an object exporting the array interface</span>
<span class="sd"> (using the buffer protocol).</span>
<span class="sd"> If **obj** is not contiguous, then the tobytes method is called</span>
<span class="sd"> and :py:func:`~PIL.Image.frombuffer` is used.</span>
<span class="sd"> If you have an image in NumPy::</span>
<span class="sd"> from PIL import Image</span>
<span class="sd"> import numpy as np</span>
<span class="sd"> im = Image.open('hopper.jpg')</span>
<span class="sd"> a = np.asarray(im)</span>
<span class="sd"> Then this can be used to convert it to a Pillow image::</span>
<span class="sd"> im = Image.fromarray(a)</span>
<span class="sd"> :param obj: Object with array interface</span>
<span class="sd"> :param mode: Mode to use (will be determined from type if None)</span>
<span class="sd"> See: :ref:`concept-modes`.</span>
<span class="sd"> :returns: An image object.</span>
<span class="sd"> .. versionadded:: 1.1.6</span>
<span class="sd"> """</span>
<span class="n">arr</span> <span class="o">=</span> <span class="n">obj</span><span class="o">.</span><span class="n">__array_interface__</span>
<span class="n">shape</span> <span class="o">=</span> <span class="n">arr</span><span class="p">[</span><span class="s1">'shape'</span><span class="p">]</span>
<span class="n">ndim</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">shape</span><span class="p">)</span>
<span class="n">strides</span> <span class="o">=</span> <span class="n">arr</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s1">'strides'</span><span class="p">,</span> <span class="kc">None</span><span class="p">)</span>
<span class="k">if</span> <span class="n">mode</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="k">try</span><span class="p">:</span>
<span class="n">typekey</span> <span class="o">=</span> <span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span> <span class="o">+</span> <span class="n">shape</span><span class="p">[</span><span class="mi">2</span><span class="p">:],</span> <span class="n">arr</span><span class="p">[</span><span class="s1">'typestr'</span><span class="p">]</span>
<span class="n">mode</span><span class="p">,</span> <span class="n">rawmode</span> <span class="o">=</span> <span class="n">_fromarray_typemap</span><span class="p">[</span><span class="n">typekey</span><span class="p">]</span>
<span class="k">except</span> <span class="ne">KeyError</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s2">"Cannot handle this data type"</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">rawmode</span> <span class="o">=</span> <span class="n">mode</span>
<span class="k">if</span> <span class="n">mode</span> <span class="ow">in</span> <span class="p">[</span><span class="s2">"1"</span><span class="p">,</span> <span class="s2">"L"</span><span class="p">,</span> <span class="s2">"I"</span><span class="p">,</span> <span class="s2">"P"</span><span class="p">,</span> <span class="s2">"F"</span><span class="p">]:</span>
<span class="n">ndmax</span> <span class="o">=</span> <span class="mi">2</span>
<span class="k">elif</span> <span class="n">mode</span> <span class="o">==</span> <span class="s2">"RGB"</span><span class="p">:</span>
<span class="n">ndmax</span> <span class="o">=</span> <span class="mi">3</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">ndmax</span> <span class="o">=</span> <span class="mi">4</span>
<span class="k">if</span> <span class="n">ndim</span> <span class="o">></span> <span class="n">ndmax</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"Too many dimensions: </span><span class="si">%d</span><span class="s2"> > </span><span class="si">%d</span><span class="s2">."</span> <span class="o">%</span> <span class="p">(</span><span class="n">ndim</span><span class="p">,</span> <span class="n">ndmax</span><span class="p">))</span>
<span class="n">size</span> <span class="o">=</span> <span class="n">shape</span><span class="p">[</span><span class="mi">1</span><span class="p">],</span> <span class="n">shape</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
<span class="k">if</span> <span class="n">strides</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
<span class="k">if</span> <span class="nb">hasattr</span><span class="p">(</span><span class="n">obj</span><span class="p">,</span> <span class="s1">'tobytes'</span><span class="p">):</span>
<span class="n">obj</span> <span class="o">=</span> <span class="n">obj</span><span class="o">.</span><span class="n">tobytes</span><span class="p">()</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">obj</span> <span class="o">=</span> <span class="n">obj</span><span class="o">.</span><span class="n">tostring</span><span class="p">()</span>
<span class="k">return</span> <span class="n">frombuffer</span><span class="p">(</span><span class="n">mode</span><span class="p">,</span> <span class="n">size</span><span class="p">,</span> <span class="n">obj</span><span class="p">,</span> <span class="s2">"raw"</span><span class="p">,</span> <span class="n">rawmode</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span></div>
<span class="k">def</span> <span class="nf">fromqimage</span><span class="p">(</span><span class="n">im</span><span class="p">):</span>
<span class="sd">"""Creates an image instance from a QImage image"""</span>
<span class="kn">from</span> <span class="nn">.</span> <span class="k">import</span> <span class="n">ImageQt</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">ImageQt</span><span class="o">.</span><span class="n">qt_is_installed</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ImportError</span><span class="p">(</span><span class="s2">"Qt bindings are not installed"</span><span class="p">)</span>
<span class="k">return</span> <span class="n">ImageQt</span><span class="o">.</span><span class="n">fromqimage</span><span class="p">(</span><span class="n">im</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">fromqpixmap</span><span class="p">(</span><span class="n">im</span><span class="p">):</span>
<span class="sd">"""Creates an image instance from a QPixmap image"""</span>
<span class="kn">from</span> <span class="nn">.</span> <span class="k">import</span> <span class="n">ImageQt</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">ImageQt</span><span class="o">.</span><span class="n">qt_is_installed</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ImportError</span><span class="p">(</span><span class="s2">"Qt bindings are not installed"</span><span class="p">)</span>
<span class="k">return</span> <span class="n">ImageQt</span><span class="o">.</span><span class="n">fromqpixmap</span><span class="p">(</span><span class="n">im</span><span class="p">)</span>
<span class="n">_fromarray_typemap</span> <span class="o">=</span> <span class="p">{</span>
<span class="c1"># (shape, typestr) => mode, rawmode</span>
<span class="c1"># first two members of shape are set to one</span>
<span class="p">((</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">),</span> <span class="s2">"|b1"</span><span class="p">):</span> <span class="p">(</span><span class="s2">"1"</span><span class="p">,</span> <span class="s2">"1;8"</span><span class="p">),</span>
<span class="p">((</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">),</span> <span class="s2">"|u1"</span><span class="p">):</span> <span class="p">(</span><span class="s2">"L"</span><span class="p">,</span> <span class="s2">"L"</span><span class="p">),</span>
<span class="p">((</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">),</span> <span class="s2">"|i1"</span><span class="p">):</span> <span class="p">(</span><span class="s2">"I"</span><span class="p">,</span> <span class="s2">"I;8"</span><span class="p">),</span>
<span class="p">((</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">),</span> <span class="s2">"<u2"</span><span class="p">):</span> <span class="p">(</span><span class="s2">"I"</span><span class="p">,</span> <span class="s2">"I;16"</span><span class="p">),</span>
<span class="p">((</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">),</span> <span class="s2">">u2"</span><span class="p">):</span> <span class="p">(</span><span class="s2">"I"</span><span class="p">,</span> <span class="s2">"I;16B"</span><span class="p">),</span>
<span class="p">((</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">),</span> <span class="s2">"<i2"</span><span class="p">):</span> <span class="p">(</span><span class="s2">"I"</span><span class="p">,</span> <span class="s2">"I;16S"</span><span class="p">),</span>
<span class="p">((</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">),</span> <span class="s2">">i2"</span><span class="p">):</span> <span class="p">(</span><span class="s2">"I"</span><span class="p">,</span> <span class="s2">"I;16BS"</span><span class="p">),</span>
<span class="p">((</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">),</span> <span class="s2">"<u4"</span><span class="p">):</span> <span class="p">(</span><span class="s2">"I"</span><span class="p">,</span> <span class="s2">"I;32"</span><span class="p">),</span>
<span class="p">((</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">),</span> <span class="s2">">u4"</span><span class="p">):</span> <span class="p">(</span><span class="s2">"I"</span><span class="p">,</span> <span class="s2">"I;32B"</span><span class="p">),</span>
<span class="p">((</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">),</span> <span class="s2">"<i4"</span><span class="p">):</span> <span class="p">(</span><span class="s2">"I"</span><span class="p">,</span> <span class="s2">"I;32S"</span><span class="p">),</span>
<span class="p">((</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">),</span> <span class="s2">">i4"</span><span class="p">):</span> <span class="p">(</span><span class="s2">"I"</span><span class="p">,</span> <span class="s2">"I;32BS"</span><span class="p">),</span>
<span class="p">((</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">),</span> <span class="s2">"<f4"</span><span class="p">):</span> <span class="p">(</span><span class="s2">"F"</span><span class="p">,</span> <span class="s2">"F;32F"</span><span class="p">),</span>
<span class="p">((</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">),</span> <span class="s2">">f4"</span><span class="p">):</span> <span class="p">(</span><span class="s2">"F"</span><span class="p">,</span> <span class="s2">"F;32BF"</span><span class="p">),</span>
<span class="p">((</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">),</span> <span class="s2">"<f8"</span><span class="p">):</span> <span class="p">(</span><span class="s2">"F"</span><span class="p">,</span> <span class="s2">"F;64F"</span><span class="p">),</span>
<span class="p">((</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">),</span> <span class="s2">">f8"</span><span class="p">):</span> <span class="p">(</span><span class="s2">"F"</span><span class="p">,</span> <span class="s2">"F;64BF"</span><span class="p">),</span>
<span class="p">((</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">),</span> <span class="s2">"|u1"</span><span class="p">):</span> <span class="p">(</span><span class="s2">"LA"</span><span class="p">,</span> <span class="s2">"LA"</span><span class="p">),</span>
<span class="p">((</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">3</span><span class="p">),</span> <span class="s2">"|u1"</span><span class="p">):</span> <span class="p">(</span><span class="s2">"RGB"</span><span class="p">,</span> <span class="s2">"RGB"</span><span class="p">),</span>
<span class="p">((</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">4</span><span class="p">),</span> <span class="s2">"|u1"</span><span class="p">):</span> <span class="p">(</span><span class="s2">"RGBA"</span><span class="p">,</span> <span class="s2">"RGBA"</span><span class="p">),</span>
<span class="p">}</span>
<span class="c1"># shortcuts</span>
<span class="n">_fromarray_typemap</span><span class="p">[((</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">),</span> <span class="n">_ENDIAN</span> <span class="o">+</span> <span class="s2">"i4"</span><span class="p">)]</span> <span class="o">=</span> <span class="p">(</span><span class="s2">"I"</span><span class="p">,</span> <span class="s2">"I"</span><span class="p">)</span>
<span class="n">_fromarray_typemap</span><span class="p">[((</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">),</span> <span class="n">_ENDIAN</span> <span class="o">+</span> <span class="s2">"f4"</span><span class="p">)]</span> <span class="o">=</span> <span class="p">(</span><span class="s2">"F"</span><span class="p">,</span> <span class="s2">"F"</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">_decompression_bomb_check</span><span class="p">(</span><span class="n">size</span><span class="p">):</span>
<span class="k">if</span> <span class="n">MAX_IMAGE_PIXELS</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="k">return</span>
<span class="n">pixels</span> <span class="o">=</span> <span class="n">size</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">*</span> <span class="n">size</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span>
<span class="k">if</span> <span class="n">pixels</span> <span class="o">></span> <span class="mi">2</span> <span class="o">*</span> <span class="n">MAX_IMAGE_PIXELS</span><span class="p">:</span>
<span class="k">raise</span> <span class="n">DecompressionBombError</span><span class="p">(</span>
<span class="s2">"Image size (</span><span class="si">%d</span><span class="s2"> pixels) exceeds limit of </span><span class="si">%d</span><span class="s2"> pixels, "</span>
<span class="s2">"could be decompression bomb DOS attack."</span> <span class="o">%</span>
<span class="p">(</span><span class="n">pixels</span><span class="p">,</span> <span class="mi">2</span> <span class="o">*</span> <span class="n">MAX_IMAGE_PIXELS</span><span class="p">))</span>
<span class="k">if</span> <span class="n">pixels</span> <span class="o">></span> <span class="n">MAX_IMAGE_PIXELS</span><span class="p">:</span>
<span class="n">warnings</span><span class="o">.</span><span class="n">warn</span><span class="p">(</span>
<span class="s2">"Image size (</span><span class="si">%d</span><span class="s2"> pixels) exceeds limit of </span><span class="si">%d</span><span class="s2"> pixels, "</span>
<span class="s2">"could be decompression bomb DOS attack."</span> <span class="o">%</span>
<span class="p">(</span><span class="n">pixels</span><span class="p">,</span> <span class="n">MAX_IMAGE_PIXELS</span><span class="p">),</span>
<span class="n">DecompressionBombWarning</span><span class="p">)</span>
<div class="viewcode-block" id="open"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.open">[docs]</a><span class="k">def</span> <span class="nf">open</span><span class="p">(</span><span class="n">fp</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s2">"r"</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Opens and identifies the given image file.</span>
<span class="sd"> This is a lazy operation; this function identifies the file, but</span>
<span class="sd"> the file remains open and the actual image data is not read from</span>
<span class="sd"> the file until you try to process the data (or call the</span>
<span class="sd"> :py:meth:`~PIL.Image.Image.load` method). See</span>
<span class="sd"> :py:func:`~PIL.Image.new`. See :ref:`file-handling`.</span>
<span class="sd"> :param fp: A filename (string), pathlib.Path object or a file object.</span>
<span class="sd"> The file object must implement :py:meth:`~file.read`,</span>
<span class="sd"> :py:meth:`~file.seek`, and :py:meth:`~file.tell` methods,</span>
<span class="sd"> and be opened in binary mode.</span>
<span class="sd"> :param mode: The mode. If given, this argument must be "r".</span>
<span class="sd"> :returns: An :py:class:`~PIL.Image.Image` object.</span>
<span class="sd"> :exception IOError: If the file cannot be found, or the image cannot be</span>
<span class="sd"> opened and identified.</span>
<span class="sd"> """</span>
<span class="k">if</span> <span class="n">mode</span> <span class="o">!=</span> <span class="s2">"r"</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"bad mode </span><span class="si">%r</span><span class="s2">"</span> <span class="o">%</span> <span class="n">mode</span><span class="p">)</span>
<span class="n">exclusive_fp</span> <span class="o">=</span> <span class="kc">False</span>
<span class="n">filename</span> <span class="o">=</span> <span class="s2">""</span>
<span class="k">if</span> <span class="n">isPath</span><span class="p">(</span><span class="n">fp</span><span class="p">):</span>
<span class="n">filename</span> <span class="o">=</span> <span class="n">fp</span>
<span class="k">elif</span> <span class="n">HAS_PATHLIB</span> <span class="ow">and</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">fp</span><span class="p">,</span> <span class="n">Path</span><span class="p">):</span>
<span class="n">filename</span> <span class="o">=</span> <span class="nb">str</span><span class="p">(</span><span class="n">fp</span><span class="o">.</span><span class="n">resolve</span><span class="p">())</span>
<span class="k">if</span> <span class="n">filename</span><span class="p">:</span>
<span class="n">fp</span> <span class="o">=</span> <span class="n">builtins</span><span class="o">.</span><span class="n">open</span><span class="p">(</span><span class="n">filename</span><span class="p">,</span> <span class="s2">"rb"</span><span class="p">)</span>
<span class="n">exclusive_fp</span> <span class="o">=</span> <span class="kc">True</span>
<span class="k">try</span><span class="p">:</span>
<span class="n">fp</span><span class="o">.</span><span class="n">seek</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
<span class="k">except</span> <span class="p">(</span><span class="ne">AttributeError</span><span class="p">,</span> <span class="n">io</span><span class="o">.</span><span class="n">UnsupportedOperation</span><span class="p">):</span>
<span class="n">fp</span> <span class="o">=</span> <span class="n">io</span><span class="o">.</span><span class="n">BytesIO</span><span class="p">(</span><span class="n">fp</span><span class="o">.</span><span class="n">read</span><span class="p">())</span>
<span class="n">exclusive_fp</span> <span class="o">=</span> <span class="kc">True</span>
<span class="n">prefix</span> <span class="o">=</span> <span class="n">fp</span><span class="o">.</span><span class="n">read</span><span class="p">(</span><span class="mi">16</span><span class="p">)</span>
<span class="n">preinit</span><span class="p">()</span>
<span class="n">accept_warnings</span> <span class="o">=</span> <span class="p">[]</span>
<span class="k">def</span> <span class="nf">_open_core</span><span class="p">(</span><span class="n">fp</span><span class="p">,</span> <span class="n">filename</span><span class="p">,</span> <span class="n">prefix</span><span class="p">):</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="n">ID</span><span class="p">:</span>
<span class="k">try</span><span class="p">:</span>
<span class="n">factory</span><span class="p">,</span> <span class="n">accept</span> <span class="o">=</span> <span class="n">OPEN</span><span class="p">[</span><span class="n">i</span><span class="p">]</span>
<span class="n">result</span> <span class="o">=</span> <span class="ow">not</span> <span class="n">accept</span> <span class="ow">or</span> <span class="n">accept</span><span class="p">(</span><span class="n">prefix</span><span class="p">)</span>
<span class="k">if</span> <span class="nb">type</span><span class="p">(</span><span class="n">result</span><span class="p">)</span> <span class="ow">in</span> <span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">bytes</span><span class="p">]:</span>
<span class="n">accept_warnings</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">result</span><span class="p">)</span>
<span class="k">elif</span> <span class="n">result</span><span class="p">:</span>
<span class="n">fp</span><span class="o">.</span><span class="n">seek</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
<span class="n">im</span> <span class="o">=</span> <span class="n">factory</span><span class="p">(</span><span class="n">fp</span><span class="p">,</span> <span class="n">filename</span><span class="p">)</span>
<span class="n">_decompression_bomb_check</span><span class="p">(</span><span class="n">im</span><span class="o">.</span><span class="n">size</span><span class="p">)</span>
<span class="k">return</span> <span class="n">im</span>
<span class="k">except</span> <span class="p">(</span><span class="ne">SyntaxError</span><span class="p">,</span> <span class="ne">IndexError</span><span class="p">,</span> <span class="ne">TypeError</span><span class="p">,</span> <span class="n">struct</span><span class="o">.</span><span class="n">error</span><span class="p">):</span>
<span class="c1"># Leave disabled by default, spams the logs with image</span>
<span class="c1"># opening failures that are entirely expected.</span>
<span class="c1"># logger.debug("", exc_info=True)</span>
<span class="k">continue</span>
<span class="k">except</span> <span class="ne">Exception</span><span class="p">:</span>
<span class="k">if</span> <span class="n">exclusive_fp</span><span class="p">:</span>
<span class="n">fp</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
<span class="k">raise</span>
<span class="k">return</span> <span class="kc">None</span>
<span class="n">im</span> <span class="o">=</span> <span class="n">_open_core</span><span class="p">(</span><span class="n">fp</span><span class="p">,</span> <span class="n">filename</span><span class="p">,</span> <span class="n">prefix</span><span class="p">)</span>
<span class="k">if</span> <span class="n">im</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="k">if</span> <span class="n">init</span><span class="p">():</span>
<span class="n">im</span> <span class="o">=</span> <span class="n">_open_core</span><span class="p">(</span><span class="n">fp</span><span class="p">,</span> <span class="n">filename</span><span class="p">,</span> <span class="n">prefix</span><span class="p">)</span>
<span class="k">if</span> <span class="n">im</span><span class="p">:</span>
<span class="n">im</span><span class="o">.</span><span class="n">_exclusive_fp</span> <span class="o">=</span> <span class="n">exclusive_fp</span>
<span class="k">return</span> <span class="n">im</span>
<span class="k">if</span> <span class="n">exclusive_fp</span><span class="p">:</span>
<span class="n">fp</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
<span class="k">for</span> <span class="n">message</span> <span class="ow">in</span> <span class="n">accept_warnings</span><span class="p">:</span>
<span class="n">warnings</span><span class="o">.</span><span class="n">warn</span><span class="p">(</span><span class="n">message</span><span class="p">)</span>
<span class="k">raise</span> <span class="ne">IOError</span><span class="p">(</span><span class="s2">"cannot identify image file </span><span class="si">%r</span><span class="s2">"</span>
<span class="o">%</span> <span class="p">(</span><span class="n">filename</span> <span class="k">if</span> <span class="n">filename</span> <span class="k">else</span> <span class="n">fp</span><span class="p">))</span></div>
<span class="c1">#</span>
<span class="c1"># Image processing.</span>
<div class="viewcode-block" id="alpha_composite"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.alpha_composite">[docs]</a><span class="k">def</span> <span class="nf">alpha_composite</span><span class="p">(</span><span class="n">im1</span><span class="p">,</span> <span class="n">im2</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Alpha composite im2 over im1.</span>
<span class="sd"> :param im1: The first image. Must have mode RGBA.</span>
<span class="sd"> :param im2: The second image. Must have mode RGBA, and the same size as</span>
<span class="sd"> the first image.</span>
<span class="sd"> :returns: An :py:class:`~PIL.Image.Image` object.</span>
<span class="sd"> """</span>
<span class="n">im1</span><span class="o">.</span><span class="n">load</span><span class="p">()</span>
<span class="n">im2</span><span class="o">.</span><span class="n">load</span><span class="p">()</span>
<span class="k">return</span> <span class="n">im1</span><span class="o">.</span><span class="n">_new</span><span class="p">(</span><span class="n">core</span><span class="o">.</span><span class="n">alpha_composite</span><span class="p">(</span><span class="n">im1</span><span class="o">.</span><span class="n">im</span><span class="p">,</span> <span class="n">im2</span><span class="o">.</span><span class="n">im</span><span class="p">))</span></div>
<div class="viewcode-block" id="blend"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.blend">[docs]</a><span class="k">def</span> <span class="nf">blend</span><span class="p">(</span><span class="n">im1</span><span class="p">,</span> <span class="n">im2</span><span class="p">,</span> <span class="n">alpha</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Creates a new image by interpolating between two input images, using</span>
<span class="sd"> a constant alpha.::</span>
<span class="sd"> out = image1 * (1.0 - alpha) + image2 * alpha</span>
<span class="sd"> :param im1: The first image.</span>
<span class="sd"> :param im2: The second image. Must have the same mode and size as</span>
<span class="sd"> the first image.</span>
<span class="sd"> :param alpha: The interpolation alpha factor. If alpha is 0.0, a</span>
<span class="sd"> copy of the first image is returned. If alpha is 1.0, a copy of</span>
<span class="sd"> the second image is returned. There are no restrictions on the</span>
<span class="sd"> alpha value. If necessary, the result is clipped to fit into</span>
<span class="sd"> the allowed output range.</span>
<span class="sd"> :returns: An :py:class:`~PIL.Image.Image` object.</span>
<span class="sd"> """</span>
<span class="n">im1</span><span class="o">.</span><span class="n">load</span><span class="p">()</span>
<span class="n">im2</span><span class="o">.</span><span class="n">load</span><span class="p">()</span>
<span class="k">return</span> <span class="n">im1</span><span class="o">.</span><span class="n">_new</span><span class="p">(</span><span class="n">core</span><span class="o">.</span><span class="n">blend</span><span class="p">(</span><span class="n">im1</span><span class="o">.</span><span class="n">im</span><span class="p">,</span> <span class="n">im2</span><span class="o">.</span><span class="n">im</span><span class="p">,</span> <span class="n">alpha</span><span class="p">))</span></div>
<div class="viewcode-block" id="composite"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.composite">[docs]</a><span class="k">def</span> <span class="nf">composite</span><span class="p">(</span><span class="n">image1</span><span class="p">,</span> <span class="n">image2</span><span class="p">,</span> <span class="n">mask</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Create composite image by blending images using a transparency mask.</span>
<span class="sd"> :param image1: The first image.</span>
<span class="sd"> :param image2: The second image. Must have the same mode and</span>
<span class="sd"> size as the first image.</span>
<span class="sd"> :param mask: A mask image. This image can have mode</span>
<span class="sd"> "1", "L", or "RGBA", and must have the same size as the</span>
<span class="sd"> other two images.</span>
<span class="sd"> """</span>
<span class="n">image</span> <span class="o">=</span> <span class="n">image2</span><span class="o">.</span><span class="n">copy</span><span class="p">()</span>
<span class="n">image</span><span class="o">.</span><span class="n">paste</span><span class="p">(</span><span class="n">image1</span><span class="p">,</span> <span class="kc">None</span><span class="p">,</span> <span class="n">mask</span><span class="p">)</span>
<span class="k">return</span> <span class="n">image</span></div>
<div class="viewcode-block" id="eval"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.eval">[docs]</a><span class="k">def</span> <span class="nf">eval</span><span class="p">(</span><span class="n">image</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Applies the function (which should take one argument) to each pixel</span>
<span class="sd"> in the given image. If the image has more than one band, the same</span>
<span class="sd"> function is applied to each band. Note that the function is</span>
<span class="sd"> evaluated once for each possible pixel value, so you cannot use</span>
<span class="sd"> random components or other generators.</span>
<span class="sd"> :param image: The input image.</span>
<span class="sd"> :param function: A function object, taking one integer argument.</span>
<span class="sd"> :returns: An :py:class:`~PIL.Image.Image` object.</span>
<span class="sd"> """</span>
<span class="k">return</span> <span class="n">image</span><span class="o">.</span><span class="n">point</span><span class="p">(</span><span class="n">args</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span></div>
<div class="viewcode-block" id="merge"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.merge">[docs]</a><span class="k">def</span> <span class="nf">merge</span><span class="p">(</span><span class="n">mode</span><span class="p">,</span> <span class="n">bands</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Merge a set of single band images into a new multiband image.</span>
<span class="sd"> :param mode: The mode to use for the output image. See:</span>
<span class="sd"> :ref:`concept-modes`.</span>
<span class="sd"> :param bands: A sequence containing one single-band image for</span>
<span class="sd"> each band in the output image. All bands must have the</span>
<span class="sd"> same size.</span>
<span class="sd"> :returns: An :py:class:`~PIL.Image.Image` object.</span>
<span class="sd"> """</span>
<span class="k">if</span> <span class="n">getmodebands</span><span class="p">(</span><span class="n">mode</span><span class="p">)</span> <span class="o">!=</span> <span class="nb">len</span><span class="p">(</span><span class="n">bands</span><span class="p">)</span> <span class="ow">or</span> <span class="s2">"*"</span> <span class="ow">in</span> <span class="n">mode</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"wrong number of bands"</span><span class="p">)</span>
<span class="k">for</span> <span class="n">band</span> <span class="ow">in</span> <span class="n">bands</span><span class="p">[</span><span class="mi">1</span><span class="p">:]:</span>
<span class="k">if</span> <span class="n">band</span><span class="o">.</span><span class="n">mode</span> <span class="o">!=</span> <span class="n">getmodetype</span><span class="p">(</span><span class="n">mode</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"mode mismatch"</span><span class="p">)</span>
<span class="k">if</span> <span class="n">band</span><span class="o">.</span><span class="n">size</span> <span class="o">!=</span> <span class="n">bands</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">size</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"size mismatch"</span><span class="p">)</span>
<span class="k">for</span> <span class="n">band</span> <span class="ow">in</span> <span class="n">bands</span><span class="p">:</span>
<span class="n">band</span><span class="o">.</span><span class="n">load</span><span class="p">()</span>
<span class="k">return</span> <span class="n">bands</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">_new</span><span class="p">(</span><span class="n">core</span><span class="o">.</span><span class="n">merge</span><span class="p">(</span><span class="n">mode</span><span class="p">,</span> <span class="o">*</span><span class="p">[</span><span class="n">b</span><span class="o">.</span><span class="n">im</span> <span class="k">for</span> <span class="n">b</span> <span class="ow">in</span> <span class="n">bands</span><span class="p">]))</span></div>
<span class="c1"># --------------------------------------------------------------------</span>
<span class="c1"># Plugin registry</span>
<div class="viewcode-block" id="register_open"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.register_open">[docs]</a><span class="k">def</span> <span class="nf">register_open</span><span class="p">(</span><span class="nb">id</span><span class="p">,</span> <span class="n">factory</span><span class="p">,</span> <span class="n">accept</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Register an image file plugin. This function should not be used</span>
<span class="sd"> in application code.</span>
<span class="sd"> :param id: An image format identifier.</span>
<span class="sd"> :param factory: An image file factory method.</span>
<span class="sd"> :param accept: An optional function that can be used to quickly</span>
<span class="sd"> reject images having another format.</span>
<span class="sd"> """</span>
<span class="nb">id</span> <span class="o">=</span> <span class="nb">id</span><span class="o">.</span><span class="n">upper</span><span class="p">()</span>
<span class="n">ID</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="nb">id</span><span class="p">)</span>
<span class="n">OPEN</span><span class="p">[</span><span class="nb">id</span><span class="p">]</span> <span class="o">=</span> <span class="n">factory</span><span class="p">,</span> <span class="n">accept</span></div>
<div class="viewcode-block" id="register_mime"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.register_mime">[docs]</a><span class="k">def</span> <span class="nf">register_mime</span><span class="p">(</span><span class="nb">id</span><span class="p">,</span> <span class="n">mimetype</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Registers an image MIME type. This function should not be used</span>
<span class="sd"> in application code.</span>
<span class="sd"> :param id: An image format identifier.</span>
<span class="sd"> :param mimetype: The image MIME type for this format.</span>
<span class="sd"> """</span>
<span class="n">MIME</span><span class="p">[</span><span class="nb">id</span><span class="o">.</span><span class="n">upper</span><span class="p">()]</span> <span class="o">=</span> <span class="n">mimetype</span></div>
<div class="viewcode-block" id="register_save"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.register_save">[docs]</a><span class="k">def</span> <span class="nf">register_save</span><span class="p">(</span><span class="nb">id</span><span class="p">,</span> <span class="n">driver</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Registers an image save function. This function should not be</span>
<span class="sd"> used in application code.</span>
<span class="sd"> :param id: An image format identifier.</span>
<span class="sd"> :param driver: A function to save images in this format.</span>
<span class="sd"> """</span>
<span class="n">SAVE</span><span class="p">[</span><span class="nb">id</span><span class="o">.</span><span class="n">upper</span><span class="p">()]</span> <span class="o">=</span> <span class="n">driver</span></div>
<span class="k">def</span> <span class="nf">register_save_all</span><span class="p">(</span><span class="nb">id</span><span class="p">,</span> <span class="n">driver</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Registers an image function to save all the frames</span>
<span class="sd"> of a multiframe format. This function should not be</span>
<span class="sd"> used in application code.</span>
<span class="sd"> :param id: An image format identifier.</span>
<span class="sd"> :param driver: A function to save images in this format.</span>
<span class="sd"> """</span>
<span class="n">SAVE_ALL</span><span class="p">[</span><span class="nb">id</span><span class="o">.</span><span class="n">upper</span><span class="p">()]</span> <span class="o">=</span> <span class="n">driver</span>
<div class="viewcode-block" id="register_extension"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.register_extension">[docs]</a><span class="k">def</span> <span class="nf">register_extension</span><span class="p">(</span><span class="nb">id</span><span class="p">,</span> <span class="n">extension</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Registers an image extension. This function should not be</span>
<span class="sd"> used in application code.</span>
<span class="sd"> :param id: An image format identifier.</span>
<span class="sd"> :param extension: An extension used for this format.</span>
<span class="sd"> """</span>
<span class="n">EXTENSION</span><span class="p">[</span><span class="n">extension</span><span class="o">.</span><span class="n">lower</span><span class="p">()]</span> <span class="o">=</span> <span class="nb">id</span><span class="o">.</span><span class="n">upper</span><span class="p">()</span></div>
<span class="k">def</span> <span class="nf">register_extensions</span><span class="p">(</span><span class="nb">id</span><span class="p">,</span> <span class="n">extensions</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Registers image extensions. This function should not be</span>
<span class="sd"> used in application code.</span>
<span class="sd"> :param id: An image format identifier.</span>
<span class="sd"> :param extensions: A list of extensions used for this format.</span>
<span class="sd"> """</span>
<span class="k">for</span> <span class="n">extension</span> <span class="ow">in</span> <span class="n">extensions</span><span class="p">:</span>
<span class="n">register_extension</span><span class="p">(</span><span class="nb">id</span><span class="p">,</span> <span class="n">extension</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">registered_extensions</span><span class="p">():</span>
<span class="sd">"""</span>
<span class="sd"> Returns a dictionary containing all file extensions belonging</span>
<span class="sd"> to registered plugins</span>
<span class="sd"> """</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">EXTENSION</span><span class="p">:</span>
<span class="n">init</span><span class="p">()</span>
<span class="k">return</span> <span class="n">EXTENSION</span>
<div class="viewcode-block" id="register_decoder"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.register_decoder">[docs]</a><span class="k">def</span> <span class="nf">register_decoder</span><span class="p">(</span><span class="n">name</span><span class="p">,</span> <span class="n">decoder</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Registers an image decoder. This function should not be</span>
<span class="sd"> used in application code.</span>
<span class="sd"> :param name: The name of the decoder</span>
<span class="sd"> :param decoder: A callable(mode, args) that returns an</span>
<span class="sd"> ImageFile.PyDecoder object</span>
<span class="sd"> .. versionadded:: 4.1.0</span>
<span class="sd"> """</span>
<span class="n">DECODERS</span><span class="p">[</span><span class="n">name</span><span class="p">]</span> <span class="o">=</span> <span class="n">decoder</span></div>
<div class="viewcode-block" id="register_encoder"><a class="viewcode-back" href="../../reference/Image.html#PIL.Image.register_encoder">[docs]</a><span class="k">def</span> <span class="nf">register_encoder</span><span class="p">(</span><span class="n">name</span><span class="p">,</span> <span class="n">encoder</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Registers an image encoder. This function should not be</span>
<span class="sd"> used in application code.</span>
<span class="sd"> :param name: The name of the encoder</span>
<span class="sd"> :param encoder: A callable(mode, args) that returns an</span>
<span class="sd"> ImageFile.PyEncoder object</span>
<span class="sd"> .. versionadded:: 4.1.0</span>
<span class="sd"> """</span>
<span class="n">ENCODERS</span><span class="p">[</span><span class="n">name</span><span class="p">]</span> <span class="o">=</span> <span class="n">encoder</span></div>
<span class="c1"># --------------------------------------------------------------------</span>
<span class="c1"># Simple display support. User code may override this.</span>
<span class="k">def</span> <span class="nf">_show</span><span class="p">(</span><span class="n">image</span><span class="p">,</span> <span class="o">**</span><span class="n">options</span><span class="p">):</span>
<span class="c1"># override me, as necessary</span>
<span class="n">_showxv</span><span class="p">(</span><span class="n">image</span><span class="p">,</span> <span class="o">**</span><span class="n">options</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">_showxv</span><span class="p">(</span><span class="n">image</span><span class="p">,</span> <span class="n">title</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="o">**</span><span class="n">options</span><span class="p">):</span>
<span class="kn">from</span> <span class="nn">.</span> <span class="k">import</span> <span class="n">ImageShow</span>
<span class="n">ImageShow</span><span class="o">.</span><span class="n">show</span><span class="p">(</span><span class="n">image</span><span class="p">,</span> <span class="n">title</span><span class="p">,</span> <span class="o">**</span><span class="n">options</span><span class="p">)</span>
<span class="c1"># --------------------------------------------------------------------</span>
<span class="c1"># Effects</span>
<span class="k">def</span> <span class="nf">effect_mandelbrot</span><span class="p">(</span><span class="n">size</span><span class="p">,</span> <span class="n">extent</span><span class="p">,</span> <span class="n">quality</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Generate a Mandelbrot set covering the given extent.</span>
<span class="sd"> :param size: The requested size in pixels, as a 2-tuple:</span>
<span class="sd"> (width, height).</span>
<span class="sd"> :param extent: The extent to cover, as a 4-tuple:</span>
<span class="sd"> (x0, y0, x1, y2).</span>
<span class="sd"> :param quality: Quality.</span>
<span class="sd"> """</span>
<span class="k">return</span> <span class="n">Image</span><span class="p">()</span><span class="o">.</span><span class="n">_new</span><span class="p">(</span><span class="n">core</span><span class="o">.</span><span class="n">effect_mandelbrot</span><span class="p">(</span><span class="n">size</span><span class="p">,</span> <span class="n">extent</span><span class="p">,</span> <span class="n">quality</span><span class="p">))</span>
<span class="k">def</span> <span class="nf">effect_noise</span><span class="p">(</span><span class="n">size</span><span class="p">,</span> <span class="n">sigma</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Generate Gaussian noise centered around 128.</span>
<span class="sd"> :param size: The requested size in pixels, as a 2-tuple:</span>
<span class="sd"> (width, height).</span>
<span class="sd"> :param sigma: Standard deviation of noise.</span>
<span class="sd"> """</span>
<span class="k">return</span> <span class="n">Image</span><span class="p">()</span><span class="o">.</span><span class="n">_new</span><span class="p">(</span><span class="n">core</span><span class="o">.</span><span class="n">effect_noise</span><span class="p">(</span><span class="n">size</span><span class="p">,</span> <span class="n">sigma</span><span class="p">))</span>
<span class="k">def</span> <span class="nf">linear_gradient</span><span class="p">(</span><span class="n">mode</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Generate 256x256 linear gradient from black to white, top to bottom.</span>
<span class="sd"> :param mode: Input mode.</span>
<span class="sd"> """</span>
<span class="k">return</span> <span class="n">Image</span><span class="p">()</span><span class="o">.</span><span class="n">_new</span><span class="p">(</span><span class="n">core</span><span class="o">.</span><span class="n">linear_gradient</span><span class="p">(</span><span class="n">mode</span><span class="p">))</span>
<span class="k">def</span> <span class="nf">radial_gradient</span><span class="p">(</span><span class="n">mode</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Generate 256x256 radial gradient from black to white, centre to edge.</span>
<span class="sd"> :param mode: Input mode.</span>
<span class="sd"> """</span>
<span class="k">return</span> <span class="n">Image</span><span class="p">()</span><span class="o">.</span><span class="n">_new</span><span class="p">(</span><span class="n">core</span><span class="o">.</span><span class="n">radial_gradient</span><span class="p">(</span><span class="n">mode</span><span class="p">))</span>
<span class="c1"># --------------------------------------------------------------------</span>
<span class="c1"># Resources</span>
<span class="k">def</span> <span class="nf">_apply_env_variables</span><span class="p">(</span><span class="n">env</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
<span class="k">if</span> <span class="n">env</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="n">env</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">environ</span>
<span class="k">for</span> <span class="n">var_name</span><span class="p">,</span> <span class="n">setter</span> <span class="ow">in</span> <span class="p">[</span>
<span class="p">(</span><span class="s1">'PILLOW_ALIGNMENT'</span><span class="p">,</span> <span class="n">core</span><span class="o">.</span><span class="n">set_alignment</span><span class="p">),</span>
<span class="p">(</span><span class="s1">'PILLOW_BLOCK_SIZE'</span><span class="p">,</span> <span class="n">core</span><span class="o">.</span><span class="n">set_block_size</span><span class="p">),</span>
<span class="p">(</span><span class="s1">'PILLOW_BLOCKS_MAX'</span><span class="p">,</span> <span class="n">core</span><span class="o">.</span><span class="n">set_blocks_max</span><span class="p">),</span>
<span class="p">]:</span>
<span class="k">if</span> <span class="n">var_name</span> <span class="ow">not</span> <span class="ow">in</span> <span class="n">env</span><span class="p">:</span>
<span class="k">continue</span>
<span class="n">var</span> <span class="o">=</span> <span class="n">env</span><span class="p">[</span><span class="n">var_name</span><span class="p">]</span><span class="o">.</span><span class="n">lower</span><span class="p">()</span>
<span class="n">units</span> <span class="o">=</span> <span class="mi">1</span>
<span class="k">for</span> <span class="n">postfix</span><span class="p">,</span> <span class="n">mul</span> <span class="ow">in</span> <span class="p">[(</span><span class="s1">'k'</span><span class="p">,</span> <span class="mi">1024</span><span class="p">),</span> <span class="p">(</span><span class="s1">'m'</span><span class="p">,</span> <span class="mi">1024</span><span class="o">*</span><span class="mi">1024</span><span class="p">)]:</span>
<span class="k">if</span> <span class="n">var</span><span class="o">.</span><span class="n">endswith</span><span class="p">(</span><span class="n">postfix</span><span class="p">):</span>
<span class="n">units</span> <span class="o">=</span> <span class="n">mul</span>
<span class="n">var</span> <span class="o">=</span> <span class="n">var</span><span class="p">[:</span><span class="o">-</span><span class="nb">len</span><span class="p">(</span><span class="n">postfix</span><span class="p">)]</span>
<span class="k">try</span><span class="p">:</span>
<span class="n">var</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">var</span><span class="p">)</span> <span class="o">*</span> <span class="n">units</span>
<span class="k">except</span> <span class="ne">ValueError</span><span class="p">:</span>
<span class="n">warnings</span><span class="o">.</span><span class="n">warn</span><span class="p">(</span><span class="s2">"</span><span class="si">{0}</span><span class="s2"> is not int"</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">var_name</span><span class="p">))</span>
<span class="k">continue</span>
<span class="k">try</span><span class="p">:</span>
<span class="n">setter</span><span class="p">(</span><span class="n">var</span><span class="p">)</span>
<span class="k">except</span> <span class="ne">ValueError</span> <span class="k">as</span> <span class="n">e</span><span class="p">:</span>
<span class="n">warnings</span><span class="o">.</span><span class="n">warn</span><span class="p">(</span><span class="s2">"</span><span class="si">{0}</span><span class="s2">: </span><span class="si">{1}</span><span class="s2">"</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">var_name</span><span class="p">,</span> <span class="n">e</span><span class="p">))</span>
<span class="n">_apply_env_variables</span><span class="p">()</span>
<span class="n">atexit</span><span class="o">.</span><span class="n">register</span><span class="p">(</span><span class="n">core</span><span class="o">.</span><span class="n">clear_cache</span><span class="p">)</span>
</pre></div>
</div>
</div>
<footer>
<hr/>
<div role="contentinfo">
<p>
© Copyright 1995-2011 Fredrik Lundh, 2010-2018 Alex Clark and Contributors
</p>
</div>
Built with <a href="http://sphinx-doc.org/">Sphinx</a> using a <a href="https://github.com/rtfd/sphinx_rtd_theme">theme</a> provided by <a href="https://readthedocs.org">Read the Docs</a>.
</footer>
</div>
</div>
</section>
</div>
<script type="text/javascript">
jQuery(function () {
SphinxRtdTheme.Navigation.enable(true);
});
</script>
</body>
</html>
distrib
>
Mageia
>
7
>
armv7hl
>
media
>
core-updates
>
by-pkgid
>
0ef4ecbd01ec307dcbe15809d095d7c7
>
files
>
26
