1730 lines
176 KiB
Plaintext
1730 lines
176 KiB
Plaintext
|
Ë
|
|||
|
|
ß¼j X ã
|
|||
|
|
óê — U d dl mZ d dlZd dlZd dlZd dlZd dlZd dlZd dlZd dl Z d dl
|
|||
|
|
Z
|
|||
|
|
d dl Z d dl Z d dl
|
|||
|
|
Z
|
|||
|
|
d dlmZ d dlmZ d dlmZmZmZ ddlmZmZmZmZmZm Z ddl m Z m Z m Z dd l!m"Z" dd
|
|||
|
|
l#m$Z$m%Z% d e&d < d d
|
|||
|
|
l'm(Z( dZ*e*rd dlm+Z+m,Z,m-Z- d dl.m/Z/ d dlm0Z0m1Z1 ejd e3« Z4 G d„ de5« Z6 G d„ de7« Z8dZ9de&d< e:d« Z;de&d< ddlm<Z= e e>e=d d« k7 rd e>e=d d« › d e› �Z? e)e?« ‚ G d"„ d#e« ZD G d$„ d%e« ZE G d&„ d'e« ZFeFjŽ d(eFj� d)eFj’ d)eFj” d*eFj– d+iZL G d,„ d-e« ZM G d.„ d/e« ZN G d0„ d1e« ZOe j e3 ZQeDeEeFeMeNeOfD ]' ZeD ] ZR eSeQeRj¨ eRjª « Œ" Œ) eVe=d2« r<e=j® ZWe=j° ZXe=j² ZYe=j´ ZZe=j¶ Z[dZ*e*r(d dl\Z\d d3l]m^Z^ d d4l_m`Z` dd5lmaZambZbmcZcmdZdmeZe dd6lfmgZgmhZhmiZi g Zjd7e&d8< i Zkd9e&d:< i Zld;e&d<< i Zmd=e&d>< i Znd=e&d?< i Zod;e&d@< i ZpdAe&dB< i ZqdCe&dD< e jä dEk( rdFndGZs�d#dI„Ztg dJ¢ZudKZv�d$dL„Zw�d$dM„Zx�d%dN„Zy�d&dO„Zzd a{i dPdQ“dRdQ“dSdT“dUdV“dWdV“dXdV“dYdV“dZd[“d\d[“d]d[“d^d[“d_d[“d`da“dbda“dcdd“dedd“dfdg“i dhdi“djdk“dldm“dndo“dpdq“drdq“dsdt“dudt“dvdw“dxdw“dydz“d{d|“d}d|“d~d“d€d�“d‚dƒ“d„dƒ“¥i d…d†“d‡dˆ“d‰dŠ“d‹dŒ“d�dŽ“d�dŽ“d�dŽ“d‘dŽ“d’dŽ“d“dŽ“d”d•“d–d—“d˜d—“d™dš“d›dœ“d�dž“dŸd “¥i d¡d¢“d£d¤“d¥d¦“d§d¨“d©dª“d«d¬“dd¬“d®d¬“d¯d¬“d°d±“d²d³“d´d³“dµd³“d¶d³“d·d¸“d¹d¸“dºd»“¥d¼d¼d½d¾d¿œ¥Z|d;e&dÀ< �d'dÁ„Z}�d(d„Z~�d)dÄZ �d* �d+dÄ„Z€ �d* �d,dÅ„Z� G dÆ„ dÇ« Z‚ �d-dÈ„Zƒ G dÉ„ dÊe« Z„ G dË„ dH« Z… G dÌ„ dÍe�j « Z‡ G d΄ dÏe�j « Zˆ�d.dЄZ‰ �d/ �d0dÑ„ZŠ �d1 �d2dÒ„Z‹ �d1 �d3dÓ„ZŒ G dÔ„ dÕe« Z� G dÖ„ d×e« ZŽ�d4�d5dØ„Z� �d6dÙ„Z��d7dÚ„Z‘�d8dÛ„Z’i dÜdÝdÞg f“dßdàdàdágf“dâdãdäg f“dådãdæg f“dçdãdèg f“dédãdêg f“dëdãdìg f“dídãdîg f“dïdãdðg f“dñdãdòg f“dódãdôg f“dõdöd÷g f“dødödùg f“dúdödûg f“düdödýg f“dþdÿdÿ�d �dgf“�d�d�dg �d¢f“�d�d�dg �d¢f�des› �d �fdãdãg f�des› �d
|
|||
|
|
�fdödög fi¥Z“�d9�d „Z” �d: �d;�d „Z•�d<�d
|
|||
|
|
„Z–�d=�d„Z—�d>�d„Z˜�d?�d„Z™�d@�d„Zš �d4 �dA�d„Z›�dB�d„Zœ �dC�d„Z� �dC�d„Zž�dD�d„ZŸ�dE�d„Z �dF�d„Z¡�dG�d„Z¢�dH�d„Z£�dI�d„Z¤ �dJ�d „Z¥�dK�d „Z¦�dL�d „Z§�dL�d „Z¨�d4�dM�d „Z© e©« e�jT e=�jV « e*ree:e0f Z¬neZ¬ G �d!„ �d"e¬« Zy# e)$ r dZ(Y �Œ†w xY w# e)$ raZ@ eAe@« j… d « r e
|
|||
|
|
j† d e5« ‚ eAe@« j… d!« r e
|
|||
|
|
j† eAe@« e5« ‚ dZ@[@ww xY w(N é )Ú annotationsN)ÚMutableMapping)ÚIntEnum)ÚIOÚProtocolÚcasté )ÚExifTagsÚ ImageModeÚTiffTagsÚUnidentifiedImageErrorÚ __version__Ú_plugins)Úi32leÚo32beÚo32le)Ú deprecate)Ú
|
|||
|
|
DeferredErrorÚis_pathzModuleType | NoneÚ ElementTree)r F)ÚCallableÚIteratorÚSequence)Ú
|
|||
|
|
ModuleType)ÚAnyÚLiteralc ó — e Zd Zy)ÚDecompressionBombWarningN©Ú__name__Ú
|
|||
|
|
__module__Ú __qualname__© ó úL/home/antigravity/intellecton/venv/lib/python3.12/site-packages/PIL/Image.pyr r K ó „ Ør$ r c ó — e Zd Zy)ÚDecompressionBombErrorNr r# r$ r% r( r( O r& r$ r( ÚboolÚWARN_POSSIBLE_FORMATSiUUUú
|
|||
|
|
int | NoneÚMAX_IMAGE_PIXELS)Ú_imagingÚPILLOW_VERSIONzUThe _imaging extension was built for another version of Pillow or PIL:
|
|||
|
|
Core version: z
|
|||
|
|
Pillow version: zModule use of pythonz?The _imaging extension was built for another version of Python.zThe _imaging extensionc ó( — e Zd ZdZdZdZdZdZdZdZ y) Ú Transposer r é é é é é N)
|
|||
|
|
r r! r" ÚFLIP_LEFT_RIGHTÚFLIP_TOP_BOTTOMÚ ROTATE_90Ú
|
|||
|
|
ROTATE_180Ú
|
|||
|
|
ROTATE_270Ú TRANSPOSEÚ
|
|||
|
|
TRANSVERSEr# r$ r% r0 r0 s% „ Ø€OØ€OØ€IØ€JØ€JØ€IØ�Jr$ r0 c ó — e Zd ZdZdZdZdZdZy)Ú Transformr r r1 r2 r3 N)r r! r" ÚAFFINEÚEXTENTÚ PERSPECTIVEÚQUADÚMESHr# r$ r% r> r> Š s „ Ø
|
|||
|
|
€FØ
|
|||
|
|
€FØ€KØ €DØ �Dr$ r> c ó$ — e Zd ZdZdZdZdZdZdZy)Ú
|
|||
|
|
Resamplingr r3 r1 r4 r2 r N) r r! r" ÚNEARESTÚBOXÚBILINEARÚHAMMINGÚBICUBICÚLANCZOSr# r$ r% rE rE “ s „ Ø€GØ
|
|||
|
|
€CØ€HØ€GØ€GØ�Gr$ rE ç à?ç ð?ç @g @c ó — e Zd ZdZdZdZdZy)ÚDitherr r r1 r2 N)r r! r" ÚNONEÚORDEREDÚ RASTERIZEÚFLOYDSTEINBERGr# r$ r% rP rP ¦ s „ Ø €DØ€GØ€IØ�Nr$ rP c ó — e Zd ZdZdZy)ÚPaletter r N)r r! r" ÚWEBÚADAPTIVEr# r$ r% rV rV ® s „ Ø
|
|||
|
|
€CØ�Hr$ rV c ó — e Zd ZdZdZdZdZy)ÚQuantizer r r1 r2 N)r r! r" Ú MEDIANCUTÚ MAXCOVERAGEÚ
|
|||
|
|
FASTOCTREEÚ
|
|||
|
|
LIBIMAGEQUANTr# r$ r% rZ rZ ³ s „ Ø€IØ€KØ€JØ�Mr$ rZ ÚDEFAULT_STRATEGY)ÚElement)Ú
|
|||
|
|
PrettyPrinter)Ú ImageFileÚ ImageFilterÚ ImagePaletteÚImageQtÚTiffImagePlugin)Ú CapsuleTypeÚ
|
|||
|
|
NumpyArrayÚStrOrBytesPathú list[str]ÚIDzodict[str, tuple[Callable[[IO[bytes], str | bytes], ImageFile.ImageFile], Callable[[bytes], bool | str] | None]]ÚOPENúdict[str, str]ÚMIMEz:dict[str, Callable[[Image, IO[bytes], str | bytes], None]]ÚSAVEÚSAVE_ALLÚ EXTENSIONz$dict[str, type[ImageFile.PyDecoder]]ÚDECODERSz$dict[str, type[ImageFile.PyEncoder]]ÚENCODERSÚlittleú<ú>ÚImagec óÌ — t j | j « }| j | j f}t |j « }|dk7 r||fz
|
|||
|
|
}||j fS ©Nr )r ÚgetmodeÚmodeÚheightÚwidthÚlenÚbandsÚtypestr)ÚimÚmÚshapeÚextras r% Ú_conv_type_shaper… é sW € Ü×ј"Ÿ'™'Ó"€AØ Ÿi™i¨¯©Ð 2€EÜ �—‘‹L€EØ �‚zØ
|
|||
|
|
�%�ÑˆØ �!—)‘)Ð Ðr$ )Ú1ÚCMYKÚFÚHSVÚIúI;16úI;16BúI;16LzI;16NÚLÚLAÚLaÚLABÚPÚPAÚRGBÚRGBAÚRGBaÚRGBXÚYCbCr)rŽ r’ r— r• r‡ r‹ r� rŒ c ó@ — t j | « j S )a%
|
|||
|
|
Gets the "base" mode for given mode. This function returns "L" for
|
|||
|
|
images that contain grayscale data, and "RGB" for images that
|
|||
|
|
contain color data.
|
|||
|
|
|
|||
|
|
:param mode: Input mode.
|
|||
|
|
:returns: "L" or "RGB".
|
|||
|
|
:exception KeyError: If the input mode was not a standard mode.
|
|||
|
|
)r rz Úbasemode©r{ s r% Ú getmodebaserœ s € ô × Ñ ˜TÓ "× +Ñ +Ð+r$ c ó@ — t j | « j S )a
|
|||
|
|
Gets the storage type mode. Given a mode, this function returns a
|
|||
|
|
single-layer mode suitable for storing individual bands.
|
|||
|
|
|
|||
|
|
:param mode: Input mode.
|
|||
|
|
:returns: "L", "I", or "F".
|
|||
|
|
:exception KeyError: If the input mode was not a standard mode.
|
|||
|
|
)r rz Úbasetyper› s r% Ú getmodetyperŸ s € ô × Ñ ˜TÓ "× +Ñ +Ð+r$ c ó@ — t j | « j S )a×
|
|||
|
|
Gets a list of individual band names. Given a mode, this function returns
|
|||
|
|
a tuple containing the names of individual bands (use
|
|||
|
|
:py:method:`~PIL.Image.getmodetype` to get the mode used to store each
|
|||
|
|
individual band.
|
|||
|
|
|
|||
|
|
:param mode: Input mode.
|
|||
|
|
:returns: A tuple containing band names. The length of the tuple
|
|||
|
|
gives the number of bands in an image of the given mode.
|
|||
|
|
:exception KeyError: If the input mode was not a standard mode.
|
|||
|
|
)r rz r r› s r% Úgetmodebandnamesr¡ ' s € ô × Ñ ˜TÓ "× (Ñ (Ð(r$ c óR — t t j | « j « S )zÎ
|
|||
|
|
Gets the number of individual bands for this mode.
|
|||
|
|
|
|||
|
|
:param mode: Input mode.
|
|||
|
|
:returns: The number of bands in this mode.
|
|||
|
|
:exception KeyError: If the input mode was not a standard mode.
|
|||
|
|
)r~ r rz r r› s r% Ú getmodebandsr£ 6 s € ô Œy× Ñ Ó&×,Ñ,Ó -Ð-r$ z.bmpÚBmpImagePluginz.dibz.gifÚGifImagePluginz.jfifÚJpegImagePluginz.jpez.jpgz.jpegz.pbmÚPpmImagePluginz.pgmz.pnmz.ppmz.pfmz.pngÚPngImagePluginz.apngz.avifÚAvifImagePluginz.avifsz.blpÚBlpImagePluginz.bufrÚBufrStubImagePluginz.curÚCurImagePluginz.dcxÚDcxImagePluginz.ddsÚDdsImagePluginz.psÚEpsImagePluginz.epsz.fitÚFitsImagePluginz.fitsz.fliÚFliImagePluginz.flcz.fpxÚFpxImagePluginz.ftcÚFtexImagePluginz.ftuz.gbrÚGbrImagePluginz.gribÚGribStubImagePluginz.h5ÚHdf5StubImagePluginz.hdfz.icnsÚIcnsImagePluginz.icoÚIcoImagePluginz.imÚ
|
|||
|
|
ImImagePluginz.iimÚIptcImagePluginz.jp2ÚJpeg2KImagePluginz.j2kz.jpcz.jpfz.jpxz.j2cz.micÚMicImagePluginz.mpgÚMpegImagePluginz.mpegz.mpoÚMpoImagePluginz.mspÚMspImagePluginz.palmÚPalmImagePluginz.pcdÚPcdImagePluginz.pcxÚPcxImagePluginz.pdfÚPdfImagePluginz.pxrÚPixarImagePluginz.psdÚPsdImagePluginz.qoiÚQoiImagePluginz.bwÚSgiImagePluginz.rgbz.rgbaz.sgiz.rasÚSunImagePluginz.tgaÚTgaImagePluginz.icbz.vdaz.vstz.tifrf z.tiffz.webpÚWebPImagePluginÚWmfImagePluginÚXbmImagePluginÚXpmImagePlugin)z.wmfz.emfz.xbmz.xpmÚ_EXTENSION_PLUGINc ó– — | syt | t « r| j « } | j « } | t v ryt
|
|||
|
|
j
|
|||
|
|
| « }|€y t j d|« t t j › d|› �t « t « g « y# t $ r!}t j d||« Y d}~yd}~ww xY w)z<Import only the plugin needed for a specific file extension.FTNú Importing %sú.ú Image: failed to import %s: %s)Ú
|
|||
|
|
isinstanceÚbytesÚdecodeÚlowerrq rÎ ÚgetÚloggerÚdebugÚ
|
|||
|
|
__import__Ú__spec__ÚparentÚglobalsÚlocalsÚ ImportError)ÚextÚpluginÚes r% Ú _import_plugin_for_extensionrã • s§ € á Øä�#”uÔ Ø�j‰j‹lˆØ
|
|||
|
|
|
|||
|
|
�)‰)‹+€CØ
|
|||
|
|
ŒiÑØä
|
|||
|
|
×
|
|||
|
|
"Ñ
|
|||
|
|
" 3Ó
|
|||
|
|
'€FØ
|
|||
|
|
€~ØðÜ� ‰ �^ VÔ,Ü”h—o‘oÐ& a¨ xÐ0´'³)¼V»XÀrÔJØøÜ ò Ü� ‰ Ð5°v¸qÔAÜûðús ÁAB  CÂ'CÃCc ó. — t dk\ ry ddlm} | sJ ‚ ddlm} |sJ ‚ ddlm} |sJ ‚ ddlm} |sJ ‚ ddlm} |sJ ‚ da y# t $ r Y Œ>w xY w# t $ r Y ŒAw xY w# t $ r Y ŒDw xY w# t $ r Y ŒGw xY w# t $ r Y da yw xY w)z|
|
|||
|
|
Explicitly loads BMP, GIF, JPEG, PPM and PNG file format drivers.
|
|||
|
|
|
|||
|
|
It is called when opening or saving images.
|
|||
|
|
r N)r¤ )r¥ )r¦ )r§ )r¨ )Ú _initializedÚ r¤ rß r¥ r¦ r§ r¨ )r¤ r¥ r¦ r§ r¨ s r% Úpreinitrç sË € ô �qÒØð
|
|||
|
|
Ý$á Ð ‰~ð
|
|||
|
|
Ý$á Ð ‰~ð
|
|||
|
|
Ý%á Ð ‰ð
|
|||
|
|
Ý$á Ð ‰~ð
|
|||
|
|
Ý$á Ð ‰~ð �Løô7 ò
|
|||
|
|
Ù ð
|
|||
|
|
ûô ò
|
|||
|
|
Ù ð
|
|||
|
|
ûô ò
|
|||
|
|
Ù ð
|
|||
|
|
ûô ò
|
|||
|
|
Ù ð
|
|||
|
|
ûô ò
|
|||
|
|
Ø à�Lð
|
|||
|
|
úsU Œ
|
|||
|
|
A
|
|||
|
|
˜
|
|||
|
|
A ¤
|
|||
|
|
A( °
|
|||
|
|
A7 ¼
|
|||
|
|
B Á
|
|||
|
|
AÁAÁ A%Á$A%Á( A4Á3A4Á7 BÂBÂ BÂBc ó6 — t dk\ ryt D ]J } t j d| « t t
|
|||
|
|
j › d| › �t « t « g « ŒL t st rda yy# t $ r!}t j d| |« Y d}~Œ‚d}~ww xY w)zþ
|
|||
|
|
Explicitly initializes the Python Imaging Library. This function
|
|||
|
|
loads all available file format drivers.
|
|||
|
|
|
|||
|
|
It is called when opening or saving images if :py:meth:`~preinit()` is
|
|||
|
|
insufficient, and by :py:meth:`~PIL.features.pilinfo`.
|
|||
|
|
r1 FrÐ rÑ rÒ NT) rå r rØ rÙ rÚ rÛ rÜ rÝ rÞ rß rl ro )rá râ s r% Úinitré Ú s� € ô �qÒØäò Fˆð FÜ �L‰L˜ ¨Ô 0Ü œ(Ÿ/™/Ð*¨!¨F¨8Ð4´g³iÄÃÈ2Õ NðFõ �t؈ ØØ øô
|
|||
|
|
ò FÜ �L‰LÐ9¸6À1× EÑ Eûð Fús •AA.Á. BÁ7BÂBc ó — |€d}nt |t « s|f} t | } || g||z ¢Ž S # t $ r Y nw xY w t t
|
|||
|
|
|› d�« }n## t $ r}d|› d�}t |« |‚d }~ww xY w || g||z ¢Ž S )Nr# Ú_decoderzdecoder ú not available)rÓ Útuplerr ÚKeyErrorÚgetattrÚcoreÚAttributeErrorÚOSError)r{ Ú decoder_nameÚargsr„ Údecoderrâ Úmsgs r% Ú _getdecoderr÷ ø ó° € ð €|؉Ü
|
|||
|
|
˜œeÔ
|
|||
|
|
$؈wˆð,ܘ<Ñ(ˆñ �tÐ+˜d U™lÒ+Ð+øô ò
|
|||
|
|
Ù ð
|
|||
|
|
úð
|
|||
|
|
"äœ$ < .°Ð 9Ó:‰øÜ ò "ؘ ˜ nÐ5ˆÜ�c‹l Ð!ûð"úñ �4Ð '˜$ ™,Ò 'Ð'ó# š / ¯ ;º;¿A Á A3Á A.Á.A3c ó — |€d}nt |t « s|f} t | } || g||z ¢Ž S # t $ r Y nw xY w t t
|
|||
|
|
|› d�« }n## t $ r}d|› d�}t |« |‚d }~ww xY w || g||z ¢Ž S )Nr# Ú_encoderzencoder rì )rÓ rí rs rî rï rð rñ rò )r{ Ú encoder_namerô r„ Úencoderrâ rö s r% Ú _getencoderrþ rø rù c óP — e Zd ZdZd
|
|||
|
|
d„Zd d„Zd d„ZeZd d„Zd d„Z d d„Z
|
|||
|
|
e
|
|||
|
|
Z d d„Z y )
|
|||
|
|
ÚImagePointTransformzÙ
|
|||
|
|
Used with :py:meth:`~PIL.Image.Image.point` for single band images with more than
|
|||
|
|
8 bits, this represents an affine transformation, where the value is multiplied by
|
|||
|
|
``scale`` and ``offset`` is added.
|
|||
|
|
c ó — || _ || _ y ©N)ÚscaleÚoffset)Úselfr r s r% Ú__init__z ImagePointTransform.__init__5 s € ؈Œ
|
|||
|
|
Ø ˆ� r$ c óF — t | j | j « S r )r r r ©r s r% Ú__neg__zImagePointTransform.__neg__9 s € Ü" D§J¡J ;°·±° Ó=Ð=r$ c óÜ — t |t « r:t | j |j z | j |j z « S t | j | j |z « S r )rÓ r r r ©r Úothers r% Ú__add__zImagePointTransform.__add__< sU € Ü �eÔ 0Ô 1Ü&Ø—
|
|||
|
|
‘
|
|||
|
|
˜UŸ[™[Ñ(¨$¯+©+¸¿ ¹ Ñ*Dóð
|
|||
|
|
ô # 4§:¡:¨t¯{©{¸UÑ/BÓCÐCr$ c ó — | | z S r r# r s r% Ú__sub__zImagePointTransform.__sub__E s € Ø�u�f‰}Ð r$ c ó — || z S r r# r s r% Ú__rsub__z ImagePointTransform.__rsub__H s € ؘ�u‰}Ð r$ c óz — t |t « rt S t | j |z | j |z « S r ©rÓ r ÚNotImplementedr r r s r% Ú__mul__zImagePointTransform.__mul__K ó2 € Ü �eÔ 0Ô 1Ü!Ð !Ü" 4§:¡:°Ñ#5°t·{±{ÀUÑ7JÓKÐKr$ c óz — t |t « rt S t | j |z | j |z « S r r r s r% Ú __truediv__z ImagePointTransform.__truediv__R r r$ N)r Úfloatr r ÚreturnÚNone)r r )r zImagePointTransform | floatr r )
|
|||
|
|
r r! r" Ú__doc__r r r
|
|||
|
|
Ú__radd__r r r Ú__rmul__r r# r$ r% r r . s; „ ñó ó>óDð €Hó ó óLð
|
|||
|
|
€HôLr$ r c ó~ — | t dd« « }t |t « r|j |j fS d|fS ©Nr r )r rÓ r r )ÚexprÚas r% Ú_getscaleoffsetr# X s< € ñ
|
|||
|
|
Ô
|
|||
|
|
AÓ
|
|||
|
|
&Ó'€AÜ",¨QÔ0CÔ"DˆA�G‰G�Q—X‘XÐ ÐPÈ1ÈaÈ&ÐPr$ c ó — e Zd Z dd„Zy)ÚSupportsGetDatac ó — y r r# r s r% ÚgetdatazSupportsGetData.getdatad s € à*-r$ N)r z tuple[Transform, Sequence[int]])r r! r" r' r# r$ r% r% r% c s „ ð.à (ô.r$ r% c óÞ — e Zd ZU dZdZded< dZded< dZd`d„Ze dad„« Z
|
|||
|
|
e
|
|||
|
|
j dbd „« Z
|
|||
|
|
e dcd
|
|||
|
|
„« Z e dcd „« Z
|
|||
|
|
e ddd „« Ze ded
|
|||
|
|
„« Ze dcd„« Zej dfd„« Zdgd„Zdhd„Zdid„Zd`d„Zd`d„Zd`d„Z dj dkd„Zdld„Zded„Zdmd„Zdnd„Zdod„Z dod „Z e dpd „« Z dqd „Z dr dsd „Z dtd „Z!dud!„Z"dvdwd"„Z#dxdyd#„Z$ dv dzd$„Z%d{d%„Z&d`d&„Z'ddde(jR d'f d|d(„Z*d'dd)de+jX f d}d*„Z-dhd+„Z.e.Z/drd~d,„Z0 dd-„Z1 d€d.„Z2d�d/„Z3d‚d0„Z4dd1œdƒd2„Z5 d„ d…d3„Z6drd†d4„Z7 dr d‡d5„Z8dˆd6„Z9d‰d7„Z:dŠd8„Z;d`d9„Z<d‹d:„Z=dŒd;„Z>d�dŽd<„Z?e d�d=„« Z@d`d>„ZA d�d?„ZBd‘d@„ZC dj d’dA„ZD dj d“dB„ZE dj d”dC„ZF d• d–dD„ZG dr d—dE„ZHd˜dF„ZI d™ dšdG„ZJ d� d›dH„ZK dœdI„ZL dr d�dJ„ZM dždK„ZN dŸ d dL„ZO dr d¡dM„ZPeQj¤ dNdddf d¢dO„ZS dr d£dP„ZTd¤dQ„ZUd¥dR„ZVdrd¦dS„ZWd§dT„ZXd¨dU„ZYdcdV„ZZeQj¶ dWf d©dX„Z\deQj¤ dYdf dªdZ„Z]eQj¤ df d«d[„Z^d¬d\„Z_dd]„Z`d®d^„Zad¯d_„Zby)°rw aD
|
|||
|
|
This class represents an image object. To create
|
|||
|
|
:py:class:`~PIL.Image.Image` objects, use the appropriate factory
|
|||
|
|
functions. There's hardly ever any reason to call the Image constructor
|
|||
|
|
directly.
|
|||
|
|
|
|||
|
|
* :py:func:`~PIL.Image.open`
|
|||
|
|
* :py:func:`~PIL.Image.new`
|
|||
|
|
* :py:func:`~PIL.Image.frombytes`
|
|||
|
|
Nú
|
|||
|
|
str | NoneÚformatÚformat_descriptionTc óf — d | _ d| _ d| _ d | _ i | _ d| _ d | _ y )Nræ ©r r r )Ú_imÚ_modeÚ_sizeÚpaletteÚinfoÚreadonlyÚ_exifr s r% r zImage.__init__y s3 € à<@ˆŒØˆŒ
|
|||
|
|
؈Œ
|
|||
|
|
Ø9=ˆŒ Ø68ˆŒ ؈Œ
|
|||
|
|
Ø"&ˆ�
|
|||
|
|
r$ c ó– — t | j t « r| j j ‚| j €J ‚| j S r )rÓ r. r Úexr s r% r� zImage.imƒ s7 € ä �d—h‘h¤
|
|||
|
|
Ô .Ø—(‘(—+‘+Ð Ø�x‰xÐ#Ð#Ð#Ø�x‰xˆr$ c ó — || _ y r )r. ©r r� s r% r� zImage.imŠ s € àˆ�r$ c ó — | j d S ©Nr ©Úsizer s r% r} z Image.widthŽ ó € à�y‰y˜‰|Ðr$ c ó — | j d S ry r; r s r% r| z Image.height’ r= r$ c ó — | j S r )r0 r s r% r< z
|
|||
|
|
Image.size– ó € à�z‰zÐr$ c ó — | j S r )r/ r s r% r{ z
|
|||
|
|
Image.modeš r@ r$ c óf — | j xr | j j xs | j S r )r. r3 Ú _readonlyr s r% r3 zImage.readonlyž s$ € à—‘Ò.˜TŸX™X× .Ñ .ÒA°4·>±>ÐAr$ c ó — || _ y r )rC )r r3 s r% r3 zImage.readonly¢ s € à!ˆ�r$ c óV — t « }||_ |j |_ |j |_ |j dv rH| j r | j j « |_ n ddlm } |j « |_ | j j « |_
|
|||
|
|
|S )N©r’ r“ r ©rd ) rw r� r{ r/ r< r0 r1 Úcopyræ rd r2 )r r� Únewrd s r% Ú_newz
|
|||
|
|
Image._new¦ sy € Ü‹gˆØˆŒØ—G‘GˆŒ Ø—G‘GˆŒ Ø
|
|||
|
|
�7‰7�kÑ !Ø�|Š|Ø "Ÿl™l× /Ñ /Ó 1�• å*à 7˜l× 7Ñ 7Ó 9�” Ø—9‘9—>‘>Ó#ˆŒØˆ
|
|||
|
|
r$ c ó — | S r r# r s r% Ú __enter__zImage.__enter__¶ s € ؈ r$ c ó — y r r# )r rô s r% Ú__exit__zImage.__exit__¹ s € Ø r$ c óØ — t | dd« rDt j dk( r*t t d« r| j j « d| _ t
|
|||
|
|
t d« « | _ y)av
|
|||
|
|
This operation will destroy the image core and release its memory.
|
|||
|
|
The image data will be unusable afterward.
|
|||
|
|
|
|||
|
|
This function is required to close images that have multiple frames or
|
|||
|
|
have not had their file read and closed by the
|
|||
|
|
:py:meth:`~PIL.Image.Image.load` method. See :ref:`file-handling` for
|
|||
|
|
more information.
|
|||
|
|
ÚmapNÚwin32Úpypy_version_infozOperation on closed image) rï ÚsysÚplatformÚhasattrrP Úcloser Ú
|
|||
|
|
ValueErrorr. r s r% rV z Image.close¼ sO € ô �4˜ Ô %Ü�|‰|˜wÒ&¬7´3Ð8KÔ+LØ—‘—‘Ô Ø)-ˆDŒHô
|
|||
|
|
!¤Ð,GÓ!HÓIˆ�r$ c óp — | j « | j j « | _ d| _ y r: )Úloadr� rH r3 r s r% Ú_copyz Image._copyÐ s# € Ø � ‰ Œ Ø—'‘'—,‘,“.ˆŒØˆ�
|
|||
|
|
r$ c ó^ — | j r| j « y | j « y r )r3 rZ rY r s r% Ú_ensure_mutablezImage._ensure_mutableÕ s € Ø �=Š=Ø �J‰J�Là �I‰I�Kr$ c ó8 — d}|rd|› �}|s.t j |« \ }}t j |« n|}|j |« s||z }| j « |r|dk( r | j j |« |S | j ||fi |¤Ž |S )Nræ rÑ ÚPPM) ÚtempfileÚmkstempÚosrV ÚendswithrY r� Úsave_ppmÚsave)r Úfiler* ÚoptionsÚsuffixÚfÚfilenames r% Ú_dumpz Image._dumpÛ s� € ð ˆÙ ؘ˜�\ˆFáÜ"×*Ñ*¨6Ó2‰KˆAˆxÜ �H‰H�Q�KàˆHØ×$Ñ$ VÔ,Ø# fÑ,�à � ‰ Œ ᘠ5š Ø �G‰G× Ñ ˜XÔ &ð ˆð
|
|||
|
|
ˆD�I‰I�h Ñ 2¨'Ò 2àˆr$ c ó‚ — | j |j uryt |t « sJ ‚| j |j k( xrz | j |j k( xr_ | j
|
|||
|
|
|j
|
|||
|
|
k( xrD | j
|
|||
|
|
« |j
|
|||
|
|
« k( xr! | j « |j « k( S ©NF)Ú __class__rÓ rw r{ r< r2 Ú
|
|||
|
|
getpaletteÚtobytesr s r% Ú__eq__z Image.__eq__ó sž € Ø �>‰> § ¡ Ñ 0Øܘ%¤Ô'Ð'Ð'à �I‰I˜Ÿ™Ñ #ò
|
|||
|
|
2Ø— ‘ ˜UŸZ™ZÑ'ò
|
|||
|
|
2à— ‘ ˜UŸZ™ZÑ'ò
|
|||
|
|
2ð —‘Ó! U×%5Ñ%5Ó%7Ñ7ò
|
|||
|
|
2ð — ‘ “ %§-¡-£/Ñ1ð
|
|||
|
|
r$ c óØ — d| j j › d| j j › d| j › d| j d › d| j d › dt | « d ›d
|
|||
|
|
�
|
|||
|
|
S ) Nru rÑ ú image mode=ú size=r Úxr z at 0xÚXrv )rm r! r r{ r< Úidr s r% Ú__repr__zImage.__repr__ÿ sm € à�—‘×)Ñ)Ð*¨!¨D¯N©N×,CÑ,CÐ+Dð EØ Ÿ)™)˜ F¨4¯9©9°Q©<¨.¸¸$¿)¹)ÀA¹,¸ ð HÜ�t“H˜Q�<˜qð
|
|||
|
|
"ð
|
|||
|
|
r$ c
|
|||
|
|
óÞ — |j d| j j › d| j j › d| j › d| j
|
|||
|
|
d › d| j
|
|||
|
|
d › d� « y )
|
|||
|
|
z"IPython plain text display supportru rÑ rr rs r rt r rv N)Útextrm r! r r{ r< )r ÚpÚcycles r% Ú
|
|||
|
|
_repr_pretty_zImage._repr_pretty_ sf € ð
|
|||
|
|
|
|||
|
|
�‰Ø�—‘×)Ñ)Ð*¨!¨D¯N©N×,CÑ,CÐ+Dð EØ Ÿ)™)˜ F¨4¯9©9°Q©<¨.¸¸$¿)¹)ÀA¹,¸ Àqð
|
|||
|
|
Jõ
|
|||
|
|
r$ c ó’ — t j « } | j ||fi |¤Ž |j « S # t $ r Y yw xY w)z�Helper function for iPython display hook.
|
|||
|
|
|
|||
|
|
:param image_format: Image format.
|
|||
|
|
:returns: image as bytes, saved into the given format.
|
|||
|
|
N)ÚioÚBytesIOrd Ú ExceptionÚgetvalue)r Ú image_formatÚkwargsÚbs r% Ú _repr_imagezImage._repr_image sK € ô
|
|||
|
|
�J‰J‹Lˆð Ø ˆD�I‰I�a˜ Ñ 0¨Ò 0ð �z‰z‹|Ðøô ò Ùð ús –: º AÁAc ó( — | j dd¬« S )zjiPython display hook support for PNG format.
|
|||
|
|
|
|||
|
|
:returns: PNG version of the image as bytes
|
|||
|
|
ÚPNGr )Úcompress_level©r… r s r% Ú
|
|||
|
|
_repr_png_zImage._repr_png_ s € ð
|
|||
|
|
× Ñ °aÐ Ó8Ð8r$ c ó$ — | j d« S )zliPython display hook support for JPEG format.
|
|||
|
|
|
|||
|
|
:returns: JPEG version of the image as bytes
|
|||
|
|
ÚJPEGr‰ r s r% Ú _repr_jpeg_zImage._repr_jpeg_$ s € ð
|
|||
|
|
× Ñ Ó'Ð'r$ c ó¦ — ddi}| j dk( r| j dd« |d< n| j « |d< t | « \ |d< |d< |S ) NÚversionr2 r† ÚrawrŽ Údatarƒ r€ )r{ ro r… )r rI s r% Ú__array_interface__zImage.__array_interface__+ s\ € ð @IÈ!¸nˆØ �9‰9˜Ò ð Ÿ,™, u¨cÓ2ˆC�ŠKà Ÿ,™,›.ˆC�‰KÜ'7¸Ó'=Ñ$ˆˆG‰ �c˜)‘n؈
|
|||
|
|
r$ c óV — | j « | j j « S r )rY r� Ú__arrow_c_schema__r s r% r” zImage.__arrow_c_schema__8 s € Ø � ‰ Œ Ø�w‰w×)Ñ)Ó+Ð+r$ c óŠ — | j « | j j « | j j « fS r )rY r� r” Ú__arrow_c_array__©r Úrequested_schemas r% r– zImage.__arrow_c_array__< s2 € ð
|
|||
|
|
� ‰ Œ Ø—‘×*Ñ*Ó,¨d¯g©g×.GÑ.GÓ.IÐJÐJr$ c óˆ — | j « }| j | j | j | j « |gS r )ro r2 r{ r< rn )r Úim_datas r% Ú __getstate__zImage.__getstate__B s1 € Ø—,‘,“.ˆØ— ‘ ˜4Ÿ9™9 d§i¡i°· ± Ó1BÀGÐLÐLr$ c óô — t j | « |d d \ }}}}}|| _ || _ || _ t j ||« | _ |dv r|r| j |« | j |« y )Nr4 ©rŽ r� r’ r“ )
|
|||
|
|
rw r r2 r/ r0 rð rI r� Ú
|
|||
|
|
putpaletteÚ frombytes)r Ústater2 r{ r< r1 r‘ s r% Ú __setstate__zImage.__setstate__F sn € Ü
|
|||
|
|
�‰�tÔ Ø*/°°¨)Ñ'ˆˆd�D˜' 4؈Œ ؈Œ
|
|||
|
|
؈Œ
|
|||
|
|
Ü—(‘(˜4 Ó&ˆŒØ Ð)Ñ )©gØ �O‰O˜GÔ $Ø �‰�tÕ r$ c ó\ — |}t |« dk( rt |d t « r|d }|dk( r|dk( r | j }| j « | j
|
|||
|
|
dk( s| j dk( ryt | j ||« }|j | j d| j z « ddl m } t |j | j d dz « }g } |j |« \ }} }
|
|||
|
|
|j! |
|
|||
|
|
« | rnŒ*| dk rd | › d
|
|||
|
|
�} t# | « ‚dj% |« S ) a°
|
|||
|
|
Return image as a bytes object.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
|
|||
|
|
This method returns raw image data derived from Pillow's internal
|
|||
|
|
storage. For compressed image data (e.g. PNG, JPEG) use
|
|||
|
|
:meth:`~.save`, with a BytesIO parameter for in-memory data.
|
|||
|
|
|
|||
|
|
:param encoder_name: What encoder to use.
|
|||
|
|
|
|||
|
|
The default is to use the standard "raw" encoder.
|
|||
|
|
To see how this packs pixel data into the returned
|
|||
|
|
bytes, see :file:`libImaging/Pack.c`.
|
|||
|
|
|
|||
|
|
A list of C encoders can be seen under codecs
|
|||
|
|
section of the function array in
|
|||
|
|
:file:`_imaging.c`. Python encoders are registered
|
|||
|
|
within the relevant plugins.
|
|||
|
|
:param args: Extra arguments to the encoder.
|
|||
|
|
:returns: A :py:class:`bytes` object.
|
|||
|
|
r r r� r# r$ r- ©rb r3 zencoder error z in tobytes)r~ rÓ rí r{ rY r} r| rþ Úsetimager� r< ræ rb ÚmaxÚMAXBLOCKÚencodeÚappendÚ RuntimeErrorÚjoin) r rü rô Ú encoder_argsrâ rb ÚbufsizeÚoutputÚbytes_consumedÚerrcoder‘ rö s r% ro z
|
|||
|
|
Image.tobytesQ s € ð0 !ˆ Ü ˆ|Ó Ò !¤j° ¸a± Ä%Ô&Hà'¨™?ˆLà ˜5Ò \°RÒ%7Ø Ÿ9™9ˆLà � ‰ Œ à �:‰:˜Š?˜dŸk™k¨QÒ .Øô
|
|||
|
|
˜Ÿ ™ <° Ó >ˆØ �
|
|||
|
|
‰
|
|||
|
|
�4—7‘7˜F T§Y¡YÑ .Ô/å ä�i×(Ñ(¨$¯)©)°A©,¸Ñ*:Ó;ˆàˆØØ,-¯H©H°WÓ,=Ñ )ˆN˜G TØ �M‰M˜$Ô ÙØð ð
|
|||
|
|
�QŠ;Ø" 7 )¨;Ð7ˆCÜ ˜sÓ#Ð #à�x‰x˜Ó Ð r$ c óZ — | j « | j dk7 r
|
|||
|
|
d}t |« ‚| j d« }dj d|› d| j
|
|||
|
|
d › d�j
|
|||
|
|
d « d|› d
|
|||
|
|
| j
|
|||
|
|
d › d�j
|
|||
|
|
d « d |› d
|
|||
|
|
�j
|
|||
|
|
d « |dg« S )a-
|
|||
|
|
Returns the image converted to an X11 bitmap.
|
|||
|
|
|
|||
|
|
.. note:: This method only works for mode "1" images.
|
|||
|
|
|
|||
|
|
:param name: The name prefix to use for the bitmap variables.
|
|||
|
|
:returns: A string containing an X11 bitmap.
|
|||
|
|
:raises ValueError: If the mode is not "1"
|
|||
|
|
r† z not a bitmapÚxbmr$ z#define z_width r ú
|
|||
|
|
Úasciiz_height r z static char z _bits[] = {
|
|||
|
|
s };)rY r{ rW ro rª r< r§ )r Únamerö r‘ s r% ÚtobitmapzImage.tobitmapŠ s³ € ð
|
|||
|
|
� ‰ Œ Ø �9‰9˜Ò Ø ˆCÜ ˜S“/Ð !Ø�|‰|˜EÓ"ˆØ�x‰xà˜4˜& ¨¯ © °!© ~°RÐ8×?Ñ?ÀÓHؘ4˜& ¨¯©°1© ¨°bÐ9×@Ñ@ÀÓIØ ˜t˜f NÐ3×:Ñ:¸7ÓCØØð
|
|||
|
|
ó
|
|||
|
|
ð
|
|||
|
|
r$ c ó´ — | j dk( s| j dk( ry|}t |« dk( rt |d t « r|d }|dk( r|dk( r | j
|
|||
|
|
}t
|
|||
|
|
| j
|
|||
|
|
||« }|j | j d| j z « |j |« }|d dk\ r
|
|||
|
|
d}t |« ‚|d dk7 r
|
|||
|
|
d}t |« ‚y) zç
|
|||
|
|
Loads this image with pixel data from a bytes object.
|
|||
|
|
|
|||
|
|
This method is similar to the :py:func:`~PIL.Image.frombytes` function,
|
|||
|
|
but loads data into this image instead of creating a new image object.
|
|||
|
|
r Nr r� r# r- znot enough image datazcannot decode image data) r} r| r~ rÓ rí r{ r÷ r¤ r� r< rÕ rW )r r‘ ró rô Ú decoder_argsÚdÚsrö s r% rŸ zImage.frombytes¤ sÔ € ð �:‰:˜Š?˜dŸk™k¨QÒ .Ø à ˆ Ü ˆ|Ó Ò !¤j° ¸a± Ä%Ô&Hà'¨™?ˆLð ˜5Ò \°RÒ%7Ø Ÿ9™9ˆLô
|
|||
|
|
˜Ÿ ™ <° Ó >ˆØ �
|
|||
|
|
‰
|
|||
|
|
�4—7‘7˜F T§Y¡YÑ .Ô/Ø
|
|||
|
|
�H‰H�T‹Nˆà ˆQ‰4�1Š9Ø)ˆCÜ ˜S“/Ð !Ø ˆQ‰4�1Š9Ø,ˆCÜ ˜S“/Ð !ð r$ c ó¦ — | j ��“| j �r†| j j �ro| j j « \ }}| j j | j j ||« d| j _ d| j _ d| j v r…|dv r�t | j d t « r*| j j | j d d« n(| j j | j d « d| j _ nl| j j |k7 rS| j j | j j | j j « | j _ | j �%| j j | j « S y)at
|
|||
|
|
Allocates storage for the image and loads the pixel data. In
|
|||
|
|
normal cases, you don't need to call this method, since the
|
|||
|
|
Image class automatically loads an opened image when it is
|
|||
|
|
accessed for the first time.
|
|||
|
|
|
|||
|
|
If the file associated with the image was opened by Pillow, then this
|
|||
|
|
method will close it. The exception to this is if the image has
|
|||
|
|
multiple frames, in which case the file will be left open for seek
|
|||
|
|
operations. See :ref:`file-handling` for more information.
|
|||
|
|
|
|||
|
|
:returns: An image access object.
|
|||
|
|
:rtype: :py:class:`.PixelAccess`
|
|||
|
|
Nr Ú transparency©r� r“ r• )r. r1 Údirtyr' r� rž r{ Úrawmoder2 rÓ ÚintÚputpalettealphaÚputpalettealphasrn Ú pixel_accessr3 )r r{ Úarrs r% rY z
|
|||
|
|
Image.loadÉ sH € ð �8‰8Ñ D§L£L°T·\±\×5GÓ5Gà Ÿ ™ ×,Ñ,Ó.‰IˆD�#Ø �G‰G× Ñ ˜tŸ|™|× 0Ñ 0°$¸Ô <Ø!"ˆD�L‰LÔ Ø#'ˆD�L‰LÔ Ø §¡Ñ*¨t°|Ñ/CÜ ˜dŸi™i¨Ñ 7¼Ô=Ø—G‘G×+Ñ+¨D¯I©I°nÑ,EÀqÕIà—G‘G×,Ñ,¨T¯Y©Y°~Ñ-FÔGØ$*�— ‘ Õ!Ø— ‘ ×"Ñ" dÒ*ð (,§w¡w×'9Ñ'9Ø—L‘L×%Ñ% t§|¡|×'8Ñ'8ó(�— ‘ Ô$ð �8‰8Ð Ø—7‘7×'Ñ'¨¯
|
|||
|
|
©
|
|||
|
|
Ó6Ð 6Ør$ c ó — y)as
|
|||
|
|
Verifies the contents of a file. For data read from a file, this
|
|||
|
|
method attempts to determine if the file is broken, without
|
|||
|
|
actually decoding the image data. If this method finds any
|
|||
|
|
problems, it raises suitable exceptions. If you need to load
|
|||
|
|
the image after using this method, you must reopen the image
|
|||
|
|
file.
|
|||
|
|
Nr# r s r% Úverifyz Image.verifyï s € ð
|
|||
|
|
r$ é c ól ‡‡ ‡ — | j « d| j v }|s=| j dk( r.| j r| j j }nd}|dk( r|rd}|r|| j k( r‰s| j « S ‰rÈ|dvr
|
|||
|
|
d}t |« ‚| j j |‰« }| j |« } |r†| j j dk( rm| j d Š d$d„Š |d k( r
|
|||
|
|
‰ ‰‰ « Š n6t |« dk( r(t ˆ ˆˆ fd
|
|||
|
|
„t t ‰ « « D « « Š ‰ | j d< | S | j dk( r^|dk( r| j |« S |d k( rC| j « \ }
|
|||
|
|
} } }
|
|||
|
|
t d|
|
|||
|
|
| | f« }|j |« }t d ||
|
|||
|
|
f« S d }d
|
|||
|
|
}|�r2| j dv r|dv s| j dk( rK|dv rG| j | j j! || j d « « } | j d= | S | j dv �r-|dv �r(| j d }t# |t$ « rt' j( d« d}�nzt+ | j d« }| j dk( r{| j €J ‚|j- | j | j j « t# |t « r-d}|j €J ‚ |j j/ || « }|€d }nÕ|j3 d|« |dv r|j5 |« }n|j5 d« }|j7 d« }nŠ| j dk( r{|dv rw| j d }d}t# |t$ « r | j j9 |« n:t# |t: « r | j j= |d« n
|
|||
|
|
d}t |« ‚|dk( rÌ|t> j@ k( r¹| j j |« }| j |« } dd l!m"} |jD d| j jG d« « | _ |r
|
|||
|
|
| j d= |�C | j j/ tI t t: d f |« | « | j d< | S | S d | j |fv r| }|d k( r,|j d vr|j5 d« }|j }n|}|d v rtdd!l!m&} |jO d"« }|jO d « }|j d k( r||gn||g}|jQ |d |d |j |« } | jS |« S |€tT jV } | j j5 ||« }| j |« } |d#v r@|t> j@ k7 r-dd l!m"} |jD d|jG d« « | _ |r
|
|||
|
|
| j d= |�m| j dk( rO| j rC | j j/ tI t t: d f |« | « | j d< | S || j d< | S # t
|
|||
|
|
$ r(}t1 |« dk( rd }n t |« |‚Y d }~�Œ˜d }~ww xY w# tJ $ r& | j d= t' j( d « Y | S w xY w# t
|
|||
|
|
$ rw tY | j « } | | j k( r‚ | j j5 | « }|j5 ||« }n # tZ $ r}d}t |« |‚d }~ww xY wY �Œºw xY w# t
|
|||
|
|
$ r;}| j d= t1 |« dk7 rt' j( d « Y d }~| S d }~ww xY w)%aÛ
|
|||
|
|
Returns a converted copy of this image. For the "P" mode, this
|
|||
|
|
method translates pixels through the palette. If mode is
|
|||
|
|
omitted, a mode is chosen so that all information in the image
|
|||
|
|
and the palette can be represented without a palette.
|
|||
|
|
|
|||
|
|
This supports all possible conversions between "L", "RGB" and "CMYK". The
|
|||
|
|
``matrix`` argument only supports "L" and "RGB".
|
|||
|
|
|
|||
|
|
When translating a color image to grayscale (mode "L"),
|
|||
|
|
the library uses the ITU-R 601-2 luma transform::
|
|||
|
|
|
|||
|
|
L = R * 299/1000 + G * 587/1000 + B * 114/1000
|
|||
|
|
|
|||
|
|
The default method of converting a grayscale ("L") or "RGB"
|
|||
|
|
image into a bilevel (mode "1") image uses Floyd-Steinberg
|
|||
|
|
dither to approximate the original image luminosity levels. If
|
|||
|
|
dither is ``None``, all values larger than 127 are set to 255 (white),
|
|||
|
|
all other values to 0 (black). To use other thresholds, use the
|
|||
|
|
:py:meth:`~PIL.Image.Image.point` method.
|
|||
|
|
|
|||
|
|
When converting from "RGBA" to "P" without a ``matrix`` argument,
|
|||
|
|
this passes the operation to :py:meth:`~PIL.Image.Image.quantize`,
|
|||
|
|
and ``dither`` and ``palette`` are ignored.
|
|||
|
|
|
|||
|
|
When converting from "PA", if an "RGBA" palette is present, the alpha
|
|||
|
|
channel from the image will be used instead of the values from the palette.
|
|||
|
|
|
|||
|
|
:param mode: The requested mode. See: :ref:`concept-modes`.
|
|||
|
|
:param matrix: An optional conversion matrix. If given, this
|
|||
|
|
should be 4- or 12-tuple containing floating point values.
|
|||
|
|
:param dither: Dithering method, used when converting from
|
|||
|
|
mode "RGB" to "P" or from "RGB" or "L" to "1".
|
|||
|
|
Available methods are :data:`Dither.NONE` or :data:`Dither.FLOYDSTEINBERG`
|
|||
|
|
(default). Note that this is not used when ``matrix`` is supplied.
|
|||
|
|
:param palette: Palette to use when converting from mode "RGB"
|
|||
|
|
to "P". Available palettes are :data:`Palette.WEB` or
|
|||
|
|
:data:`Palette.ADAPTIVE`.
|
|||
|
|
:param colors: Number of colors to use for the :data:`Palette.ADAPTIVE`
|
|||
|
|
palette. Defaults to 256.
|
|||
|
|
:rtype: :py:class:`~PIL.Image.Image`
|
|||
|
|
:returns: An :py:class:`~PIL.Image.Image` object.
|
|||
|
|
r» r’ r” r• )rŽ r” zillegal conversionr2 c ó˜ — | d |d z | d |d z z | d |d z z | d dz z }t dt dt |« « « S )Nr r r1 r2 rL éÿ )r¥ Úminr¿ )r‚ ÚvÚvalues r% Úconvert_transparencyz+Image.convert.<locals>.convert_transparencyF s\ € ð ˜a™D 1 Q¡4™K¨!¨A©$°°1±©+Ñ 5¸¸!¹¸qÀ¹t¹ Ñ CÀaÈÁdÈSÁjÑ P�EÜ ˜q¤# c¬3¨u«:Ó"6Ó7Ð7r$ rŽ c 3 óH •K — | ] } ‰‰|d z |d z d z ‰« –— Œ yw)r3 Nr# )Ú.0ÚirÍ Úmatrixr» s €€€r% ú <genexpr>z Image.convert.<locals>.<genexpr>O s3 øè ø€ ò )à ñ -¨V°A¸±E¸AÀ¹EÀA¹IÐ-FÈ ×Uñ)ùs ƒ "r“ NF)r† rŽ rŠ r‹ ©r� r• )r� r� r– r• )rŽ r” r’ zVPalette images with Transparency expressed in bytes should be converted to RGBA imagesT©r r z2Couldn't allocate a palette color for transparencyz$cannot allocate more than 256 colorsr- ©r� r“ r• r z.Transparency for P mode should be bytes or intr rG .z0Couldn't allocate palette entry for transparencyr‘ )r” r• r— )ÚImageCmsÚsRGBrF )r‚ ztuple[float, ...]rË ztuple[int, int, int]r r¿ ).rY r2 r{ r1 rH rW r� Úconvert_matrixrJ r r~ rí ÚrangeÚquantizeÚsplitÚmergeÚconvert_transparentrÓ rÔ ÚwarningsÚwarnrI rž ÚgetcolorÚstrÚputpixelÚconvertÚgetpixelrÁ r¿ rÀ rV rX ræ rd rn r r€ rÖ Ú
|
|||
|
|
createProfileÚbuildTransformÚapplyrP rT rœ rî ) r r{ rÑ Úditherr1 ÚcolorsÚhas_transparencyrö r� Únew_imÚrÚgr„ r" Úrgbrz ÚtrnsÚ delete_trnsÚtÚtrns_imÚerrrâ rd Ú
|
|||
|
|
other_moderÖ ÚsrgbÚlabÚprofilesÚ transformÚmodebaserÍ r» s ` @@r% rã z
|
|||
|
|
Image.convertú sE ú€ ðh
|
|||
|
|
� ‰ Œ à)¨T¯Y©YÐ6ÐÙ˜Ÿ ™ SÒ(à�|Š|Ø—|‘|×(Ñ(‘à �Ø�uŠ}Ñ!1Ø �Ù˜ § ¡ Ò)±&Ø—9‘9“;Ð á à˜<Ñ'Ø*�Ü “oÐ%Ø—‘×'Ñ'¨¨fÓ5ˆBØ—Y‘Y˜r“]ˆFÙ D§G¡G§M¡M°QÒ$6Ø %Ÿ{™{¨>Ñ :� ð8Ø(ð8Ø-Að8àó8ð ˜3’;Ù#7¸À Ó#M‘Lܘ“Y !’^Ü#(õ )ä!&¤s¨<Ó'8Ó!9ô)ó $�Lð /;�— ‘ ˜NÑ+؈Mà �9‰9˜Ò Ø�sŠ{Ø—}‘} VÓ,Ð,ؘ’ Ø !ŸZ™Z›\‘
|
|||
|
|
��1�a˜Ü˜E A q¨! 9Ó-�Ø—L‘L Ó(�Ü ˜T A q 6Ó*Ð*àˆØˆ â Ø— ‘ Ð 4Ñ4¸À Ñ9OØ— ‘ ˜UÒ" tÐ/KÑ'K𠟙ؗG‘G×/Ñ/°°d·i±iÀÑ6OÓPó�ð —K‘K Ð/Ø �
|
|||
|
|
Ø—‘Ð /Ò/°DÐ<MÒ4MØ—I‘I˜nÑ-�Ü ˜a¤Ô'ä —M‘Mð3ôð #'’Kô " $§)¡)¨VÓ 4�GØ—y‘y CÒ'Ø #Ÿ|™|Ð 7Ð7Ð 7Ø ×*Ñ*¨4¯<©<¸¿ ¹ ×9JÑ9JÔKÜ% a¬Ô/Ø"V˜CØ#*§?¡?Ð#>Ð >Ð#>ð AØ$+§O¡O×$<Ñ$<¸QÀÓ$E ð �yØ #™à ×(Ñ(¨°Ô3à <Ñ/Ø&-§o¡o°dÓ&;™Gð '.§o¡o°eÓ&<˜GØ &× /Ñ /°Ó 7™à—‘˜cÒ! dÐ.BÑ&BØ—I‘I˜nÑ-�Ø "� ä ˜a¤Ô'Ø—G‘G×,Ñ,¨QÕ/Ü ¤3Ô'Ø—G‘G×+Ñ+¨A¨qÕ1àJ�CÜ$ S›/Ð)à �3Š;˜7¤g×&6Ñ&6Ò6Ø—‘×!Ñ! &Ó)ˆBØ—Y‘Y˜r“]ˆFÝ &à 6˜\× 6Ñ 6Ø�v—y‘y×+Ñ+¨EÓ2ó ˆFŒNñ ð —K‘K Ð/ØÐ ð VØ28·.±.×2IÑ2IÜ œU¤3¨ 8™_¨dÓ3Ø ó3�F—K‘K Ñ/ð ˆM�6ˆMà �T—Y‘Y Ð%Ñ %؈BØ�uŠ}Ø—7‘7Ð"9Ñ9ØŸ™ FÓ+�BØ ŸW™W‘
|
|||
|
|
à !�
|
|||
|
|
ØÐ 4Ñ4Ý&à ×-Ñ-¨fÓ5�Ø ×,Ñ,¨UÓ3�Ø*,¯'©'°UÒ*:˜C ™;ÀÀsÀ �Ø $× 3Ñ 3Ø ˜Q‘K ¨!¡¨b¯g©g°tó � ð !—‘ rÓ*Ð*ð ˆ>Ü×*Ñ*ˆFð -Ø—‘— ‘ vÓ.ˆBð —‘˜2“ ˆØ �;Ñ 7¬g×.>Ñ.>Ò#>Ý &à 6˜\× 6Ñ 6°u¸b¿m¹mÈEÓ>RÓ SˆFŒNÙ à— ‘ ˜NÐ+Ø Ð Ø�{‰{˜cÒ! f§n¢nð Ø28·.±.×2IÑ2IÜ œU¤3¨ 8™_¨dÓ3°Vó3�F—K‘K Ñ/ð ˆ
|
|||
|
|
ð /3�— ‘ ˜NÑ+؈
|
|||
|
|
øôm $.ò AÜ#& q£6Ð-SÒ#Sð )-¡Aä*4°S«/¸qÐ$@õ %&ûð Aûôd !ò Vð Ÿ ™ NÐ3Ü —M‘MÐ"TÕU؈Mð Vûô@ ò
|
|||
|
|
-ð
|
|||
|
|
-ä& t§y¡yÓ1�ؘtŸy™yÒ(ØØ—W‘W—_‘_ XÓ.�Ø—Z‘Z fÓ-‘øÜò
|
|||
|
|
-Ø*�Ü “o¨1Ð,ûð
|
|||
|
|
-úò ð
|
|||
|
|
-ûô4 "ò Ø Ÿ ™ NÐ3ܘ1“vÐ!GÒGô !Ÿ
|
|||
|
|
™
|
|||
|
|
Ø Nôûð
|
|||
|
|
ˆ
|
|||
|
|
ûðús{ Ë> Z ÒA Z: Ö [, Ø3A ]/ Ú Z7Ú Z2Ú2Z7Ú:+[)Û([)Û, ],Û6A] Ý],Ý ]%Ý] Ý ]%Ý%],Ý+],Ý/ ^3Ý80^.Þ.^3r c ó¦ — | j « |€/t j }| j dk( rt j }| j dk( r/|t j t j
|
|||
|
|
fvr
|
|||
|
|
d}t
|
|||
|
|
|« ‚|r®|j « |j dk7 r
|
|||
|
|
d}t
|
|||
|
|
|« ‚| j dvr
|
|||
|
|
d}t
|
|||
|
|
|« ‚| j j d||j « }| j |« }|j €J ‚|j j « |_
|
|||
|
|
|S |dk r
|
|||
|
|
d }t
|
|||
|
|
|« ‚| j | j j |||« « }d
|
|||
|
|
d l
|
|||
|
|
m} |j j « }
|
|||
|
|
|j j! |
|
|||
|
|
|
|
|||
|
|
« d|t# |
|
|||
|
|
« z } | j |
|
|||
|
|
| « |_
|
|||
|
|
|S ) a3
|
|||
|
|
Convert the image to 'P' mode with the specified number
|
|||
|
|
of colors.
|
|||
|
|
|
|||
|
|
:param colors: The desired number of colors, <= 256
|
|||
|
|
:param method: :data:`Quantize.MEDIANCUT` (median cut),
|
|||
|
|
:data:`Quantize.MAXCOVERAGE` (maximum coverage),
|
|||
|
|
:data:`Quantize.FASTOCTREE` (fast octree),
|
|||
|
|
:data:`Quantize.LIBIMAGEQUANT` (libimagequant; check support
|
|||
|
|
using :py:func:`PIL.features.check_feature` with
|
|||
|
|
``feature="libimagequant"``).
|
|||
|
|
|
|||
|
|
By default, :data:`Quantize.MEDIANCUT` will be used.
|
|||
|
|
|
|||
|
|
The exception to this is RGBA images. :data:`Quantize.MEDIANCUT`
|
|||
|
|
and :data:`Quantize.MAXCOVERAGE` do not support RGBA images, so
|
|||
|
|
:data:`Quantize.FASTOCTREE` is used by default instead.
|
|||
|
|
:param kmeans: Integer greater than or equal to zero.
|
|||
|
|
:param palette: Quantize to the palette of given
|
|||
|
|
:py:class:`PIL.Image.Image`.
|
|||
|
|
:param dither: Dithering method, used when converting from
|
|||
|
|
mode "RGB" to "P" or from "RGB" or "L" to "1".
|
|||
|
|
Available methods are :data:`Dither.NONE` or :data:`Dither.FLOYDSTEINBERG`
|
|||
|
|
(default).
|
|||
|
|
:returns: A new image
|
|||
|
|
Nr• zoFast Octree (method == 2) and libimagequant (method == 3) are the only valid methods for quantizing RGBA imagesr’ zbad mode for palette image> rŽ r” z7only RGB or L mode images can be quantized to a paletter zkmeans must not be negativer rG )rY rZ r[ r{ r] r^ rW r� rã rJ r1 rH rÚ ræ rd Úgetpalettemodern r~ ) r ré ÚmethodÚkmeansr1 rè rö r� rë rd r{ Ú palette_datas r% rÚ zImage.quantizeú s– € ðF
|
|||
|
|
� ‰ Œ à ˆ>ä ×'Ñ'ˆFØ�y‰y˜FÒ"Ü!×,Ñ,�à �9‰9˜Ò 6Ü × Ñ Ü × "Ñ "ð2
|
|||
|
|
ñ $
|
|||
|
|
ð Hð
|
|||
|
|
ô ˜S“/Ð !á à �L‰LŒNØ�|‰|˜sÒ"Ø2�Ü “oÐ%Ø�y‰y Ñ,ØO�Ü “oÐ%Ø—‘— ‘ f¨g¯j©jÓ9ˆBØ—Y‘Y˜r“]ˆFØ—?‘?Ð.Ð .Ð.Ø $Ÿ_™_× 1Ñ 1Ó 3ˆFŒN؈Mà �AŠ:Ø/ˆCÜ ˜S“/Ð !à
|
|||
|
|
�Y‰Y�t—w‘w×'Ñ'¨°¸Ó?Ó
|
|||
|
|
@ˆå"à�u‰u×#Ñ#Ó%ˆØ—u‘u×'Ñ'¨¨dÓ3Ð4H°f¼sÀ4»yÑ6HÐIˆ Ø.�\×.Ñ.¨t°\ÓBˆŒ
|
|||
|
|
àˆ r$ c ót — | j « | j | j j « « S )zî
|
|||
|
|
Copies this image. Use this method if you wish to paste things
|
|||
|
|
into an image, but still retain the original.
|
|||
|
|
|
|||
|
|
:rtype: :py:class:`~PIL.Image.Image`
|
|||
|
|
:returns: An :py:class:`~PIL.Image.Image` object.
|
|||
|
|
)rY rJ r� rH r s r% rH z
|
|||
|
|
Image.copyM s& € ð
|
|||
|
|
� ‰ Œ Ø�y‰y˜Ÿ™Ÿ ™ › Ó(Ð(r$ c óü — |€| j « S |d |d k r
|
|||
|
|
d}t |« ‚|d |d k r
|
|||
|
|
d}t |« ‚| j « | j | j | j
|
|||
|
|
|« « S )a¸
|
|||
|
|
Returns a rectangular region from this image. The box is a
|
|||
|
|
4-tuple defining the left, upper, right, and lower pixel
|
|||
|
|
coordinate. See :ref:`coordinate-system`.
|
|||
|
|
|
|||
|
|
Note: Prior to Pillow 3.4.0, this was a lazy operation.
|
|||
|
|
|
|||
|
|
:param box: The crop rectangle, as a (left, upper, right, lower)-tuple.
|
|||
|
|
:rtype: :py:class:`~PIL.Image.Image`
|
|||
|
|
:returns: An :py:class:`~PIL.Image.Image` object.
|
|||
|
|
r1 r z&Coordinate 'right' is less than 'left'r2 r z'Coordinate 'lower' is less than 'upper')rH rW rY rJ Ú_cropr� )r Úboxrö s r% Úcropz
|
|||
|
|
Image.cropZ sx € ð ˆ;Ø—9‘9“;Ð à ˆq‰6�C˜‘FŠ?Ø:ˆCÜ ˜S“/Ð !Ø
|
|||
|
|
�‰V�c˜!‘fŠ_Ø;ˆCÜ ˜S“/Ð !à � ‰ Œ Ø�y‰y˜Ÿ™ D§G¡G¨SÓ1Ó2Ð2r$ c óÀ — t t t t |« « \ }}}}t ||z
|
|||
|
|
« t ||z
|
|||
|
|
« f}t |« |j ||||f« S )a]
|
|||
|
|
Returns a rectangular region from the core image object im.
|
|||
|
|
|
|||
|
|
This is equivalent to calling im.crop((x0, y0, x1, y1)), but
|
|||
|
|
includes additional sanity checks.
|
|||
|
|
|
|||
|
|
:param im: a core image object
|
|||
|
|
:param box: The crop rectangle, as a (left, upper, right, lower)-tuple.
|
|||
|
|
:returns: A core image object.
|
|||
|
|
)rP r¿ ÚroundÚabsÚ_decompression_bomb_checkr )r r� r Úx0Úy0Úx1Úy1Úabsolute_valuess r% r z Image._cropt sX € ô œS¤#¤e¨S£/Ó2‰ˆˆB��Bä ˜r B™w›<¬¨R°"©W« Ð6ˆä! /Ô2à�w‰w˜˜B BÐ'Ó(Ð(r$ c ó — y)aY
|
|||
|
|
Configures the image file loader so it returns a version of the
|
|||
|
|
image that as closely as possible matches the given mode and
|
|||
|
|
size. For example, you can use this method to convert a color
|
|||
|
|
JPEG to grayscale while loading it.
|
|||
|
|
|
|||
|
|
If any changes are made, returns a tuple with the chosen ``mode`` and
|
|||
|
|
``box`` with coordinates of the original image within the altered one.
|
|||
|
|
|
|||
|
|
Note that this method modifies the :py:class:`~PIL.Image.Image` object
|
|||
|
|
in place. If the image has already been loaded, this method has no
|
|||
|
|
effect.
|
|||
|
|
|
|||
|
|
Note: This method is not implemented for most images. It is
|
|||
|
|
currently implemented only for JPEG and MPO images.
|
|||
|
|
|
|||
|
|
:param mode: The requested mode.
|
|||
|
|
:param size: The requested size in pixels, as a 2-tuple:
|
|||
|
|
(width, height).
|
|||
|
|
Nr# )r r{ r< s r% Údraftz Image.draftŠ s € ð.
|
|||
|
|
r$ c
|
|||
|
|
ó6 — ddl m} | j « t |« r |« }t |d« s
|
|||
|
|
d}t |« ‚t
|
|||
|
|
||j « }| j j dk( s|r*| j |j | j « « S t | j j « D �cg c]; }| j |j | j j |« « « ‘Œ= }}t | j |« S c c}w )zé
|
|||
|
|
Filters this image using the given filter. For a list of
|
|||
|
|
available filters, see the :py:mod:`~PIL.ImageFilter` module.
|
|||
|
|
|
|||
|
|
:param filter: Filter kernel.
|
|||
|
|
:returns: An :py:class:`~PIL.Image.Image` object.r )rc Úfilterz>filter argument should be ImageFilter.Filter instance or class)ræ rc rY ÚcallablerU Ú TypeErrorrÓ ÚMultibandFilterr� r rJ r rÙ ÚgetbandrÜ r{ )r r rc rö Ú multibandÚcÚimss r% r z Image.filter£ sÚ € õ "à � ‰ Œ ä �FÔ Ù“XˆFÜ�v˜xÔ(ØRˆCܘC“.Ð ä ˜v {×'BÑ'BÓCˆ Ø �7‰7�=‰=˜AÒ ¡Ø—9‘9˜VŸ]™]¨4¯7©7Ó 3Ó4Ð 4ô CHÈÏÉÏ
|
|||
|
|
É
|
|||
|
|
ÓBVö
|
|||
|
|
Ø=>ˆD�I‰I�f—m‘m D§G¡G§O¡O°AÓ$6Ó7Õ 8ð
|
|||
|
|
ˆð
|
|||
|
|
ô �T—Y‘Y Ó$Ð$ùò
|
|||
|
|
s Â>A Dc óT — t j | j « j S )zä
|
|||
|
|
Returns a tuple containing the name of each band in this image.
|
|||
|
|
For example, ``getbands`` on an RGB image returns ("R", "G", "B").
|
|||
|
|
|
|||
|
|
:returns: A tuple containing band names.
|
|||
|
|
:rtype: tuple
|
|||
|
|
)r rz r{ r r s r% ÚgetbandszImage.getbands¾ s € ô × Ñ §¡Ó+×1Ñ1Ð1r$ )Ú
|
|||
|
|
alpha_onlyc óX — | j « | j j |« S )aG
|
|||
|
|
Calculates the bounding box of the non-zero regions in the
|
|||
|
|
image.
|
|||
|
|
|
|||
|
|
:param alpha_only: Optional flag, defaulting to ``True``.
|
|||
|
|
If ``True`` and the image has an alpha channel, trim transparent pixels.
|
|||
|
|
Otherwise, trim pixels when all channels are zero.
|
|||
|
|
Keyword-only argument.
|
|||
|
|
:returns: The bounding box is returned as a 4-tuple defining the
|
|||
|
|
left, upper, right, and lower pixel coordinate. See
|
|||
|
|
:ref:`coordinate-system`. If the image is completely empty, this
|
|||
|
|
method returns None.
|
|||
|
|
|
|||
|
|
)rY r� Úgetbbox)r r s r% r z
|
|||
|
|
Image.getbboxÈ s € ð
|
|||
|
|
� ‰ Œ Ø�w‰w�‰˜zÓ*Ð*r$ c ó — | j « | j dv rN| j j « }t d« D �cg c] }|| sŒ || |f‘Œ }}t |« |kD ry|S | j j
|
|||
|
|
|« S c c}w )aó
|
|||
|
|
Returns a list of colors used in this image.
|
|||
|
|
|
|||
|
|
The colors will be in the image's mode. For example, an RGB image will
|
|||
|
|
return a tuple of (red, green, blue) color values, and a P image will
|
|||
|
|
return the index of the color in the palette.
|
|||
|
|
|
|||
|
|
:param maxcolors: Maximum number of colors. If this number is
|
|||
|
|
exceeded, this method returns None. The default limit is
|
|||
|
|
256 colors.
|
|||
|
|
:returns: An unsorted list of (count, pixel) values.
|
|||
|
|
)r† rŽ r’ rÆ N)rY r{ r� Ú histogramrÙ r~ Ú getcolors)r Ú maxcolorsÚhrÐ Úouts r% r zImage.getcolorsÛ s € ð
|
|||
|
|
� ‰ Œ Ø �9‰9˜Ñ 'Ø—‘×!Ñ!Ó#ˆAÜ?DÀS»zÖ+R¸!ÈQÈqËT¨Q¨q©T°1ªIÐ+RˆCÐ+RÜ�3‹x˜)Ò#Ø؈JØ�w‰w× Ñ Ó+Ð+ùò ,Ss Á
|
|||
|
|
BÁ Bc óŽ — t ddd« | j « |�| j j |« S | j S )aå
|
|||
|
|
Returns the contents of this image as a sequence object
|
|||
|
|
containing pixel values. The sequence object is flattened, so
|
|||
|
|
that values for line one follow directly after the values of
|
|||
|
|
line zero, and so on.
|
|||
|
|
|
|||
|
|
Note that the sequence object returned by this method is an
|
|||
|
|
internal PIL data type, which only supports certain sequence
|
|||
|
|
operations. To convert it to an ordinary sequence (e.g. for
|
|||
|
|
printing), use ``list(im.getdata())``.
|
|||
|
|
|
|||
|
|
:param band: What band to return. The default is to return
|
|||
|
|
all bands. To return a single band, pass in the index
|
|||
|
|
value (e.g. 0 to get the "R" band from an "RGB" image).
|
|||
|
|
:returns: A sequence-like object.
|
|||
|
|
zImage.Image.getdataé Úget_flattened_data)r rY r� r ©r Úbands r% r' z
|
|||
|
|
Image.getdataô s= € ô" Ð'¨Ð-AÔBà � ‰ Œ Ø Ð Ø—7‘7—?‘? 4Ó(Ð (Ø�w‰wˆr$ c ó˜ — | j « |�$t | j j |« « S t | j « S )aÝ
|
|||
|
|
Returns the contents of this image as a tuple containing pixel values.
|
|||
|
|
The sequence object is flattened, so that values for line one follow
|
|||
|
|
directly after the values of line zero, and so on.
|
|||
|
|
|
|||
|
|
:param band: What band to return. The default is to return
|
|||
|
|
all bands. To return a single band, pass in the index
|
|||
|
|
value (e.g. 0 to get the "R" band from an "RGB" image).
|
|||
|
|
:returns: A tuple containing pixel values.
|
|||
|
|
)rY rí r� r r& s r% r% zImage.get_flattened_data s9 € ð
|
|||
|
|
� ‰ Œ Ø Ð Ü˜Ÿ™Ÿ ™ ¨Ó.Ó/Ð /Ü�T—W‘W‹~Ð r$ c óì ‡ — ‰ j « ‰ j j dkD r1t ˆ fd„t ‰ j j « D « « S ‰ j j « S )a"
|
|||
|
|
Gets the minimum and maximum pixel values for each band in
|
|||
|
|
the image.
|
|||
|
|
|
|||
|
|
:returns: For a single-band image, a 2-tuple containing the
|
|||
|
|
minimum and maximum pixel value. For a multi-band image,
|
|||
|
|
a tuple containing one 2-tuple for each band.
|
|||
|
|
r c 3 óp •K — | ]- }‰j j |« j « –— Œ/ y wr )r� r Ú
|
|||
|
|
getextrema)rÏ rÐ r s €r% rÒ z#Image.getextrema.<locals>.<genexpr>* s' øè ø€ ÒW¸Q˜Ÿ™Ÿ ™ ¨Ó+×6Ñ6×8ÑWùs ƒ36)rY r� r rí rÙ r+ r s `r% r+ zImage.getextrema sO ø€ ð
|
|||
|
|
� ‰ Œ Ø �7‰7�=‰=˜1Ò ÜÓWÄ%ÈÏÉÏ
|
|||
|
|
É
|
|||
|
|
ÓBVÔWÓWÐ WØ�w‰w×!Ñ!Ó#Ð#r$ c ó ‡‡— dd„Šdˆˆfd„ Št €t j d« i S d| j vri S t j | j d j d« « } ‰|j « ‰|« iS )z™
|
|||
|
|
Returns a dictionary containing the XMP tags.
|
|||
|
|
Requires defusedxml to be installed.
|
|||
|
|
|
|||
|
|
:returns: XMP tags in a dictionary.
|
|||
|
|
c ó0 — t j dd| « S )Nz^{[^}]+}ræ )ÚreÚsub)Útags r% Úget_namez Image.getxmp.<locals>.get_name5 s € Ü—6‘6˜* b¨#Ó.Ð .r$ c ó •— | j j « D ��ci c] \ }} ‰|« |“Œ }}}t | « }|r]|D ]V } ‰|j « } ‰ |« }||v r1t || t « s || g||< || j |« ŒR|||< ŒX |S |r | j r| j |d< |S | j S c c}}w )Nry )ÚattribÚitemsÚlistr0 rÓ r¨ ry )
|
|||
|
|
ÚelementÚkrË rÌ ÚchildrenÚchildr´ Ú child_valuer1 Ú get_values
|
|||
|
|
€€r% r; z Image.getxmp.<locals>.get_value8 sÚ ø€ Ø@GÇÁ×@TÑ@TÓ@V×$W¹¸¸1¡X¨a£[°!¡^Ð$WˆEÑ$WܘG“}ˆHÙØ %ò 2�EÙ# E§I¡IÓ.�DÙ"+¨EÓ"2�Kؘu‘}Ü )¨%°©+´tÔ <Ø+0°©;¨-˜E $™KØ ˜d™ ×*Ñ*¨;Õ7à&1˜˜dš ð2ð ˆLñ Ø—<’<Ø$+§L¡L�E˜&‘Mð ˆLð —|‘|Ð#ùó! %Xs ŸC
|
|||
|
|
z5XMP data cannot be read without defusedxml dependencyÚxmps )r0 rá r rá )r6 r` r zstr | dict[str, Any] | None)r rÞ rß r2 Ú
|
|||
|
|
fromstringÚrstripr0 )r Úrootr1 r; s @@r% Úgetxmpz Image.getxmp- st ù€ ó /ö ô( Ð Ü �M‰MÐQÔ R؈IØ ˜Ÿ ™ Ñ !؈IÜ×%Ñ% d§i¡i°Ñ&6×&=Ñ&=¸hÓ&GÓHˆÙ˜Ÿ™Ó"¡I¨d£OÐ4Ð4r$ c ó¬ — | j €t « | _ n"| j j r | j S d| j _ | j j d« }|�€d| j v rDt
|
|||
|
|
j
|
|||
|
|
dj | j d j d« dd « « }n¼t | d« r°d d
|
|||
|
|
l
|
|||
|
|
m } t | |j « sJ ‚| j j | j _ | j j" | j _ | j& €J ‚| j j) | j& | j j* « |�| j j- |« t. j0 j2 | j vr‹| j j d « }d }|s | j j d
|
|||
|
|
« x}rd}|rKt5 j6 ||« }|r3t9 |d « | j t. j0 j2 < | j S )zj
|
|||
|
|
Gets EXIF data from the image.
|
|||
|
|
|
|||
|
|
:returns: an :py:class:`~PIL.Image.Exif` object.
|
|||
|
|
NTÚexifzRaw profile type exifræ r² r2 Útag_v2r ©rf zXML:com.adobe.xmpz tiff:Orientation(="|>)([0-9])r< s tiff:Orientation(="|>)([0-9])r1 ) r4 ÚExifÚ_loadedr2 r× rÔ Úfromhexrª rÛ rU ræ rf rÓ Ú
|
|||
|
|
TiffImageFilerC Ú_bigtiffÚbigtiffÚ_endianÚendianÚfpÚ load_from_fpÚ_offsetrY r
|
|||
|
|
ÚBaseÚ Orientationr. Úsearchr¿ )r Ú exif_inforf Úxmp_tagsÚpatternÚmatchs r% Úgetexifz
|
|||
|
|
Image.getexifT s¼ € ð �:‰:Ð Ü ›ˆD�JØ
|
|||
|
|
�Z‰Z×
|
|||
|
|
Ò
|
|||
|
|
Ø—:‘:Ð Ø !ˆ�
|
|||
|
|
‰
|
|||
|
|
Ôà—I‘I—M‘M &Ó)ˆ Ø Ñ Ø&¨$¯)©)Ñ3Ü !ŸM™MØ—G‘G˜DŸI™IÐ&=Ñ >× DÑ DÀTÓ JÈ1È2Ð NÓOó ‘ ô ˜˜xÔ(Ý-ä! $¨×(EÑ(EÔFÐFÐFØ%)§[¡[×%9Ñ%9�—
|
|||
|
|
‘
|
|||
|
|
Ô"Ø$(§K¡K×$7Ñ$7�—
|
|||
|
|
‘
|
|||
|
|
Ô!à—w‘wÐ*Ð*Ð*Ø—
|
|||
|
|
‘
|
|||
|
|
×'Ñ'¨¯©°·±×1DÑ1DÔEØ Ð Ø �J‰J�O‰O˜IÔ &ô �=‰=× $Ñ $¨D¯J©JÑ 6Ø—y‘y—}‘}Ð%8Ó9ˆHØ#CˆGÙ¨T¯Y©Y¯]©]¸5Ó-AÐ!A Ð!AØ;�ÙÜŸ ™ '¨8Ó4�ÙÜ<?ÀÀaÁ»M�D—J‘JœxŸ}™}× 8Ñ 8Ñ9à�z‰zÐr$ c óŒ — | j �| j j sy d| j _ | j « y rl )r4 rF rW r s r% Ú _reload_exifzImage._reload_exif s0 € Ø �:‰:Ð T§Z¡Z×%7Ò%7Ø Ø "ˆ�
|
|||
|
|
‰
|
|||
|
|
ÔØ � ‰ �r$ c ó\ — ddl m} t dd« |j j | « S )Nr r£ z Image.Image.get_child_imagesé
|
|||
|
|
)ræ rb r Úget_child_images)r rb s r% r\ zImage.get_child_images… s' € Ý äÐ0°"Ô5Ø×"Ñ"×3Ñ3°DÓ9Ð9r$ c óN — | j « | j j S )zr
|
|||
|
|
Returns a capsule that points to the internal image memory.
|
|||
|
|
|
|||
|
|
:returns: A capsule object.
|
|||
|
|
)rY r� Úptrr s r% Úgetimz Image.getim‹ s € ð
|
|||
|
|
� ‰ Œ Ø�w‰w�{‰{Ðr$ c óÈ — | j « | j j « }|€|}t | j j ||« « S # t $ r Y yw xY w)aG
|
|||
|
|
Returns the image palette as a list.
|
|||
|
|
|
|||
|
|
:param rawmode: The mode in which to return the palette. ``None`` will
|
|||
|
|
return the palette in its current mode.
|
|||
|
|
|
|||
|
|
.. versionadded:: 9.1.0
|
|||
|
|
|
|||
|
|
:returns: A list of color values [r, g, b, ...], or None if the
|
|||
|
|
image has no palette.
|
|||
|
|
N)rY r� rû rW r5 rn )r r¾ r{ s r% rn zImage.getpalette• s` € ð
|
|||
|
|
� ‰ Œ ð Ø—7‘7×)Ñ)Ó+ˆDð ˆ?؈GÜ�D—G‘G×&Ñ& t¨WÓ5Ó6Ð6øô ò Ùð ús ’A Á A!Á A!c ó — | j dv sd| j v ry| j dk( r3| j €J ‚| j j j d« S y)aN
|
|||
|
|
Determine if an image has transparency data, whether in the form of an
|
|||
|
|
alpha channel, a palette with an alpha channel, or a "transparency" key
|
|||
|
|
in the info dictionary.
|
|||
|
|
|
|||
|
|
Note the image might still appear solid, if all of the values shown
|
|||
|
|
within are opaque.
|
|||
|
|
|
|||
|
|
:returns: A boolean.
|
|||
|
|
)r� r� r“ r• r– r» Tr’ ÚAF)r{ r2 r1 rb r s r% Úhas_transparency_datazImage.has_transparency_data« sZ € ð
|
|||
|
|
�I‰IÐ;Ñ ;Ø §¡Ñ*àØ �9‰9˜Ò Ø—<‘<Ð+Ð +Ð+Ø—<‘<×$Ñ$×-Ñ-¨cÓ2Ð 2Ør$ c ó† — | j dk7 sd| j vryddlm} | j d« }|€J ‚| j d }t |t « r t |« D ] \ }}|||dz dz < Œ n d ||dz dz < |j dt
|
|||
|
|
|« « | _ d| j _ | j d= y)
|
|||
|
|
zÉ
|
|||
|
|
If a P mode image has a "transparency" key in the info dictionary,
|
|||
|
|
remove the key and instead apply the transparency to the palette.
|
|||
|
|
Otherwise, the image is unchanged.
|
|||
|
|
r’ r» Nr rG r• r3 r2 r )
|
|||
|
|
r{ r2 ræ rd rn rÓ rÔ Ú enumerater1 r½ )r rd r1 r» rÐ Úalphas r% Úapply_transparencyzImage.apply_transparencyÁ sÅ € ð �9‰9˜Ò ˜~°T·Y±YÑ >Ø å"à—/‘/ &Ó)ˆØÐ"Ð"Ð"Ø—y‘y Ñ0ˆ Ü �l¤EÔ *Ü % lÓ 3ò
|
|||
|
|
+‘��5Ø%*�˜˜A™ ™ Ò"ñ
|
|||
|
|
+ð -.ˆG�L 1Ñ$ qÑ(Ñ )Ø0�|×0Ñ0°¼¸w» ÓHˆŒ Ø ˆ� ‰ Ôà �I‰I�nÑ %r$ c ój — | j « | j j t |« « S )a
|
|||
|
|
|
|||
|
|
Returns the pixel value at a given position.
|
|||
|
|
|
|||
|
|
:param xy: The coordinate, given as (x, y). See
|
|||
|
|
:ref:`coordinate-system`.
|
|||
|
|
:returns: The pixel value. If the image is a multi-layer image,
|
|||
|
|
this method returns a tuple.
|
|||
|
|
)rY r� rä rí )r Úxys r% rä zImage.getpixelÙ s& € ð
|
|||
|
|
� ‰ Œ Ø�w‰w× Ñ ¤ b£ Ó*Ð*r$ c óˆ — | j « | j j « \ }}t |« t |« fS )z¸
|
|||
|
|
Get projection to x and y axes
|
|||
|
|
|
|||
|
|
:returns: Two sequences, indicating where there are non-zero
|
|||
|
|
pixels along the X-axis and the Y-axis, respectively.
|
|||
|
|
)rY r� Ú
|
|||
|
|
getprojectionr5 )r rt Úys r% rk zImage.getprojectionè s6 € ð
|
|||
|
|
� ‰ Œ Ø�w‰w×$Ñ$Ó&‰ˆˆ1Ü�A‹wœ˜Q›Ð Ð r$ c óD — | j « |r6|j « | j j d|j « S | j dv r1| j j |�|« S | j « « S | j j « S )aÎ
|
|||
|
|
Returns a histogram for the image. The histogram is returned as a
|
|||
|
|
list of pixel counts, one for each pixel value in the source
|
|||
|
|
image. Counts are grouped into 256 bins for each band, even if
|
|||
|
|
the image has more than 8 bits per band. If the image has more
|
|||
|
|
than one band, the histograms for all bands are concatenated (for
|
|||
|
|
example, the histogram for an "RGB" image contains 768 values).
|
|||
|
|
|
|||
|
|
A bilevel image (mode "1") is treated as a grayscale ("L") image
|
|||
|
|
by this method.
|
|||
|
|
|
|||
|
|
If a mask is provided, the method returns a histogram for those
|
|||
|
|
parts of the image where the mask image is non-zero. The mask
|
|||
|
|
image must have the same size as the image, and be either a
|
|||
|
|
bi-level image (mode "1") or a grayscale image ("L").
|
|||
|
|
|
|||
|
|
:param mask: An optional mask.
|
|||
|
|
:param extrema: An optional tuple of manually-specified extrema.
|
|||
|
|
:returns: A list containing pixel counts.
|
|||
|
|
r- ©rŠ rˆ )rY r� r r{ r+ ©r ÚmaskÚextremas r% r zImage.histogramô sˆ € ð.
|
|||
|
|
� ‰ Œ Ù Ø �I‰IŒKØ—7‘7×$Ñ$ V¨T¯W©WÓ5Ð 5Ø �9‰9˜
|
|||
|
|
Ñ "Ø—7‘7×$Ñ$Ø"Ð.�óð
|
|||
|
|
Ø48·O±OÓ4Eóð
|
|||
|
|
ð �w‰w× Ñ Ó"Ð"r$ c óD — | j « |r6|j « | j j d|j « S | j dv r1| j j |�|« S | j « « S | j j « S )ah
|
|||
|
|
Calculates and returns the entropy for the image.
|
|||
|
|
|
|||
|
|
A bilevel image (mode "1") is treated as a grayscale ("L")
|
|||
|
|
image by this method.
|
|||
|
|
|
|||
|
|
If a mask is provided, the method employs the histogram for
|
|||
|
|
those parts of the image where the mask image is non-zero.
|
|||
|
|
The mask image must have the same size as the image, and be
|
|||
|
|
either a bi-level image (mode "1") or a grayscale image ("L").
|
|||
|
|
|
|||
|
|
:param mask: An optional mask.
|
|||
|
|
:param extrema: An optional tuple of manually-specified extrema.
|
|||
|
|
:returns: A float value representing the image entropy
|
|||
|
|
r- rn )rY r� Úentropyr{ r+ ro s r% rs z
|
|||
|
|
Image.entropy s‚ € ð$
|
|||
|
|
� ‰ Œ Ù Ø �I‰IŒKØ—7‘7—?‘? 6¨4¯7©7Ó3Ð 3Ø �9‰9˜
|
|||
|
|
Ñ "Ø—7‘7—?‘?Ø"Ð.�óð
|
|||
|
|
Ø48·O±OÓ4Eóð
|
|||
|
|
ð �w‰w�‰Ó Ð r$ c ó` — t |t « r|�
|
|||
|
|
d}t |« ‚|}d}|€d}t |« dk( r`t |t « r
|
|||
|
|
|j }n*t |t « r
|
|||
|
|
|j }n
|
|||
|
|
d}t |« ‚||d |d z |d |d z fz
|
|||
|
|
}t |t
|
|||
|
|
« r#ddlm} |j || j « }n€t |t « rn|j « | j |j k7 r8| j d k7 s|j d
|
|||
|
|
vr|j | j « }|j }n|}| j « |r8|j « | j j |||j « y| j j ||« y) aÌ
|
|||
|
|
Pastes another image into this image. The box argument is either
|
|||
|
|
a 2-tuple giving the upper left corner, a 4-tuple defining the
|
|||
|
|
left, upper, right, and lower pixel coordinate, or None (same as
|
|||
|
|
(0, 0)). See :ref:`coordinate-system`. If a 4-tuple is given, the size
|
|||
|
|
of the pasted image must match the size of the region.
|
|||
|
|
|
|||
|
|
If the modes don't match, the pasted image is converted to the mode of
|
|||
|
|
this image (see the :py:meth:`~PIL.Image.Image.convert` method for
|
|||
|
|
details).
|
|||
|
|
|
|||
|
|
Instead of an image, the source can be a integer or tuple
|
|||
|
|
containing pixel values. The method then fills the region
|
|||
|
|
with the given color. When creating RGB images, you can
|
|||
|
|
also use color strings as supported by the ImageColor module. See
|
|||
|
|
:ref:`colors` for more information.
|
|||
|
|
|
|||
|
|
If a mask is given, this method updates only the regions
|
|||
|
|
indicated by the mask. You can use either "1", "L", "LA", "RGBA"
|
|||
|
|
or "RGBa" images (if present, the alpha band is used as mask).
|
|||
|
|
Where the mask is 255, the given image is copied as is. Where
|
|||
|
|
the mask is 0, the current value is preserved. Intermediate
|
|||
|
|
values will mix the two images together, including their alpha
|
|||
|
|
channels if they have them.
|
|||
|
|
|
|||
|
|
See :py:meth:`~PIL.Image.Image.alpha_composite` if you want to
|
|||
|
|
combine images with respect to their alpha channels.
|
|||
|
|
|
|||
|
|
:param im: Source image or pixel value (integer, float or tuple).
|
|||
|
|
:param box: An optional 4-tuple giving the region to paste into.
|
|||
|
|
If a 2-tuple is used instead, it's treated as the upper left
|
|||
|
|
corner. If omitted or None, the source is pasted into the
|
|||
|
|
upper left corner.
|
|||
|
|
|
|||
|
|
If an image is given as the second argument and there is no
|
|||
|
|
third, the box defaults to (0, 0), and the second argument
|
|||
|
|
is interpreted as a mask image.
|
|||
|
|
:param mask: An optional mask image.
|
|||
|
|
Nz=If using second argument as mask, third argument must be Noner- r1 z,cannot determine region size; use 4-item boxr r ©Ú
|
|||
|
|
ImageColorr” )r� r• r– )rÓ rw rW r~ r< rá ræ rv rà r{ rY rã r� r\ Úpaste)r r� r rp rö r< rv Úsources r% rw z Image.paste1 sf € ô\ �cœ5Ô !ØÐ ØU�Ü “oÐ%àˆD؈Cà ˆ;؈Cä ˆs‹8�qŠ=ä˜"œeÔ$Ø—w‘w‘ܘD¤%Ô(Ø—y‘y‘ð E�Ü “oÐ%Ø �C˜‘F˜T !™WÑ$ c¨!¡f¨t°A©wÑ&6Ð7Ñ 7ˆCô �bœ#Ô Ý $à ×(Ñ(¨¨T¯Y©YÓ7‰FÜ
|
|||
|
|
˜œEÔ
|
|||
|
|
"Ø �G‰GŒIØ�y‰y˜BŸG™GÒ#Ø—9‘9 Ò%¨¯©Ð8NÑ)NàŸ™ D§I¡IÓ.�BØ—U‘U‰FàˆFà × Ñ Ô á Ø �I‰IŒKØ �G‰G�M‰M˜& # t§w¡wÕ /à �G‰G�M‰M˜& #Õ &r$ c óÌ — t |t t f« s
|
|||
|
|
d}t |« ‚t |t t f« s
|
|||
|
|
d}t |« ‚t |« dk( r t |« }n4t |« dk( rt |« |j
|
|||
|
|
z }n
|
|||
|
|
d}t |« ‚t |« dk( s
|
|||
|
|
d}t |« ‚t
|
|||
|
|
|« dk r
|
|||
|
|
d}t |« ‚|d |j
|
|||
|
|
z k( r|}n|j |« }t |« |d |j z |d
|
|||
|
|
|j z fz }|d | j
|
|||
|
|
z k( r| }n| j |« }t ||« } | j | |« y ) a- 'In-place' analog of Image.alpha_composite. Composites an image
|
|||
|
|
onto this image.
|
|||
|
|
|
|||
|
|
:param im: image to composite over this one
|
|||
|
|
:param dest: Optional 2 tuple (left, top) specifying the upper
|
|||
|
|
left corner in this (destination) image.
|
|||
|
|
:param source: Optional 2 (left, top) tuple for the upper left
|
|||
|
|
corner in the overlay source image, or 4 tuple (left, top, right,
|
|||
|
|
bottom) for the bounds of the source rectangle
|
|||
|
|
|
|||
|
|
Performance Note: Not currently implemented in-place in the core layer.
|
|||
|
|
z Source must be a list or tuplez#Destination must be a list or tupler3 r1 z*Source must be a sequence of length 2 or 4z*Destination must be a sequence of length 2r zSource must be non-negativer- r N) rÓ r5 rí rW r~ r< rÊ r r} r| Úalpha_compositerw )
|
|||
|
|
r r� Údestrx rö Úoverlay_crop_boxÚoverlayr Ú
|
|||
|
|
backgroundÚresults
|
|||
|
|
r% rz zImage.alpha_composite� sK € ô ˜&¤4¬ -Ô0Ø2ˆCÜ ˜S“/Ð !ܘ$¤¤u
|
|||
|
|
Ô.Ø7ˆCÜ ˜S“/Ð !ä ˆv‹;˜!Ò Ü $ V›}Ñ Ü
|
|||
|
|
�‹[˜AÒ
|
|||
|
|
Ü $ V›}¨r¯w©wÑ 6Ñ à>ˆCÜ ˜S“/Ð !ä�4‹y˜AŠ~Ø>ˆCÜ ˜S“/Ð !Ü ˆv‹;˜Š?Ø/ˆCÜ ˜S“/Ð !ð ˜v¨¯©Ñ /Ò /؉Gà—g‘gÐ .Ó/ˆGô �D‹k˜T !™W w§}¡}Ñ 4°d¸1±gÀÇÁÑ6NÐ OÑOˆð �&˜4Ÿ9™9Ñ$Ò $Ø ‰Jà Ÿ™ 3› ˆJä ¨WÓ5ˆØ �
|
|||
|
|
‰
|
|||
|
|
�6˜3Õ r$ c óV — | j « t |t « r|j | « S t |« r~| j
|
|||
|
|
dv r9t
|
|||
|
|
|« \ }}| j | j j ||« « S t d« D �cg c]
|
|||
|
|
} ||« ‘Œ c}| j j z }n|}| j
|
|||
|
|
dk( r
|
|||
|
|
d}t |« ‚|dk7 r|D �cg c]
|
|||
|
|
}t |« ‘Œ }}| j | j j ||« « S c c}w c c}w )aÇ
|
|||
|
|
Maps this image through a lookup table or function.
|
|||
|
|
|
|||
|
|
:param lut: A lookup table, containing 256 (or 65536 if
|
|||
|
|
self.mode=="I" and mode == "L") values per band in the
|
|||
|
|
image. A function can be used instead, it should take a
|
|||
|
|
single argument. The function is called once for each
|
|||
|
|
possible pixel value, and the resulting table is applied to
|
|||
|
|
all bands of the image.
|
|||
|
|
|
|||
|
|
It may also be an :py:class:`~PIL.Image.ImagePointHandler`
|
|||
|
|
object::
|
|||
|
|
|
|||
|
|
class Example(Image.ImagePointHandler):
|
|||
|
|
def point(self, im: Image) -> Image:
|
|||
|
|
# Return result
|
|||
|
|
:param mode: Output mode (default is same as input). This can only be used if
|
|||
|
|
the source image has mode "L" or "P", and the output has mode "1" or the
|
|||
|
|
source image mode is "I" and the output mode is "L".
|
|||
|
|
:returns: An :py:class:`~PIL.Image.Image` object.
|
|||
|
|
)rŠ r‹ rˆ rÆ rˆ z+point operation not supported for this mode)rY rÓ ÚImagePointHandlerÚpointr r{ r# rJ r� Úpoint_transformrÙ r rW r )r Úlutr{ r r rÐ ÚflatLutrö s r% r‚ z Image.pointÅ sö € ðB
|
|||
|
|
� ‰ Œ ä �cÔ,Ô -Ø—9‘9˜T“?Ð "ä �CŒ=à�y‰yÐ .Ñ.ô !0°Ó 4‘
|
|||
|
|
��vØ—y‘y §¡×!8Ñ!8¸ÀÓ!GÓHÐHä',¨S£zÖ2 !‘s˜1•vÒ2°T·W±W·]±]ÑB‰GàˆGà �9‰9˜Ò à?ˆCÜ ˜S“/Ð !à �3Š;Ø)0Ö1 A”u˜Q•xÐ1ˆGÐ1Ø�y‰y˜Ÿ™Ÿ ™ w°Ó5Ó6Ð6ùò 3ùò 2s ÂD!Ã"D&c ó’ — | j « | j dvrP t | j « dz } | j j |« | j j | _ | j dv rd}nd}t |t « rL|j d vr
|
|||
|
|
d}t
|
|||
|
|
|« ‚|j « |j d
|
|||
|
|
k( r0|j d « }n | j j ||« y| j j! |j |« y# t
|
|||
|
|
t f$ rI}| j j |« }|j dvrd}t
|
|||
|
|
|« |‚|| _ Y d}~�Œ"d}~ww xY w# t $ r}d}t
|
|||
|
|
|« |‚d}~ww xY w# t
|
|||
|
|
t f$ r t d | j |« }Y ŒÉw xY w) aZ
|
|||
|
|
Adds or replaces the alpha layer in this image. If the image
|
|||
|
|
does not have an alpha layer, it's converted to "LA" or "RGBA".
|
|||
|
|
The new layer must be either "L" or "1".
|
|||
|
|
|
|||
|
|
:param alpha: The new alpha layer. This can either be an "L" or "1"
|
|||
|
|
image having the same size as this image, or an integer.
|
|||
|
|
rÕ rb z alpha channel could not be addedNúillegal image moder¼ r r2 )r† rŽ r† rŽ )r\ r{ rœ r� Úsetmoderñ rW rã r/ rî rÓ rw rY ÚfillbandrI r< Úputband)r rf r{ râ r� rö r' s r% ÚputalphazImage.putalpha s‰ € ð
|
|||
|
|
× Ñ Ô à �9‰9Ð 0Ñ 0ð
|
|||
|
|
-Ü" 4§9¡9Ó-°Ñ3�ð!Ø—G‘G—O‘O DÔ)ð "ŸW™WŸ\™\�”
|
|||
|
|
ð
|
|||
|
|
�9‰9˜ Ñ $؉DàˆDä �eœUÔ #à�z‰z Ñ+Ø*�Ü “oÐ%Ø �J‰JŒLØ�z‰z˜SÒ Ø Ÿ
|
|||
|
|
™
|
|||
|
|
cÓ*‘ð
|
|||
|
|
Ø—‘× Ñ uÔ-ð
|
|||
|
|
à �‰�‰˜Ÿ™ $Õ'øôG '¬
|
|||
|
|
Ð3ò !à Ÿ™Ÿ ™ ¨Ó.�BØ—w‘wÐ&:Ñ:Ø @˜Ü (¨›o°1Ð4Ø �D—G’Gûð
|
|||
|
|
!ûô ò
|
|||
|
|
-Ø*�Ü “o¨1Ð,ûð
|
|||
|
|
-ûô* #¤JÐ/ò
|
|||
|
|
3ä˜C §¡¨EÓ2’ð
|
|||
|
|
3úsR E> ¹D# ÁE> Ã F Ä#E;Ä2>E6Å0E> Å6E;Å;E> Å> FÆFÆFÆ &GÇGc ó^ — | j « | j j |||« y)a½
|
|||
|
|
Copies pixel data from a flattened sequence object into the image. The
|
|||
|
|
values should start at the upper left corner (0, 0), continue to the
|
|||
|
|
end of the line, followed directly by the first value of the second
|
|||
|
|
line, and so on. Data will be read until either the image or the
|
|||
|
|
sequence ends. The scale and offset values are used to adjust the
|
|||
|
|
sequence values: **pixel = value*scale + offset**.
|
|||
|
|
|
|||
|
|
:param data: A flattened sequence object. See :ref:`colors` for more
|
|||
|
|
information about values.
|
|||
|
|
:param scale: An optional scale value. The default is 1.0.
|
|||
|
|
:param offset: An optional offset value. The default is 0.0.
|
|||
|
|
N)r\ r� Úputdata)r r‘ r r s r% r� z
|
|||
|
|
Image.putdata8 s$ € ð(
|
|||
|
|
× Ñ Ô à �‰�‰˜˜e VÕ,r$ c óp — ddl m} | j dvr
|
|||
|
|
d}t |« ‚t ||j « rY|j
|
|||
|
|
�( |j |j
|
|||
|
|
|j « }nS |j |j ¬« }d|_ n.t |t « s t |« } |j ||« }d| j v rdnd | _
|
|||
|
|
|| _ |j d
|
|||
|
|
« rd
|
|||
|
|
| j _ n'd|v rd | j _ nd | j _ | j « y)
|
|||
|
|
a~
|
|||
|
|
Attaches a palette to this image. The image must be a "P", "PA", "L"
|
|||
|
|
or "LA" image.
|
|||
|
|
|
|||
|
|
The palette sequence must contain at most 256 colors, made up of one
|
|||
|
|
integer value for each channel in the raw mode.
|
|||
|
|
For example, if the raw mode is "RGB", then it can contain at most 768
|
|||
|
|
values, made up of red, green and blue values for the corresponding pixel
|
|||
|
|
index in the 256 colors.
|
|||
|
|
If the raw mode is "RGBA", then it can contain at most 1024 values,
|
|||
|
|
containing red, green, blue and alpha values.
|
|||
|
|
|
|||
|
|
Alternatively, an 8-bit string may be used instead of an integer sequence.
|
|||
|
|
|
|||
|
|
:param data: A palette sequence (either a list or a string).
|
|||
|
|
:param rawmode: The raw mode of the palette. Either "RGB", "RGBA", "CMYK", or a
|
|||
|
|
mode that can be transformed to one of those modes (e.g. "R", "RGBA;L").
|
|||
|
|
r rG r� r‡ N©r1 rb r“ r’ r‡ r• r” )
|
|||
|
|
ræ rd r{ rW rÓ r¾ r� r1 r½ rÔ r/ Ú
|
|||
|
|
startswithrY )r r‘ r¾ rd rö r1 s r% rž zImage.putpaletteP sú € õ. #à �9‰9Ð 2Ñ 2Ø&ˆCÜ ˜S“/Ð !Ü �d˜L× 5Ñ 5Ô 6Ø�|‰|Ð'Ø*˜,×*Ñ*¨4¯<©<¸¿ ¹ ÓF‘à3˜,×3Ñ3¸D¿L¹LÔI�Ø !�•
|
|||
|
|
ä ˜d¤EÔ*Ü ˜T“{�Ø&�l×&Ñ& w°Ó5ˆGØ D§I¡IÑ -‘T°3ˆŒ
|
|||
|
|
Ø ˆŒ Ø × Ñ ˜fÔ %Ø &ˆD�L‰LÕ Ø
|
|||
|
|
�G‰^Ø &ˆD�L‰LÕ à %ˆD�L‰LÔ Ø � ‰ � r$ c óž — | j « | j dv r”t |t t f« r~t |« dv rq| j dk( rt |« dk( r|d nd}|dd }| j €J ‚| j j t |« | « }| j dk( r|fn|}| j j ||« S )aý
|
|||
|
|
Modifies the pixel at the given position. The color is given as
|
|||
|
|
a single numerical value for single-band images, and a tuple for
|
|||
|
|
multi-band images. In addition to this, RGB and RGBA tuples are
|
|||
|
|
accepted for P and PA images. See :ref:`colors` for more information.
|
|||
|
|
|
|||
|
|
Note that this method is relatively slow. For more extensive changes,
|
|||
|
|
use :py:meth:`~PIL.Image.Image.paste` or the :py:mod:`~PIL.ImageDraw`
|
|||
|
|
module instead.
|
|||
|
|
|
|||
|
|
See:
|
|||
|
|
|
|||
|
|
* :py:meth:`~PIL.Image.Image.paste`
|
|||
|
|
* :py:meth:`~PIL.Image.Image.putdata`
|
|||
|
|
* :py:mod:`~PIL.ImageDraw`
|
|||
|
|
|
|||
|
|
:param xy: The pixel coordinate, given as (x, y). See
|
|||
|
|
:ref:`coordinate-system`.
|
|||
|
|
:param value: The pixel value.
|
|||
|
|
rF )r2 r3 r“ r3 r2 rÉ N)
|
|||
|
|
r\ r{ rÓ r5 rí r~ r1 rà r� râ )r ri rÌ rf Ú
|
|||
|
|
palette_indexs r% râ zImage.putpixel€ s¾ € ð0
|
|||
|
|
× Ñ Ô ð
|
|||
|
|
�I‰I˜Ñ $ܘ5¤4¬ -Ô0Ü�E“
|
|||
|
|
˜fÑ$ð �y‰y˜DÒ Ü$'¨£J°!¢O˜˜aš¸�Ø ˜b˜q˜ �Ø—<‘<Ð+Ð +Ð+Ø ŸL™L× 1Ñ 1´%¸³,ÀÓ EˆMØ.2¯i©i¸4Ò.?�] EÑ*À]ˆEØ�w‰w× Ñ EÓ*Ð*r$ c óþ — ddl m} | j dvr
|
|||
|
|
d}t |« ‚d}d}|€y| j dk( rN| j « | j
|
|||
|
|
j
|
|||
|
|
« }|dk( rd }| j
|
|||
|
|
j ||« }n.t d
|
|||
|
|
„ t d « D « « }nt |« d kD rd }d}d }d
|
|||
|
|
gdz }t |« D ] \ } }
|
|||
|
|
|||
|
|||
|
|
|z |
|
|||
|
|
|z |z z
|
|||
|
|
}| ||
|
|||
|
|
< Œ t |« } | j « } d| _
|
|||
|
|
|j || |z ¬« | _ | j
|
|||
|
|
j ||dz | j j! « « | j# d« } | j ||« |j ||¬« | _ d| j$ v r. |j' | j$ d « | j$ d< | S | S # t $ r d| j$ v r
|
|||
|
|
| j$ d= Y | S w xY w)ae
|
|||
|
|
Rewrites the image to reorder the palette.
|
|||
|
|
|
|||
|
|
:param dest_map: A list of indexes into the original palette.
|
|||
|
|
e.g. ``[1,0]`` would swap a two item palette, and ``list(range(256))``
|
|||
|
|
is the identity transform.
|
|||
|
|
:param source_palette: Bytes or None.
|
|||
|
|
:returns: An :py:class:`~PIL.Image.Image` object.
|
|||
|
|
|
|||
|
|
r rG )rŽ r’ r‡ r2 r” r’ r• r3 c 3 ó& K — | ] }|d z –— Œ yw)r2 Nr# ©rÏ rÐ s r% rÒ z&Image.remap_palette.<locals>.<genexpr>Å s è ø€ Ò*F°a¨1°6Ñ*Fùs ‚i r$ r rÆ r� z;LrŽ r» )ræ rd r{ rW rY r� rû rn Ú bytearrayrÙ r~ re rH r/ r1 rž ro rã r2 Úindex)
|
|||
|
|
r Údest_mapÚsource_paletterd rö r Ú palette_modeÚ
|
|||
|
|
palette_bytesÚ
|
|||
|
|
new_positionsrÐ Ú oldPositionÚmapping_paletteÚm_ims
|
|||
|
|
r% Ú
|
|||
|
|
remap_palettezImage.remap_palette¨ s € õ #à �9‰9˜JÑ &Ø&ˆCÜ ˜S“/Ð !àˆØ ˆ Ø Ð !Ø�y‰y˜CÒ Ø— ‘ ” Ø #Ÿw™w× 5Ñ 5Ó 7� Ø 6Ò)Ø �EØ!%§¡×!3Ñ!3°LÀ,Ó!O‘ä!*Ñ*F¼5À»:Ô*FÓ!F‘Ü
|
|||
|
|
� Ó
|
|||
|
|
3Ò
|
|||
|
|
&؈EØ!ˆLàˆ
|
|||
|
|
ؘ˜c™ ˆ
|
|||
|
|
ô (¨Ó 1ò +‰NˆAˆ{Ø ˜^ؘeÑ# k°EÑ&9¸EÑ&Að ñ
|
|||
|
|
ˆMð *+ˆM˜+Ò &ð +ô0 $ MÓ2ˆà�y‰y‹{ˆØˆŒ
|
|||
|
|
à0�|×0Ñ0Ø /°EÑ"9ô
|
|||
|
|
ˆŒ ð
|
|||
|
|
�‰×ј<¨ ¸Ñ)<¸d¿l¹l×>RÑ>RÓ>TÔUà�|‰|˜CÓ ˆà �‰˜
|
|||
|
|
|Ô4Ø0�|×0Ñ0° À}ÔUˆŒ à ˜TŸY™YÑ &ð
|
|||
|
|
2Ø,4¯N©N¸4¿9¹9À^Ñ;TÓ,U�— ‘ ˜.Ñ)ð
|
|||
|
|
ˆ ˆtˆ øô ò
|
|||
|
|
2Ø! T§Y¡YÑ.Ø Ÿ ™ .Ð1øàˆ ð
|
|||
|
|
2ús Æ%+G Ç$G<Ç;G<c
|
|||
|
|
ó¢ — t | dz
|
|||
|
|
}|d |d z
|
|||
|
|
|d z }|d |d z
|
|||
|
|
|d z }||z }||z }t dt |d |z
|
|||
|
|
« « t dt |d |z
|
|||
|
|
« « t | j d t j |d |z « « t | j d t j |d |z « « fS )z€Expands the box so it includes adjacent pixels
|
|||
|
|
that may be used by resampling with the given resampling filter.
|
|||
|
|
rL r1 r r2 r )Ú_filters_supportr¥ r¿ rÊ r< ÚmathÚceil) r r< Úresampler Úfilter_supportÚscale_xÚscale_yÚ support_xÚ support_ys r% Ú
|
|||
|
|
_get_safe_boxzImage._get_safe_box sß € ô *¨(Ñ3°cÑ9ˆØ�q‘6˜C ™F‘? d¨1¡gÑ-ˆØ�q‘6˜C ™F‘? d¨1¡gÑ-ˆØ" WÑ,ˆ Ø" WÑ,ˆ ô
|
|||
|
|
�”3�s˜1‘v Ñ)Ó*Ó +Ü �”3�s˜1‘v Ñ)Ó*Ó +Ü �— ‘ ˜!‘ œdŸi™i¨¨A©°Ñ(:Ó ;Ó <Ü �— ‘ ˜!‘ œdŸi™i¨¨A©°Ñ(:Ó ;Ó <ð
|
|||
|
|
ð
|
|||
|
|
r$ c óâ — |€t j }�n|t j t j t j t j t j
|
|||
|
|
t j fvr²d|› d�}t j dft j dft j dft j dft j
|
|||
|
|
dft j d ffD �cg c] }|d
|
|||
|
|
› d |d › d
|
|||
|
|
�‘Œ }}|ddj |dd « › d|d › �z
|
|||
|
|
}t |« ‚|�|dk r
|
|||
|
|
d}t |« ‚|€d| j z }t |« }| j |k( r"|d| j z k( r| j « S | j dv rt j }| j dv rb|t j k7 rO| j dddœ| j « }|j |||« }|j | j « S | j « |�ú|t j k7 rçt! |d |d z
|
|||
|
|
|d z |z « xs d
|
|||
|
|
} t! |d |d
|
|||
|
|
z
|
|||
|
|
|d
|
|||
|
|
z |z « xs d
|
|||
|
|
}
|
|||
|
|
| d
|
|||
|
|
kD s|
|
|||
|
|
d
|
|||
|
|
kD r›| j# |t% t |« |« } | |
|
|||
|
|
f} t' | j( « r| j) | | ¬« nt* j) | | | ¬« } |d | d z
|
|||
|
|
| z |d
|
|||
|
|
| d
|
|||
|
|
z
|
|||
|
|
|
|
|||
|
|
z |d | d z
|
|||
|
|
| z |d | d
|
|||
|
|
z
|
|||
|
|
|
|
|||
|
|
z f}| j d
|
|||
|
|
| j d d z kD r||d
|
|||
|
|
| j d
|
|||
|
|
k rg| j, j | j d |d
|
|||
|
|
f|d |d
|
|||
|
|
| j d |d f« }|j |||d d |d |d
|
|||
|
|
f« }n | j, j |||« }| j/ |« S c c}w ) aÃ
|
|||
|
|
Returns a resized copy of this image.
|
|||
|
|
|
|||
|
|
:param size: The requested size in pixels, as a tuple or array:
|
|||
|
|
(width, height).
|
|||
|
|
:param resample: An optional resampling filter. This can be
|
|||
|
|
one of :py:data:`Resampling.NEAREST`, :py:data:`Resampling.BOX`,
|
|||
|
|
:py:data:`Resampling.BILINEAR`, :py:data:`Resampling.HAMMING`,
|
|||
|
|
:py:data:`Resampling.BICUBIC` or :py:data:`Resampling.LANCZOS`.
|
|||
|
|
If the image has mode "1" or "P", it is always set to
|
|||
|
|
:py:data:`Resampling.NEAREST`. Otherwise, the default filter is
|
|||
|
|
:py:data:`Resampling.BICUBIC`. See: :ref:`concept-filters`.
|
|||
|
|
:param box: An optional 4-tuple of floats providing
|
|||
|
|
the source image region to be scaled.
|
|||
|
|
The values must be within (0, 0, width, height) rectangle.
|
|||
|
|
If omitted or None, the entire source is used.
|
|||
|
|
:param reducing_gap: Apply optimization by resizing the image
|
|||
|
|
in two steps. First, reducing the image by integer times
|
|||
|
|
using :py:meth:`~PIL.Image.Image.reduce`.
|
|||
|
|
Second, resizing using regular resampling. The last step
|
|||
|
|
changes size no less than by ``reducing_gap`` times.
|
|||
|
|
``reducing_gap`` may be None (no first step is performed)
|
|||
|
|
or should be greater than 1.0. The bigger ``reducing_gap``,
|
|||
|
|
the closer the result to the fair resampling.
|
|||
|
|
The smaller ``reducing_gap``, the faster resizing.
|
|||
|
|
With ``reducing_gap`` greater or equal to 3.0, the result is
|
|||
|
|
indistinguishable from fair resampling in most cases.
|
|||
|
|
The default value is None (no optimization).
|
|||
|
|
:returns: An :py:class:`~PIL.Image.Image` object.
|
|||
|
|
NúUnknown resampling filter (ú).úImage.Resampling.NEARESTúImage.Resampling.LANCZOSúImage.Resampling.BILINEARúImage.Resampling.BICUBICúImage.Resampling.BOXúImage.Resampling.HAMMINGr ú (r ú)ú Use ú, éÿÿÿÿú or rM z#reducing_gap must be 1.0 or greaterr- ©r† r’ rÓ r� r– r1 r2 )r éd )rE rJ rF rH rK rG rI rª rW r< rí rH r{ rã ÚresizerY r¿ r« r r Úreducerw r� rJ )
|
|||
|
|
r r< r¥ r Ú reducing_gaprö r Úfiltersr� Úfactor_xÚfactor_yÚ
|
|||
|
|
reduce_boxÚfactors
|
|||
|
|
r% r½ z Image.resize sû € ðL Ð Ü!×)Ñ)ŠHØ
|
|||
|
|
Ü × Ñ Ü × Ñ Ü × Ñ Ü × Ñ Ü �N‰NÜ × Ñ ð
|
|||
|
|
|
|||
|
|
ñ
|
|||
|
|
ð 0°¨z¸Ð<ˆCô
|
|||
|
|
×'Ñ'Ð)CÐDÜ ×'Ñ'Ð)CÐDÜ ×(Ñ(Ð*EÐFÜ ×'Ñ'Ð)CÐDÜ —^‘^Ð%;Ð<Ü ×'Ñ'Ð)CÐDð
|
|||
|
|
ö
|
|||
|
|
àð ˜!‘9�+˜R q¡ ˜{¨!Ò,ð
|
|||
|
|
ˆGð
|
|||
|
|
ð
|
|||
|
|
�U˜4Ÿ9™9 W¨S¨b \Ó2Ð3°4¸À¹ °}ÐEÑ EˆCÜ ˜S“/Ð !à Ð #¨ °sÒ(:Ø7ˆCÜ ˜S“/Ð !à ˆ;ؘ4Ÿ9™9Ñ$ˆCä�T‹{ˆØ �9‰9˜Ò ¨°·±Ñ(:Ò!:Ø—9‘9“;Ð à �9‰9˜
|
|||
|
|
Ñ "Ü!×)Ñ)ˆHà �9‰9˜Ñ &¨8´z×7IÑ7IÒ+IØ— ‘ T°6Ñ :¸4¿9¹9Ñ EÓFˆBØ—‘˜4 ¨3Ó/ˆBØ—:‘:˜dŸi™iÓ(Ð (à � ‰ Œ à Ð #¨´J×4FÑ4FÒ(FܘC ™F S¨¡V™O¨t°A©wÑ6¸ ÑEÓFÒKÈ!ˆHܘC ™F S¨¡V™O¨t°A©wÑ6¸ ÑEÓFÒKÈ!ˆHؘ!Š|˜x¨!š|Ø !× /Ñ /°´d¼:ÀxÓ6PÐRUÓ V�
|
|||
|
|
Ø" HÐ-�ô § ¡ Ô,ð —K‘K ¨J�KÔ7ä Ÿ ™ d¨F¸
|
|||
|
|
˜ ÓCð 𠘑V˜j¨™mÑ+¨xÑ7ؘ‘V˜j¨™mÑ+¨xÑ7ؘ‘V˜j¨™mÑ+¨xÑ7ؘ‘V˜j¨™mÑ+¨xÑ7ð �ð �9‰9�Q‰<˜$Ÿ)™) A™,¨Ñ,Ò ,°°a±¸4¿9¹9ÀQ¹<Ò1GØ—‘— ‘ Ø—‘˜1‘ ˜t A™wÐ'¨°A°s¸1±v¸t¿y¹yȹ|ÈSÐQRÉVÐ3TóˆBð —‘˜4 ¨C°©F°A°s¸1±v¸tÀA¹wÐ+GÓH‰Bà—‘— ‘ h°Ó4ˆBØ�y‰y˜‹}Ð ùòy
|
|||
|
|
s Ã#O,c óÔ — t |t t f« s||f}|€d| j z }|dk( r"|d| j z k( r| j « S | j
|
|||
|
|
dv rN| j
|
|||
|
|
dddœ| j
|
|||
|
|
« }|j ||« }|j
|
|||
|
|
| j
|
|||
|
|
« S | j « | j | j j ||« « S )a!
|
|||
|
|
Returns a copy of the image reduced ``factor`` times.
|
|||
|
|
If the size of the image is not dividable by ``factor``,
|
|||
|
|
the resulting size will be rounded up.
|
|||
|
|
|
|||
|
|
:param factor: A greater than 0 integer or tuple of two integers
|
|||
|
|
for width and height separately.
|
|||
|
|
:param box: An optional 4-tuple of ints providing
|
|||
|
|
the source image region to be reduced.
|
|||
|
|
The values must be within ``(0, 0, width, height)`` rectangle.
|
|||
|
|
If omitted or ``None``, the entire source is used.
|
|||
|
|
r- rÔ rÓ r� r– ) rÓ r5 rí r< rH r{ rã r¾ rY rJ r� )r rÄ r r� s r% r¾ z Image.reduceˆ sÅ € ô" ˜&¤4¬ -Ô0Ø ˜fÐ%ˆFà ˆ;ؘ4Ÿ9™9Ñ$ˆCà �VÒ v°· ± Ñ'9Ò 9Ø—9‘9“;Ð à �9‰9˜Ñ &Ø— ‘ T°6Ñ :¸4¿9¹9Ñ EÓFˆBØ—‘˜6 3Ó'ˆBØ—:‘:˜dŸi™iÓ(Ð (à � ‰ Œ à�y‰y˜Ÿ™Ÿ ™ ¨°Ó4Ó5Ð5r$ Fc óP — |dz }|s’|s�|dk( r| j « S |dk( r | j t j « S |dv rS|s| j | j
|
|||
|
|
k( r8| j |dk( rt j « S t j « S | j \ }}|€d} n|} |€
|
|||
|
|
|dz |dz f}t j |« }t t j |« d« t t j |« d« d t t j |« d« t t j |« d« d g}
|
|||
|
|
dd
|
|||
|
|
„} | |d | d z
|
|||
|
|
|d | d z
|
|||
|
|
|
|
|||
|
|
« \ |
|
|||
|
|
d< |
|
|||
|
|
d < |
|
|||
|
|
dxx |d z
|
|||
|
|
cc< |
|
|||
|
|
d xx |d z
|
|||
|
|
cc< |ræg } g }
|
|||
|
|
d|df||fd|ffD ]4 \ }} | |||
|
|||
|
|
« \ }}| j |« |
|
|||
|
|
j |« Œ6 t j t! | « « t j" t% | « « z
|
|||
|
|
}t j t! |
|
|||
|
|
« « t j" t% |
|
|||
|
|
« « z
|
|||
|
|
} | ||z
|
|||
|
|
d
|
|||
|
|
z ||z
|
|||
|
|
d
|
|||
|
|
z |
|
|||
|
|
« \ |
|
|||
|
|
d< |
|
|||
|
|
d < ||}}| j' ||ft( j* |
|
|||
|
|
||¬« S )a�
|
|||
|
|
Returns a rotated copy of this image. This method returns a
|
|||
|
|
copy of this image, rotated the given number of degrees counter
|
|||
|
|
clockwise around its centre.
|
|||
|
|
|
|||
|
|
:param angle: In degrees counter clockwise.
|
|||
|
|
:param resample: An optional resampling filter. This can be
|
|||
|
|
one of :py:data:`Resampling.NEAREST` (use nearest neighbour),
|
|||
|
|
:py:data:`Resampling.BILINEAR` (linear interpolation in a 2x2
|
|||
|
|
environment), or :py:data:`Resampling.BICUBIC` (cubic spline
|
|||
|
|
interpolation in a 4x4 environment). If omitted, or if the image has
|
|||
|
|
mode "1" or "P", it is set to :py:data:`Resampling.NEAREST`.
|
|||
|
|
See :ref:`concept-filters`.
|
|||
|
|
:param expand: Optional expansion flag. If true, expands the output
|
|||
|
|
image to make it large enough to hold the entire rotated image.
|
|||
|
|
If false or omitted, make the output image the same size as the
|
|||
|
|
input image. Note that the expand flag assumes rotation around
|
|||
|
|
the center and no translation.
|
|||
|
|
:param center: Optional center of rotation (a 2-tuple). Origin is
|
|||
|
|
the upper left corner. Default is the center of the image.
|
|||
|
|
:param translate: An optional post-rotate translation (a 2-tuple).
|
|||
|
|
:param fillcolor: An optional color for area outside the rotated image.
|
|||
|
|
:returns: An :py:class:`~PIL.Image.Image` object.
|
|||
|
|
g €v@r é´ )éZ i rÈ r- r1 é ç c óL — |\ }}}}}}|| z ||z z |z || z ||z z |z fS r r# ) rt rl rÑ r" r„ r r¸ râ rh s r% rø z Image.rotate.<locals>.transform
|
|||
|
|
sA € Ø %Ñ ˆAˆq�!�Q˜˜1Ø�q‘5˜1˜q™5‘= 1Ñ$ a¨!¡e¨a°!©e¡m°aÑ&7Ð7Ð 7r$ r r4 rN )Ú fillcolor)rt r rl r rÑ z list[float]r útuple[float, float])rH Ú transposer0 r9 r} r| r8 r: r< r£ Úradiansr ÚcosÚsinr¨ r¤ r¥ ÚfloorrÊ rø r> r? )r Úangler¥ ÚexpandÚcenterÚ translaterÌ Úwr! Ú
|
|||
|
|
post_transrÑ rø ÚxxÚyyrt rl Ú
|
|||
|
|
transformed_xÚ
|
|||
|
|
transformed_yÚnwÚnhs r% Úrotatez Image.rotate« s¦ € ðD ˜‘
|
|||
|
|
ˆñ ™)ؘŠzØ—y‘y“{Ð"ؘŠ|Ø—~‘~¤i×&:Ñ&:Ó;Ð;ؘ Ñ!¡v°·±¸t¿{¹{Ò1JØ—~‘~Ø+0°Bª;”I×'Ñ'óð Ü<E×<PÑ<Póð ð, �y‰y‰ˆˆ1à Ð Ø ‰Jà"ˆJØ ˆ>ؘ!‘e˜Q ™U�^ˆFä— ‘ ˜eÓ$Ð$ˆä ”$—(‘(˜5“/ 2Ó &Ü ”$—(‘(˜5“/ 2Ó &Ø Ü ”4—8‘8˜E“?Ð" BÓ 'Ü ”$—(‘(˜5“/ 2Ó &Ø ð
|
|||
|
|
|
|||
|
|
ˆó 8ñ )Ø
|
|||
|
|
�A‰YˆJ˜ A™ Ñ &¨°©¨
|
|||
|
|
°ZÀ±]Ñ(BÀFó
|
|||
|
|
Ñ ˆˆq‰ �6˜!‘9ð ˆq‹ �V˜A‘YÑ ‹ ؈q‹ �V˜A‘YÑ ‹ á àˆB؈BØ ! Q ¨!¨Q¨°!°Q°Ð8ò
|
|||
|
|
)‘��1Ù/8¸¸A¸vÓ/FÑ,�
|
|||
|
|
˜}Ø— ‘ ˜-Ô(Ø— ‘ ˜-Õ(ð
|
|||
|
|
)ô —‘œ3˜r›7Ó#¤d§j¡j´°R³Ó&9Ñ9ˆBÜ—‘œ3˜r›7Ó#¤d§j¡j´°R³Ó&9Ñ9ˆBñ
|
|||
|
|
$-¨r°A©v¨Y¸©_ÀÀQÁ¸iÈ#¹oÈvÓ#VÑ ˆF�1‰I�v˜a‘yØ�rˆqˆAà�~‰~Ø
|
|||
|
|
�ˆF”I×$Ñ$ f¨hÀ)ð ó
|
|||
|
|
ð
|
|||
|
|
r$ c ó — d}d}t |« rt j |« }d}n.|t j k( r t j j
|
|||
|
|
}|s@t |d« r4t |j « r t j |j « }|r t « nƒt j j |« d j « }t |t « r|j « n|}t! |« s
|
|||
|
|
t « |t" vr
|
|||
|
|
t% « t" | }ddlm}
|
|||
|
|
t | |
|
|||
|
|
j, « rZt j j/ |« t j j/ | j0 « k( r| j3 « n| j5 « |j7 d d« } || _ t; | d
|
|||
|
|
i « } | j= | « d | _ |jA « tB vr
|
|||
|
|
t% « | s)| €?|jE d « r.|jA « tF v rtF |jA « }
|
|||
|
|
ntB |jA « }
|
|||
|
|
d}|r`t j jI |« }|jE d
|
|||
|
|
d« rtK jL |d« }n.tK jL |d« }ntO tP t |« } |
|
|||
|
|
| ||« | | _- |r|jU « yy# t $ r Y �Œ¾w xY w# t& $ r}d|› �} t) | « |‚d}~ww xY w# tR $ r< |r|jU « |r& t jV |« ‚ # tX $ r Y ‚ w xY w‚ w xY w# | | _- w xY w)aþ
|
|||
|
|
Saves this image under the given filename. If no format is
|
|||
|
|
specified, the format to use is determined from the filename
|
|||
|
|
extension, if possible.
|
|||
|
|
|
|||
|
|
Keyword options can be used to provide additional instructions
|
|||
|
|
to the writer. If a writer doesn't recognise an option, it is
|
|||
|
|
silently ignored. The available options are described in the
|
|||
|
|
:doc:`image format documentation
|
|||
|
|
<../handbook/image-file-formats>` for each writer.
|
|||
|
|
|
|||
|
|
You can use a file object instead of a filename. In this case,
|
|||
|
|
you must always specify the format. The file object must
|
|||
|
|
implement the ``seek``, ``tell``, and ``write``
|
|||
|
|
methods, and be opened in binary mode.
|
|||
|
|
|
|||
|
|
:param fp: A filename (string), os.PathLike object or file object.
|
|||
|
|
:param format: Optional format override. If omitted, the
|
|||
|
|
format to use is determined from the filename extension.
|
|||
|
|
If a file object was used instead of a filename, this
|
|||
|
|
parameter should always be used.
|
|||
|
|
:param params: Extra parameters to the image writer. These can also be
|
|||
|
|
set on the image itself through ``encoderinfo``. This is useful when
|
|||
|
|
saving multiple images::
|
|||
|
|
|
|||
|
|
# Saving XMP data to a single image
|
|||
|
|
from PIL import Image
|
|||
|
|
red = Image.new("RGB", (1, 1), "#f00")
|
|||
|
|
red.save("out.mpo", xmp=b"test")
|
|||
|
|
|
|||
|
|
# Saving XMP data to the second frame of an image
|
|||
|
|
from PIL import Image
|
|||
|
|
black = Image.new("RGB", (1, 1))
|
|||
|
|
red = Image.new("RGB", (1, 1), "#f00")
|
|||
|
|
red.encoderinfo = {"xmp": b"test"}
|
|||
|
|
black.save("out.mpo", save_all=True, append_images=[red])
|
|||
|
|
:returns: None
|
|||
|
|
:exception ValueError: If the output format could not be determined
|
|||
|
|
from the file name. Use the format option to solve this.
|
|||
|
|
:exception OSError: If the file could not be written. The file
|
|||
|
|
may have been created, and may contain partial data.
|
|||
|
|
ræ FTr´ r zunknown file extension: Nr£ Úsave_allÚ encoderinfor# Ú
|
|||
|
|
append_imagesr¨ zr+bzw+b).r ra ÚfspathrS ÚstdoutÚbufferrñ rU r´ rç ÚpathÚsplitextrÖ rÓ rÔ rÕ rã rq ré rî rW ræ rb Úabspathri r\ rY ÚpopÚ_default_encoderinforï Ú_attach_default_encoderinfoÚ
|
|||
|
|
encoderconfigÚupperro r× rp ÚexistsÚbuiltinsÚopenr r r€ rV ÚremoveÚPermissionErrorrâ )r rM r* Úparamsri Úopen_fpÚ filename_extrà râ rö rb rá râ Ú save_handlerÚcreateds r% rd z
|
|||
|
|
Image.save
|
|||
|
|
sö € ð\ !#ˆØˆÜ �2Œ;Ü—y‘y “}ˆH؉GØ
|
|||
|
|
”3—:‘:Ò
|
|||
|
|
ð
|
|||
|
|
Ü—Z‘Z×&Ñ&�ñ œG B¨Ô /´G¸B¿G¹GÔ4Dä—y‘y §¡Ó)ˆHá Ü �Iä Ÿ7™7×+Ñ+¨HÓ5°aÑ8×>Ñ>Ó@ˆLô ˜l¬EÔ2ð ×#Ñ#Ô%à!ð
|
|||
|
|
ô 0°Ô4Ü” àœ)Ñ#Ü”ð
|
|||
|
|
-Ü" 3™ �õ
|
|||
|
|
ô �d˜I× /Ñ /Ô 0´R·W±W·_±_Ø ó6
|
|||
|
|
ä
|
|||
|
|
�W‰W�_‰_˜TŸ]™]Ó
|
|||
|
|
+ò6,ð
|
|||
|
|
× Ñ Õ "à �I‰IŒKà—:‘:˜j¨$Ó/ˆØ$*ˆÔ!Ü ˜d M°2Ó6ˆ Ø ×(Ñ(¨Ô.Ø.0ˆÔà �<‰<‹>¤Ñ %Ü ŒFÙ Ø Ð Ø—
|
|||
|
|
‘
|
|||
|
|
˜?Ô+Ø— ‘ “¤(Ñ*ä# F§L¡L£NÑ3‰Lä § ¡ £Ñ/ˆLàˆÙ Ü Ÿ'™'Ÿ.™.¨Ó2Ð2ˆGØ�z‰z˜( EÔ*ô —]‘] 8¨UÓ3‘ä —]‘] 8¨UÓ3‘ä”bœ‘i Ó$ˆBð +Ù ˜˜r 8Õ ,ð +ˆDÔ Ù Ø �H‰H�Jð øôa "ò
|
|||
|
|
Úð
|
|||
|
|
ûô0 ò
|
|||
|
|
-Ø0°°Ð6�Ü “o¨1Ð,ûð
|
|||
|
|
-ûôZ ò ÙØ—‘”
|
|||
|
|
ÙðÜ—I‘I˜hÔ'ð
|
|||
|
|
øô 'ò ØØ ðúà ð ûð +ˆDÕ úse ¼L Ä L Ë"
|
|||
|
|
L: Ì LÌLÌ L7Ì!L2Ì2L7Ì: M?ÍM.Í-M?Í. M:Í7M?Í9M:Í:M?Í?N Î N c óJ — t | di « }i |j ¥|¥| _ |S )Nrâ )rï rë râ )r r� râ s r% rì z!Image._attach_default_encoderinfo¨
|
|||
|
|
s. € Ü ˜d M°2Ó6ˆ ØE˜b× 5Ñ 5ÐE¸ÐEˆÔØÐr$ c ó( — |dk7 r
|
|||
|
|
d}t |« ‚y)a0
|
|||
|
|
Seeks to the given frame in this sequence file. If you seek
|
|||
|
|
beyond the end of the sequence, the method raises an
|
|||
|
|
``EOFError`` exception. When a sequence file is opened, the
|
|||
|
|
library automatically seeks to frame 0.
|
|||
|
|
|
|||
|
|
See :py:meth:`~PIL.Image.Image.tell`.
|
|||
|
|
|
|||
|
|
If defined, :attr:`~PIL.Image.Image.n_frames` refers to the
|
|||
|
|
number of available frames.
|
|||
|
|
|
|||
|
|
:param frame: Frame number, starting at 0.
|
|||
|
|
:exception EOFError: If the call attempts to seek beyond the end
|
|||
|
|
of the sequence.
|
|||
|
|
r zno more images in fileN)ÚEOFError)r Úframerö s r% Úseekz
|
|||
|
|
Image.seek
|
|||
|
|
s € ð$ �AŠ:Ø*ˆCܘ3“-Ð ð r$ c ó4 — ddl m} |j | |« y)aï
|
|||
|
|
Displays this image. This method is mainly intended for debugging purposes.
|
|||
|
|
|
|||
|
|
This method calls :py:func:`PIL.ImageShow.show` internally. You can use
|
|||
|
|
:py:func:`PIL.ImageShow.register` to override its default behaviour.
|
|||
|
|
|
|||
|
|
The image is first saved to a temporary file. By default, it will be in
|
|||
|
|
PNG format.
|
|||
|
|
|
|||
|
|
On Unix, the image is then opened using the **xdg-open**, **display**,
|
|||
|
|
**gm**, **eog** or **xv** utility, depending on which one can be found.
|
|||
|
|
|
|||
|
|
On macOS, the image is opened with the native Preview application.
|
|||
|
|
|
|||
|
|
On Windows, the image is opened with the standard PNG display utility.
|
|||
|
|
|
|||
|
|
:param title: Optional title to use for the image window, where possible.
|
|||
|
|
r ©Ú ImageShowN)ræ r Úshow)r Útitler s r% r z
|
|||
|
|
Image.showÃ
|
|||
|
|
s € õ( à�‰�t˜UÕ#r$ c óä — | j « | j j dk( r| j « fS t t | j | j j « « « S )aÏ
|
|||
|
|
Split this image into individual bands. This method returns a
|
|||
|
|
tuple of individual image bands from an image. For example,
|
|||
|
|
splitting an "RGB" image creates three new images each
|
|||
|
|
containing a copy of one of the original bands (red, green,
|
|||
|
|
blue).
|
|||
|
|
|
|||
|
|
If you need only one band, :py:meth:`~PIL.Image.Image.getchannel`
|
|||
|
|
method can be more convenient and faster.
|
|||
|
|
|
|||
|
|
:returns: A tuple containing bands.
|
|||
|
|
r )rY r� r rH rí rP rJ rÛ r s r% rÛ z Image.splitÛ
|
|||
|
|
sK € ð
|
|||
|
|
� ‰ Œ Ø �7‰7�=‰=˜AÒ Ø—I‘I“K�>Ð !Ü”S˜Ÿ™ D§G¡G§M¡M£OÓ4Ó5Ð5r$ c ó — | j « t |t « r | j « j |« }| j
|
|||
|
|
| j j |« « S # t
|
|||
|
|
$ r}d|› d�}t |« |‚d}~ww xY w)a@
|
|||
|
|
Returns an image containing a single channel of the source image.
|
|||
|
|
|
|||
|
|
:param channel: What channel to return. Could be index
|
|||
|
|
(0 for "R" channel of "RGB") or channel name
|
|||
|
|
("A" for alpha channel of "RGBA").
|
|||
|
|
:returns: An image in "L" mode.
|
|||
|
|
|
|||
|
|
.. versionadded:: 4.3.0
|
|||
|
|
zThe image has no channel "ú"N) rY rÓ rá r r— rW rJ r� r )r Úchannelrâ rö s r% Ú
|
|||
|
|
getchannelzImage.getchannelî
|
|||
|
|
s| € ð
|
|||
|
|
� ‰ Œ ä �gœsÔ #ð
|
|||
|
|
-Ø Ÿ-™-›/×/Ñ/°Ó8�ð
|
|||
|
|
�y‰y˜Ÿ™Ÿ ™ ¨Ó1Ó2Ð2øô ò
|
|||
|
|
-Ø2°7°)¸1Ð=�Ü “o¨1Ð,ûð
|
|||
|
|
-ús ¢ A+ Á+ B Á4BÂB c ó — y)zô
|
|||
|
|
Returns the current frame number. See :py:meth:`~PIL.Image.Image.seek`.
|
|||
|
|
|
|||
|
|
If defined, :attr:`~PIL.Image.Image.n_frames` refers to the
|
|||
|
|
number of available frames.
|
|||
|
|
|
|||
|
|
:returns: Frame number, starting with 0.
|
|||
|
|
r r# r s r% Útellz
|
|||
|
|
Image.tell s € ð r$ rN c óª ‡ ‡
|
|||
|
|
— t t t j |« « Š
|
|||
|
|
dˆ
|
|||
|
|
ˆ fd„ } |« }|€y|}d}|�9‰ j dt |d |z « t |d |z « f« }|�|d }‰ j |k7 rH‰ j ||||¬« } | j ‰ _ |‰ _ ‰ j j ‰ _ d‰ _ y)an
|
|||
|
|
Make this image into a thumbnail. This method modifies the
|
|||
|
|
image to contain a thumbnail version of itself, no larger than
|
|||
|
|
the given size. This method calculates an appropriate thumbnail
|
|||
|
|
size to preserve the aspect of the image, calls the
|
|||
|
|
:py:meth:`~PIL.Image.Image.draft` method to configure the file reader
|
|||
|
|
(where applicable), and finally resizes the image.
|
|||
|
|
|
|||
|
|
Note that this function modifies the :py:class:`~PIL.Image.Image`
|
|||
|
|
object in place. If you need to use the full resolution image as well,
|
|||
|
|
apply this method to a :py:meth:`~PIL.Image.Image.copy` of the original
|
|||
|
|
image.
|
|||
|
|
|
|||
|
|
:param size: The requested size in pixels, as a 2-tuple:
|
|||
|
|
(width, height).
|
|||
|
|
:param resample: Optional resampling filter. This can be one
|
|||
|
|
of :py:data:`Resampling.NEAREST`, :py:data:`Resampling.BOX`,
|
|||
|
|
:py:data:`Resampling.BILINEAR`, :py:data:`Resampling.HAMMING`,
|
|||
|
|
:py:data:`Resampling.BICUBIC` or :py:data:`Resampling.LANCZOS`.
|
|||
|
|
If omitted, it defaults to :py:data:`Resampling.BICUBIC`.
|
|||
|
|
(was :py:data:`Resampling.NEAREST` prior to version 2.5.0).
|
|||
|
|
See: :ref:`concept-filters`.
|
|||
|
|
:param reducing_gap: Apply optimization by resizing the image
|
|||
|
|
in two steps. First, reducing the image by integer times
|
|||
|
|
using :py:meth:`~PIL.Image.Image.reduce` or
|
|||
|
|
:py:meth:`~PIL.Image.Image.draft` for JPEG images.
|
|||
|
|
Second, resizing using regular resampling. The last step
|
|||
|
|
changes size no less than by ``reducing_gap`` times.
|
|||
|
|
``reducing_gap`` may be None (no first step is performed)
|
|||
|
|
or should be greater than 1.0. The bigger ``reducing_gap``,
|
|||
|
|
the closer the result to the fair resampling.
|
|||
|
|
The smaller ``reducing_gap``, the faster resizing.
|
|||
|
|
With ``reducing_gap`` greater or equal to 3.0, the result is
|
|||
|
|
indistinguishable from fair resampling in most cases.
|
|||
|
|
The default value is 2.0 (very close to fair resampling
|
|||
|
|
while still being faster in many cases).
|
|||
|
|
:returns: None
|
|||
|
|
c ó𠕇‡‡— dd„} ‰\ ŠŠ‰‰j k\ r‰‰j k\ ry ‰j ‰j z Š‰‰z ‰k\ r | ‰‰z ˆˆfd„¬« Š‰‰fS | ‰‰z ˆˆfd„¬« Š‰‰fS )Nc ó~ — t t t j | « t j | « |¬« d« S )N©Úkeyr )r¥ rÊ r£ rÒ r¤ )Únumberr s r% Ú round_aspectzDImage.thumbnail.<locals>.preserve_aspect_ratio.<locals>.round_aspect? s+ € Üœ3œtŸz™z¨&Ó 1´4·9±9¸VÓ3DÈ#ÔNÐPQÓRÐRr$ c ó& •— t ‰| ‰z z
|
|||
|
|
« S r ©r )ÚnÚaspectrl s €€r% ú<lambda>z@Image.thumbnail.<locals>.preserve_aspect_ratio.<locals>.<lambda>H s ø€ ¼3¸vÈÈAɹ~Ó;N€ r$ r
|
|||
|
|
c ó4 •— | dk( rdS t ‰‰| z z
|
|||
|
|
« S r: r )r r rt s €€r% r z@Image.thumbnail.<locals>.preserve_aspect_ratio.<locals>.<lambda>K s ø€ °1¸²6¨a€ ¼sÀ6ÈAÐPQÉEÁ>Ó?R€ r$ )r r r úCallable[[int], float]r r¿ )r} r| )r r rt rl Ú
|
|||
|
|
provided_sizer s @@@€€r% Úpreserve_aspect_ratioz.Image.thumbnail.<locals>.preserve_aspect_ratio> s‡ û€ ó
|
|||
|
|
Sð !‰DˆAˆqØ�D—J‘JŠ 1¨¯ © Ò#3Øà—Z‘Z $§+¡+Ñ-ˆFØ�1‰u˜ŠÙ V¡Ô1NÔO�ð
|
|||
|
|
�a�4ˆKñ !ؘ‘JÔ$Rô�ð �a�4ˆKr$ Nr r )r r¿ )r útuple[int, int] | None)
|
|||
|
|
rí rP r£ rÒ r r¿ r< r½ r� r0 r{ r/ r3 ) r r< r¥ r¿ r Úpreserved_sizeÚ
|
|||
|
|
final_sizer Úresr� r s ` @r% Ú thumbnailzImage.thumbnail sÑ ù€ ôZ œc¤$§*¡*¨dÓ 3Ó4ˆ
|
|||
|
|
ö ñ" /Ó0ˆØ Ð !Ø Ø#ˆ
|
|||
|
|
àˆØ Ð #Ø—*‘*Ø”s˜4 ™7 \Ñ1Ó2´C¸¸Q¹À,Ñ8NÓ4OÐPóˆCð ˆØ˜!‘f�à �9‰9˜
|
|||
|
|
Ò "Ø—‘˜Z¨°sÈ �ÓVˆBà—e‘eˆDŒGØ#ˆDŒJØ Ÿ™Ÿ ™ ˆDŒJàˆ�
|
|||
|
|
r$ r c
|
|||
|
|
ó* — | j dv ra|t j k7 rN| j dddœ| j « j ||||||« j | j « S t |t « r|j || ||¬« S t |d« r|j « \ }}|€
|
|||
|
|
d}t |« ‚t | j ||« }| j dk( r+| j r | j j « |_ | j j « |_
|
|||
|
|
|t j k( r2|D ]+ \ } }
|
|||
|
|
|j! | | t j" |
|
|||
|
|
||du « Œ- |S |j! d |z | ||||du « |S )
|
|||
|
|
ar
|
|||
|
|
Transforms this image. This method creates a new image with the
|
|||
|
|
given size, and the same mode as the original, and copies data
|
|||
|
|
to the new image using the given transform.
|
|||
|
|
|
|||
|
|
:param size: The output size in pixels, as a 2-tuple:
|
|||
|
|
(width, height).
|
|||
|
|
:param method: The transformation method. This is one of
|
|||
|
|
:py:data:`Transform.EXTENT` (cut out a rectangular subregion),
|
|||
|
|
:py:data:`Transform.AFFINE` (affine transform),
|
|||
|
|
:py:data:`Transform.PERSPECTIVE` (perspective transform),
|
|||
|
|
:py:data:`Transform.QUAD` (map a quadrilateral to a rectangle), or
|
|||
|
|
:py:data:`Transform.MESH` (map a number of source quadrilaterals
|
|||
|
|
in one operation).
|
|||
|
|
|
|||
|
|
It may also be an :py:class:`~PIL.Image.ImageTransformHandler`
|
|||
|
|
object::
|
|||
|
|
|
|||
|
|
class Example(Image.ImageTransformHandler):
|
|||
|
|
def transform(self, size, data, resample, fill=1):
|
|||
|
|
# Return result
|
|||
|
|
|
|||
|
|
Implementations of :py:class:`~PIL.Image.ImageTransformHandler`
|
|||
|
|
for some of the :py:class:`Transform` methods are provided
|
|||
|
|
in :py:mod:`~PIL.ImageTransform`.
|
|||
|
|
|
|||
|
|
It may also be an object with a ``method.getdata`` method
|
|||
|
|
that returns a tuple supplying new ``method`` and ``data`` values::
|
|||
|
|
|
|||
|
|
class Example:
|
|||
|
|
def getdata(self):
|
|||
|
|
method = Image.Transform.EXTENT
|
|||
|
|
data = (0, 0, 100, 100)
|
|||
|
|
return method, data
|
|||
|
|
:param data: Extra data to the transformation method.
|
|||
|
|
:param resample: Optional resampling filter. It can be one of
|
|||
|
|
:py:data:`Resampling.NEAREST` (use nearest neighbour),
|
|||
|
|
:py:data:`Resampling.BILINEAR` (linear interpolation in a 2x2
|
|||
|
|
environment), or :py:data:`Resampling.BICUBIC` (cubic spline
|
|||
|
|
interpolation in a 4x4 environment). If omitted, or if the image
|
|||
|
|
has mode "1" or "P", it is set to :py:data:`Resampling.NEAREST`.
|
|||
|
|
See: :ref:`concept-filters`.
|
|||
|
|
:param fill: If ``method`` is an
|
|||
|
|
:py:class:`~PIL.Image.ImageTransformHandler` object, this is one of
|
|||
|
|
the arguments passed to it. Otherwise, it is unused.
|
|||
|
|
:param fillcolor: Optional fill color for the area outside the
|
|||
|
|
transform in the output image.
|
|||
|
|
:returns: An :py:class:`~PIL.Image.Image` object.
|
|||
|
|
rÓ r� r– )r¥ Úfillr' Nzmissing method datar’ r- )r{ rE rF rã rø rÓ ÚImageTransformHandlerrU r' rW rI r1 rH r2 r> rC Ú_Image__transformerrB ) r r< rü r‘ r¥ r rÌ rö r� r Úquads r% rø zImage.transformg su € ðv �9‰9˜Ñ &¨8´z×7IÑ7IÒ+Ià— ‘ D°&Ñ 9¸$¿)¹)Ñ DÓEß‘˜4 ¨¨x¸¸yÓIß‘˜Ÿ™Ó#ð
|
|||
|
|
ô �fÔ 3Ô 4Ø×#Ñ# D¨$¸ÈÐ#ÓMÐ Mä �6˜9Ô %à!Ÿ>™>Ó+‰LˆF�Dà ˆ<Ø'ˆCÜ ˜S“/Ð !ä
|
|||
|
|
�—‘˜D )Ó
|
|||
|
|
,ˆØ �9‰9˜Ò § ¢ Ø Ÿ ™ ×*Ñ*Ó,ˆBŒJØ—)‘)—.‘.Ó"ˆŒØ ”Y—^‘^Ò #à !ò
|
|||
|
|
‘ ��TØ× Ñ Ø˜œyŸ~™~¨t°X¸yÈDÐ?Põð
|
|||
|
|
ð ˆ ð
|
|||
|
|
× Ñ Ø˜‘
|
|||
|
|
˜t V¨T°8¸YÈ$Ð=Nô
|
|||
|
|
ð ˆ r$ c
|
|||
|
|
óx — |d |d z
|
|||
|
|
}|d |d z
|
|||
|
|
}|t j k( r|d d }nþ|t j k( r0|\ } }
|
|||
|
|
} } | | z
|
|||
|
|
|z }
|
|||
|
|
| |
|
|||
|
|
z
|
|||
|
|
|z }t j }|
|
|||
|
|
d| d||
|
|||
|
|
f}n»|t j k( r|d d }n¢|t j k( r‚|d d }|dd }|dd }|dd }|\ } }
|
|||
|
|
d|z }d|z }| |d | z
|
|||
|
|
|z |d | z
|
|||
|
|
|z |d |d z
|
|||
|
|
|d z
|
|||
|
|
| z |z |z |
|
|||
|
|
|d |
|
|||
|
|
z
|
|||
|
|
|z |d |
|
|||
|
|
z
|
|||
|
|
|z |d |d z
|
|||
|
|
|d z
|
|||
|
|
|
|
|||
|
|
z |z |z f}n
|
|||
|
|
d }t |« ‚|t j t j t j fvrï|t j t j t j fv r?t j d
|
|||
|
|
t j d t j d i}|| d
|
|||
|
|
|› d�z }nd|› d�}t j dft j dft j dffD �cg c] }|d › d
|
|||
|
|
|d › d�‘Œ }}|ddj |d d « › d|d › �z
|
|||
|
|
}t |« ‚|j « | j « |j dv rt j }| j j# ||j ||||« y c c}w )Nr1 r r2 r r5 é r3 rM z unknown transformation methodr³ r´ r° rµ z) cannot be used.r r® r¯ r± r² r¶ r· r¸ r¹ rº r» )r> r? r@ rA rB rW rE rF rH rJ rG rI rK rª rY r{ r� rø )r r Úimagerü r‘ r¥ r r× r! r r r
|
|||
|
|
r ÚxsÚysrÝ ÚswÚseÚneÚAsÚAtrö Úunusabler rÀ s r% Ú
|
|||
|
|
__transformerzImage.__transformerÅ s. € ð
|
|||
|
|
�‰F�S˜‘V‰OˆØ �‰F�S˜‘V‰Oˆà ”Y×%Ñ%Ò %ؘ˜�8‰Dà
|
|||
|
|
”y×'Ñ'Ò
|
|||
|
|
'à !‰NˆB��B˜Ø�r‘'˜Q‘ ˆBØ�r‘'˜Q‘ ˆBÜ ×%Ñ%ˆFؘ˜2˜q " bÐ)‰Dà
|
|||
|
|
”y×,Ñ,Ò
|
|||
|
|
,ؘ˜�8‰Dà
|
|||
|
|
”y—~‘~Ò
|
|||
|
|
%ð �b�q�ˆBØ�a˜�ˆBØ�a˜�ˆBØ�a˜�ˆB؉FˆB�Ø�q‘ˆBØ�q‘ˆBàØ�A‘˜‘˜rÑ!Ø�A‘˜‘˜rÑ!Ø�A‘˜˜A™‘ A¡Ñ&¨Ñ+¨rÑ1°BÑ6ØØ�A‘˜‘˜rÑ!Ø�A‘˜‘˜rÑ!Ø�A‘˜˜A™‘ A¡Ñ&¨Ñ+¨rÑ1°BÑ6ð ‰Dð 2ˆCÜ ˜S“/Ð !à Ü × Ñ Ü × Ñ Ü × Ñ ð
|
|||
|
|
ñ
|
|||
|
|
ð
|
|||
|
|
œJŸN™N¬J×,>Ñ,>Ä
|
|||
|
|
×@RÑ@RÐSÑSä —N‘NÐ$:Ü ×&Ñ&Ð(BÜ ×&Ñ&Ð(Bð,�ð
|
|||
|
|
˜xÑ(¨R°¨zÐ9JÐ+KÑK‘à3°H°:¸RÐ@�ô
|
|||
|
|
×'Ñ'Ð)CÐDÜ ×(Ñ(Ð*EÐFÜ ×'Ñ'Ð)CÐDð öàð ˜!‘9�+˜R q¡ ˜{¨!Ò,ðˆGð ð
|
|||
|
|
�U˜4Ÿ9™9 W¨S¨b \Ó2Ð3°4¸À¹ °}ÐEÑ EˆCÜ ˜S“/Ð !à
|
|||
|
|
�
|
|||
|
|
‰
|
|||
|
|
Œ à � ‰ Œ à �:‰:˜Ñ #Ü!×)Ñ)ˆHà �‰×ј#˜uŸx™x¨°°xÀÕFùò%s È J7c óv — | j « | j | j j |« « S )a¶
|
|||
|
|
Transpose image (flip or rotate in 90 degree steps)
|
|||
|
|
|
|||
|
|
:param method: One of :py:data:`Transpose.FLIP_LEFT_RIGHT`,
|
|||
|
|
:py:data:`Transpose.FLIP_TOP_BOTTOM`, :py:data:`Transpose.ROTATE_90`,
|
|||
|
|
:py:data:`Transpose.ROTATE_180`, :py:data:`Transpose.ROTATE_270`,
|
|||
|
|
:py:data:`Transpose.TRANSPOSE` or :py:data:`Transpose.TRANSVERSE`.
|
|||
|
|
:returns: Returns a flipped or rotated copy of this image.
|
|||
|
|
)rY rJ r� rÎ )r rü s r% rÎ zImage.transpose s+ € ð
|
|||
|
|
� ‰ Œ Ø�y‰y˜Ÿ™×*Ñ*¨6Ó2Ó3Ð3r$ c óv — | j « | j | j j |« « S )zj
|
|||
|
|
Randomly spread pixels in an image.
|
|||
|
|
|
|||
|
|
:param distance: Distance to spread pixels.
|
|||
|
|
)rY rJ r� Ú
|
|||
|
|
effect_spread)r Údistances r% r2 zImage.effect_spread) s+ € ð
|
|||
|
|
� ‰ Œ Ø�y‰y˜Ÿ™×.Ñ.¨xÓ8Ó9Ð9r$ c ód — ddl m} |j s
|
|||
|
|
d}t |« ‚ |j | « S )z#Returns a QImage copy of this imager ©re ú Qt bindings are not installed)ræ re Úqt_is_installedrß Útoqimage©r re rö s r% r8 zImage.toqimage2 s1 € å à×&Ò&Ø1ˆCÜ ˜cÓ"Ð "Ø ˆw× Ñ Ó%Ð%r$ c ód — ddl m} |j s
|
|||
|
|
d}t |« ‚ |j | « S )z$Returns a QPixmap copy of this imager r5 r6 )ræ re r7 rß Ú toqpixmapr9 s r% r; zImage.toqpixmap; s1 € å à×&Ò&Ø1ˆCÜ ˜cÓ"Ð "Ø ˆw× Ñ Ó&Ð&r$ ©r r )r úcore.ImagingCore)r� r= r r ©r r¿ )r útuple[int, int]©r rá )r3 r¿ r r )r� r= r rw )r rw )rô Úobjectr r )NN)re r) r* r) rf r r rá )r rA r r) )rz ra r{ r) r r )r‚ rá rƒ r r ú bytes | None)r rB )r z.dict[str, str | bytes | int | tuple[int, ...]])r rA r )r˜ z
|
|||
|
|
object | Noner ztuple[object, object])r ú list[Any])r rC r r ©r� )rü rá rô r r rÔ )r& )r´ rá r rÔ )r‘ ú*bytes | bytearray | SupportsArrayInterfaceró rá rô r r r )r zcore.PixelAccess | None) r{ r) rÑ ztuple[float, ...] | Nonerè z
|
|||
|
|
Dither | Noner1 rV ré r¿ r rw ) ré r¿ rü r+ rý r¿ r1 ú Image | Nonerè rP r rw )r ú(tuple[float, float, float, float] | Noner rw )r� r= r ú!tuple[float, float, float, float]r r= )r{ r) r< r r z0tuple[str, tuple[int, int, float, float]] | None)r z-ImageFilter.Filter | type[ImageFilter.Filter]r rw )r útuple[str, ...])r r) r ú tuple[int, int, int, int] | None)rÆ )r r¿ r zBlist[tuple[int, tuple[int, ...]]] | list[tuple[int, float]] | None)r' r+ r r= )r' r+ r z/tuple[tuple[int, ...], ...] | tuple[float, ...])r z1tuple[float, float] | tuple[tuple[int, int], ...]©r údict[str, Any])r rE )r zlist[ImageFile.ImageFile])r rg )r” )r¾ r) r zlist[int] | None©r r) )ri útuple[int, int] | list[int]r z float | tuple[int, ...] | None)r ztuple[list[int], list[int]])rp rF rq útuple[float, float] | Noner ú list[int])rp rF rq rO r r )r� z'Image | str | float | tuple[float, ...]r z:Image | tuple[int, int, int, int] | tuple[int, int] | Nonerp rF r r )r- r- )r� rw r{ ú
|
|||
|
|
Sequence[int]rx rQ r r )r„ zˆSequence[float] | NumpyArray | Callable[[int], float] | Callable[[ImagePointTransform], ImagePointTransform | float] | ImagePointHandlerr{ r) r rw )rf z Image | intr r )rM rÊ )r‘ zISequence[float] | Sequence[Sequence[int]] | core.ImagingCore | NumpyArrayr r r r r r )r‘ z1ImagePalette.ImagePalette | bytes | Sequence[int]r¾ rá r r )ri r? rÌ z#float | tuple[int, ...] | list[int]r r )r˜ rP r™ zbytes | bytearray | Noner rw )r< r? r¥ rE r rH r útuple[int, int, int, int])NNN)
|
|||
|
|
r< z(tuple[int, int] | list[int] | NumpyArrayr¥ r+ r rG r¿ ú float | Noner rw )rÄ zint | tuple[int, int]r rJ r rw )rÓ r r¥ rE rÔ z
|
|||
|
|
int | boolrÕ rO rÖ r rÌ ú&float | tuple[float, ...] | str | Noner rw )rM úStrOrBytesPath | IO[bytes]r* r) rô r r r )r� rw r rL )rü r¿ r r )r r) r r )r ztuple[Image, ...])r z int | strr rw )r< rÍ r¥ rE r¿ rS r r )r< r? rü z3Transform | ImageTransformHandler | SupportsGetDatar‘ zSequence[Any] | Noner¥ r¿ r r¿ rÌ rT r rw )r rR r& rw rü r> r‘ zSequence[float]r¥ r¿ r r) r r )rü r0 r rw )r3 r¿ r rw )r zImageQt.ImageQt)r úImageQt.QPixmap)cr r! r" r r* Ú__annotations__r+ Ú!_close_exclusive_fp_after_loadingr Úpropertyr� Úsetterr} r| r< r{ r3 rJ rL rN rV rZ r\ rj rp rw r| r… rŠ r� r’ r” r– r› r¡ ro rµ rŸ rY rÅ rV rW rã rP rT rÚ rH Ú__copy__r r r r r r r r' r% r+ r@ rW rY r\ r_ rn rc rg rä rk r rs rw rz r‚ r‹ r� rž râ r r« r½ r¾ rE rF rß rd rì rý r rÛ r r rJ r rø r" rÎ r2 r8 r; r# r$ r% rw rw i sc … ñ ð €FˆJÓ Ø%)И
|
|||
|
|
Ó)Ø(,Ð%ó'ð òó ðð ‡Y�Yòó ðð ò ó ð ð ò ó ð ð òó ðð òó ðð òBó ðBð ‡_�_ò"ó ð"ó
|
|||
|
|
ó ó
|
|||
|
|
óJó(ó
|
|||
|
|
ð =AðØ ðØ/9ðØMPðà óó0
|
|||
|
|
|
|||
|
|
ó
|
|||
|
|
ó
|
|||
|
|
ó ó9ó(ð ò
|
|||
|
|
ó ð
|
|||
|
|
ó,ð
|
|||
|
|
15ðKØ -ðKà óKó Mó ô7 ôr
|
|||
|
|
ð: "ð#"à8ð#"ð ð#"ð ð #"ð
|
|||
|
|
|
|||
|
|
ó #"óJ$óL
|
|||
|
|
ð Ø+/Ø $Ø"Ÿ;™;Øð
|
|||
|
|
~àð~ð )ð~ð ð ~ð
|
|||
|
|
ð ~ð ð
|
|||
|
|
~ð
|
|||
|
|
ó~ðD Ø !ØØ $Ø ×.Ñ.ð
|
|||
|
|
QàðQð ðQð ð Qð
|
|||
|
|
ð Qð ð
|
|||
|
|
Qð
|
|||
|
|
óQóf )ð €Hô3ð4)Ø"ð)Ø)Jð)à ó)ð,
|
|||
|
|
Ø ð
|
|||
|
|
Ø&<ð
|
|||
|
|
à 9ó
|
|||
|
|
ó2%ó62ð -1õ +ð( #ð,Ø ð,à Kó,ô2ð2 "&ð Ø ð à 8ó ó$
|
|||
|
|
$ó %5óN)óVó :ó ô7ð, òó ðó*&ð0
|
|||
|
|
+Ø-ð
|
|||
|
|
+à 'ó
|
|||
|
|
+ó
|
|||
|
|
ð PTð #Ø ð #Ø2Lð #à ó #ðD PTð!Ø ð!Ø2Lð!à ó!ð> KOØ !ð Z'à 3ðZ'ð HðZ'ð ð Z'ð
|
|||
|
|
|
|||
|
|
ó Z'ðz PVð6 Øð6 Ø ,ð6 Ø?Lð6 à
|
|||
|
|
ó6 ðB ð:7ð
|
|||
|
|
ð:7ð ð:7ð
|
|||
|
|
ó:7óx5(ðt Øð -àWð-ð ð-ð ð -ð
|
|||
|
|
|
|||
|
|
ó -ð6 ð.à?ð.ð ð.ð
|
|||
|
|
ó .ð`&+Ø!ð&+Ø*Mð&+à
|
|||
|
|
ó&+ðR OSðXØ!ðXØ3KðXà óXðt
|
|||
|
|
à ð
|
|||
|
|
ð ð
|
|||
|
|
ð /ð
|
|||
|
|
ð
|
|||
|
|
|
|||
|
|
#ó
|
|||
|
|
ð2 $Ø8<Ø%)ð n à6ðn ð ðn ð 6ð n ð
|
|||
|
|
#ð n ð
|
|||
|
|
ó
|
|||
|
|
n ðf 15ð!6à%ð!6ð .ð!6ð
|
|||
|
|
ó !6ðL *× 1Ñ 1Ø "Ø-1Ø,0Ø<@ðr
|
|||
|
|
àðr
|
|||
|
|
ð ðr
|
|||
|
|
ð ð r
|
|||
|
|
ð
|
|||
|
|
+ð r
|
|||
|
|
ð *ð
|
|||
|
|
r
|
|||
|
|
ð :ðr
|
|||
|
|
ð
|
|||
|
|
ór
|
|||
|
|
ðj DHðGØ,ðGØ6@ðGØSVðGà
|
|||
|
|
óGóRó
|
|||
|
|
ô,$ó06ó&3ó, ð *× 1Ñ 1Ø%(ð Tà!ðTð ðTð #ð Tð
|
|||
|
|
|
|||
|
|
ó Tðx &*Ø"×*Ñ*ØØ<@ð\à ð\ð Dð\ð #ð \ð
|
|||
|
|
ð \ð ð
|
|||
|
|
\ð :ð\ð
|
|||
|
|
ó\ðH #×*Ñ*ØðTGà
|
|||
|
|
&ðTGð ðTGð ð TGð
|
|||
|
|
ð TGð ð
|
|||
|
|
TGð ðTGð
|
|||
|
|
óTGól 4ó :ó&ô'r$ c ó6 — e Zd ZdZej
|
|||
|
|
dd„« Zy)r� zb
|
|||
|
|
Used as a mixin by point transforms
|
|||
|
|
(for use with :py:meth:`~PIL.Image.Image.point`)
|
|||
|
|
c ó — y r r# r8 s r% r‚ zImagePointHandler.pointO s € à r$ N)r� rw r rw )r r! r" r ÚabcÚabstractmethodr‚ r# r$ r% r� r� I s! „ ñð
|
|||
|
|
×Ñò
|
|||
|
|
ó ñ
|
|||
|
|
r$ r� c óF — e Zd ZdZej
|
|||
|
|
dd„« Zy)r! zi
|
|||
|
|
Used as a mixin by geometry transforms
|
|||
|
|
(for use with :py:meth:`~PIL.Image.Image.transform`)
|
|||
|
|
c ó — y r r# )r r< r& rf s r% rø z ImageTransformHandler.transformZ s € ð
|
|||
|
|
r$ N)r< r? r& rw rf r r rw )r r! r" r r^ r_ rø r# r$ r% r! r! T sG „ ñð
|
|||
|
|
×Ñð
|
|||
|
|
à ð
|
|||
|
|
ð ð
|
|||
|
|
ð ð
|
|||
|
|
ð
|
|||
|
|
|
|||
|
|
ò
|
|||
|
|
ó ñ
|
|||
|
|
r$ r! c óº — t | t t f« s
|
|||
|
|
d}t |« ‚t | « dk7 r
|
|||
|
|
d}t |« ‚| d dk s| d dk r
|
|||
|
|
d}t |« ‚y)zª
|
|||
|
|
Common check to enforce type and sanity check on size tuples
|
|||
|
|
|
|||
|
|
:param size: Should be a 2 tuple of (width, height)
|
|||
|
|
:returns: None, or raises a ValueError
|
|||
|
|
z Size must be a list or tupler1 z#Size must be a sequence of length 2r r z Width and height must be >= 0N)rÓ r5 rí rW r~ )r< rö s r% Ú _check_sizerc h sd € ô �dœT¤5˜MÔ *Ø,ˆÜ˜‹oÐ Ü
|
|||
|
|
ˆ4ƒy�A‚~Ø3ˆÜ˜‹oÐ Ø ˆA�w�‚{�d˜1‘g ’kØ-ˆÜ˜‹oÐ ð "r$ c ój — t |« |€-t « j t j | |« « S t |t « rddlm} |j || « }t « }| dk( r�t |t t f« r‡t d„ |D « « rut t t df t |« « }t |« dk( st |« dk( r7ddlm} |j « |_ |j" j |« }|j t j$ | ||« « S ) aÅ
|
|||
|
|
Creates a new image with the given mode and size.
|
|||
|
|
|
|||
|
|
:param mode: The mode to use for the new image. See:
|
|||
|
|
:ref:`concept-modes`.
|
|||
|
|
:param size: A 2-tuple, containing (width, height) in pixels.
|
|||
|
|
:param color: What color to use for the image. Default is black. If given,
|
|||
|
|
this should be a single integer or floating point value for single-band
|
|||
|
|
modes, and a tuple for multi-band modes (one value per band). When
|
|||
|
|
creating RGB or HSV images, you can also use color strings as supported
|
|||
|
|
by the ImageColor module. See :ref:`colors` for more information. If the
|
|||
|
|
color is None, the image is not initialised.
|
|||
|
|
:returns: An :py:class:`~PIL.Image.Image` object.
|
|||
|
|
r ru r’ c 3 ó< K — | ] }t |t « –— Œ y wr )rÓ r¿ r• s r% rÒ znew.<locals>.<genexpr> s è ø€ Ò2 q”
|
|||
|
|
˜1œc×"Ñ2ùs ‚ .r2 r3 rG )rc rw rJ rð rI rÓ rá ræ rv rà r5 rí Úallr r¿ r~ rd r1 r )r{ r< Úcolorrv r� Ú
|
|||
|
|
color_intsrd s r% rI rI { sì € ô( �Ôà €}ä‹w�|‰|œDŸH™H T¨4Ó 0Ó1Ð1ä�%œÔ õ !à×#Ñ# E¨4Ó0ˆä ‹€Bà �Š Ü �uœt¤U˜mÔ ,Ü Ñ2¨EÔ2Ô 2ä&*¬5´°c°©?¼EÀ%»LÓ&Iˆ
|
|||
|
|
Ü ˆz‹?˜aÒ ¤3 z£?°aÒ#7å &à2˜ ×2Ñ2Ó4ˆBŒJØ—J‘J×'Ñ'¨
|
|||
|
|
Ó3ˆEØ
|
|||
|
|
�7‰7”4—9‘9˜T 4¨Ó/Ó 0Ð0r$ c óþ — t |« t | |« }|j dk7 rV|j dk7 rG|}t |« dk( rt |d t « r|d }|dk( r|dk( r| }|j |||« |S )aƒ
|
|||
|
|
Creates a copy of an image memory from pixel data in a buffer.
|
|||
|
|
|
|||
|
|
In its simplest form, this function takes three arguments
|
|||
|
|
(mode, size, and unpacked pixel data).
|
|||
|
|
|
|||
|
|
You can also use any pixel decoder supported by PIL. For more
|
|||
|
|
information on available decoders, see the section
|
|||
|
|
:ref:`Writing Your Own File Codec <file-codecs>`.
|
|||
|
|
|
|||
|
|
Note that this function decodes pixel data only, not entire images.
|
|||
|
|
If you have an entire image in a string, wrap it in a
|
|||
|
|
:py:class:`~io.BytesIO` object, and use :py:func:`~PIL.Image.open` to load
|
|||
|
|
it.
|
|||
|
|
|
|||
|
|
:param mode: The image mode. See: :ref:`concept-modes`.
|
|||
|
|
:param size: The image size.
|
|||
|
|
:param data: A byte buffer containing raw data for the given mode.
|
|||
|
|
:param decoder_name: What decoder to use.
|
|||
|
|
:param args: Additional parameters for the given decoder.
|
|||
|
|
:returns: An :py:class:`~PIL.Image.Image` object.
|
|||
|
|
r r r� r# )rc rI r} r| r~ rÓ rí rŸ )r{ r< r‘ ró rô r� r· s r% rŸ rŸ ¬ s} € ô< �Ôä ˆT�4‹ €BØ ‡x�x�1‚}˜Ÿ™ aš Ø ˆ Ü ˆ|Ó Ò !¤j° ¸a± Ä%Ô&Hà'¨™?ˆLà ˜5Ò \°RÒ%7Ø ˆLà
|
|||
|
|
� ‰ �T˜<¨ Ô6Ø
|
|||
|
|
€Ir$ c ó¨ — t |« t |« dk( rt |d t « r|d }|dk( rŽ|dk( r| ddf}|d t v ryt | d« }|j
|
|||
|
|
t j |||d|« « }| dk( r7ddl m
|
|||
|
|
} |j d|j j d« « |_
|
|||
|
|
d|_ |S t | ||||« S ) aÑ
|
|||
|
|
Creates an image memory referencing pixel data in a byte buffer.
|
|||
|
|
|
|||
|
|
This function is similar to :py:func:`~PIL.Image.frombytes`, but uses data
|
|||
|
|
in the byte buffer, where possible. This means that changes to the
|
|||
|
|
original buffer object are reflected in this image). Not all modes can
|
|||
|
|
share memory; supported modes include "L", "RGBX", "RGBA", and "CMYK".
|
|||
|
|
|
|||
|
|
Note that this function decodes pixel data only, not entire images.
|
|||
|
|
If you have an entire image file in a string, wrap it in a
|
|||
|
|
:py:class:`~io.BytesIO` object, and use :py:func:`~PIL.Image.open` to load it.
|
|||
|
|
|
|||
|
|
The default parameters used for the "raw" decoder differs from that used for
|
|||
|
|
:py:func:`~PIL.Image.frombytes`. This is a bug, and will probably be fixed in a
|
|||
|
|
future release. The current release issues a warning if you do this; to disable
|
|||
|
|
the warning, you should provide the full set of parameters. See below for details.
|
|||
|
|
|
|||
|
|
:param mode: The image mode. See: :ref:`concept-modes`.
|
|||
|
|
:param size: The image size.
|
|||
|
|
:param data: A bytes or other buffer object containing raw
|
|||
|
|
data for the given mode.
|
|||
|
|
:param decoder_name: What decoder to use.
|
|||
|
|
:param args: Additional parameters for the given decoder. For the
|
|||
|
|
default encoder ("raw"), it's recommended that you provide the
|
|||
|
|
full set of parameters::
|
|||
|
|
|
|||
|
|
frombuffer(mode, size, data, "raw", mode, 0, 1)
|
|||
|
|
|
|||
|
|
:returns: An :py:class:`~PIL.Image.Image` object.
|
|||
|
|
|
|||
|
|
.. versionadded:: 1.1.4
|
|||
|
|
r r r� r# r- r’ rG r” )rc r~ rÓ rí Ú _MAPMODESrI rJ rð Ú
|
|||
|
|
map_bufferræ rd r� rn r1 r3 rŸ )r{ r< r‘ ró rô r� rd s r% Ú
|
|||
|
|
frombufferrm Ú sÏ € ôP �Ôô ˆ4ƒy�A‚~œ* T¨!¡W¬eÔ4Ø�A‰wˆà�uÒ Ø �2Š:ؘ˜A�:ˆDØ �‰7”iÑ Ü�T˜6Ó"ˆBØ—‘œŸ ™ ¨¨t°\À1ÀdÓKÓLˆBØ�sŠ{Ý*à 6˜\× 6Ñ 6°u¸b¿e¹e×>NÑ>NÈuÓ>UÓ V�”
|
|||
|
|
؈BŒK؈Iä �T˜4 |°TÓ :Ð:r$ c ó" — e Zd ZdZedd„« Zy)ÚSupportsArrayInterfacezC
|
|||
|
|
An object that has an ``__array_interface__`` dictionary.
|
|||
|
|
c ó — t « ‚r ©ÚNotImplementedErrorr s r% r’ z*SupportsArrayInterface.__array_interface__
|
|||
|
|
s € ä!Ó#Ð#r$ NrK )r r! r" r rY r’ r# r$ r% ro ro
|
|||
|
|
s „ ñð ò$ó ñ$r$ ro c ó" — e Zd ZdZ d dd„Zy)ÚSupportsArrowArrayInterfacezm
|
|||
|
|
An object that has an ``__arrow_c_array__`` method corresponding to the arrow c
|
|||
|
|
data interface.
|
|||
|
|
Nc ó — t « ‚r rq r— s r% r– z-SupportsArrowArrayInterface.__arrow_c_array__(
|
|||
|
|
s
|
|||
|
|
€ ô "Ó#Ð#r$ r )r˜ z 'PyCapsule'r z tuple['PyCapsule', 'PyCapsule'])r r! r" r r– r# r$ r% rt rt "
|
|||
|
|
s! „ ñð /3ð$Ø +ð$à (ô$r$ rt c ó¦ — | j }|d }t |« }|j dd« } d|dd z |d f}|� t
|
|||
|
|
| \ }
|
|||
|
|
} }|�|
|
|||
|
|
k7 r|vr t
|
|||
|
|
d
|
|||
|
|
d « |} n
|
|||
|
|
}|d v rd}n
|
|||
|
|
|d
|
|||
|
|
k( rd}nd}||kD rd|› d|› d�} t | « ‚|dk( rdn|d |d f}|�Gt | d« r| j « } n*t | d« r| j « } n
|
|||
|
|
d} t | « ‚t ||| d dd« S # t $ r }|�d}g }nd} t | « |‚Y d}~Œäd}~ww xY w# t $ r }|\ } }
|
|||
|
|
d| › d |
|
|||
|
|
› �} t | « |‚d}~ww xY w)a2
|
|||
|
|
Creates an image memory from an object exporting the array interface
|
|||
|
|
(using the buffer protocol)::
|
|||
|
|
|
|||
|
|
from PIL import Image
|
|||
|
|
import numpy as np
|
|||
|
|
a = np.zeros((5, 5))
|
|||
|
|
im = Image.fromarray(a)
|
|||
|
|
|
|||
|
|
If ``obj`` is not contiguous, then the ``tobytes`` method is called
|
|||
|
|
and :py:func:`~PIL.Image.frombuffer` is used.
|
|||
|
|
|
|||
|
|
In the case of NumPy, be aware that Pillow modes do not always correspond
|
|||
|
|
to NumPy dtypes. Pillow modes only offer 1-bit pixels, 8-bit pixels,
|
|||
|
|
32-bit signed integer pixels, and 32-bit floating point pixels.
|
|||
|
|
|
|||
|
|
Pillow images can also be converted to arrays::
|
|||
|
|
|
|||
|
|
from PIL import Image
|
|||
|
|
import numpy as np
|
|||
|
|
im = Image.open("hopper.jpg")
|
|||
|
|
a = np.asarray(im)
|
|||
|
|
|
|||
|
|
When converting Pillow images to arrays however, only pixel values are
|
|||
|
|
transferred. This means that P and PA mode images will lose their palette.
|
|||
|
|
|
|||
|
|
:param obj: Object with array interface
|
|||
|
|
:param mode: Optional mode to use when reading ``obj``. Since pixel values do not
|
|||
|
|
contain information about palettes or color spaces, this can be used to place
|
|||
|
|
grayscale L mode data within a P mode image, or read RGB data as YCbCr for
|
|||
|
|
example.
|
|||
|
|
|
|||
|
|
See: :ref:`concept-modes` for general information about modes.
|
|||
|
|
:returns: An image object.
|
|||
|
|
|
|||
|
|
.. versionadded:: 1.1.6
|
|||
|
|
rƒ ÚstridesNrÔ r1 r€ z Cannot handle this data typez Cannot handle this data type: r¸ z('mode' parameter for changing data typesr[ )r† rŽ rŠ r’ rˆ r” r2 r3 zToo many dimensions: z > rÑ r r ro Útostringz1'strides' requires either tobytes() or tostring()r� ) r’ r~ r× rî r Ú_fromarray_typemapr rW rU ro rx rm )Úobjr{ rà rƒ Úndimrw Útypekeyrâ Ú color_modesrö Útypemoder¾ Ú
|
|||
|
|
typekey_shaper€ Úndmaxr< s r% Ú fromarrayr� .
|
|||
|
|
sÀ € ðL ×
|
|||
|
|
!Ñ
|
|||
|
|
!€CØ �‰L€EÜ ˆu‹:€DØ�g‰g�i Ó&€Gð(ؘ5 ˜9Ñ$ c¨)¡nÐ4ˆð Ðð (Ü-?ÀÑ-HÑ *ˆH�g˜{ð
|
|||
|
|
ÐØ �8Ò ¨KÑ 7Ü Ð@À"Ô E؉àˆØ Ð(Ñ(؉Ø
|
|||
|
|
�Š ؉àˆØ ˆe‚|Ø% d V¨3¨u¨g°QÐ7ˆÜ˜‹oÐ à˜’ ‰1˜u Q™x¨¨q©Ð 1€DØÐÜ �3˜ Ô "Ø—+‘+“-‰CÜ
|
|||
|
|
�S˜*Ô
|
|||
|
|
%Ø—,‘,“.‰CàEˆCÜ ˜S“/Ð !ä �d˜D # u¨g°q¸!Ó <Ð<øôQ ò (Ø Ð ØˆGØ%'‰Kà0ˆCܘC“. aÐ 'ô
|
|||
|
|
ûð(ûô ò (Ø%,Ñ "ˆM˜7Ø2°=°/ÀÀGÀ9ÐMˆCܘC“. aÐ 'ûð (ús/ °
|
|||
|
|
C> Á
|
|||
|
|
D) Ã> D&ÄD!Ä!D&Ä) EÄ2E Å Ec óÚ — t | d« s
|
|||
|
|
d}t |« ‚| j « \ }}t j ||||« }|rt « j
|
|||
|
|
|« S d}t |« ‚)a× Creates an image with zero-copy shared memory from an object exporting
|
|||
|
|
the arrow_c_array interface protocol::
|
|||
|
|
|
|||
|
|
from PIL import Image
|
|||
|
|
import pyarrow as pa
|
|||
|
|
arr = pa.array([0]*(5*5*4), type=pa.uint8())
|
|||
|
|
im = Image.fromarrow(arr, 'RGBA', (5, 5))
|
|||
|
|
|
|||
|
|
If the data representation of the ``obj`` is not compatible with
|
|||
|
|
Pillow internal storage, a ValueError is raised.
|
|||
|
|
|
|||
|
|
Pillow images can also be converted to Arrow objects::
|
|||
|
|
|
|||
|
|
from PIL import Image
|
|||
|
|
import pyarrow as pa
|
|||
|
|
im = Image.open('hopper.jpg')
|
|||
|
|
arr = pa.array(im)
|
|||
|
|
|
|||
|
|
As with array support, when converting Pillow images to arrays,
|
|||
|
|
only pixel values are transferred. This means that P and PA mode
|
|||
|
|
images will lose their palette.
|
|||
|
|
|
|||
|
|
:param obj: Object with an arrow_c_array interface
|
|||
|
|
:param mode: Image mode.
|