Ë
|
³òúhøR ã
|
ór
|
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( rdFndGZsd±dIZtg dJ¢ZudKZvd²dLZwd²dMZxd³dNZyd´dOZzd a{dµdPZ|d¶dQZ} d· d¸dRZ~ d· d¹dSZ G dT dU« Z dºdVZ G dW dXe« Z G dY dH« Z G dZ d[ej « Z
G d\ d]ej « Zd»d^Z d¼ d½d_Z d¾ d¿d`Z d¾ dÀdaZ G db dce« Z G dd dee« ZdÁdÂdfZ dÃdgZdÄdhZdÅdiZi djdkdlg fdmdndndogfdpdqdrg fdsdqdtg fdudqdvg fdwdqdxg fdydqdzg fd{dqd|g fd}dqd~g fddqdg fddqdg fddd
g fdddg fdddg fdddg fdddddgfdddg d¢fdddg d¢fdes dfdqdqg fdes dfddg fi¥ZdÆdZ dÇ dÈdZdÉdZdÊdZdËdZdÌdZdÍdZ dÁ dÎd ZdÏd¡Z dÐd¢Z dÐd£ZdÑd¤ZdÒd¥ZdÓd¦ZdÔd§Z dÕd¨Z¡dÖd©Z¢ d×dªZ£dØd«Z¤dÙd¬Z¥dÙdZ¦dÁdÚd®Z§ e§« ejP e=jR « e*ree:e0f ZªneZª G d¯ d°eª« Z«y# e)$ r dZ(Y Jw xY w# e)$ raZ@ eAe@« j
d « r e j d e5« eAe@« j
d!« r e j eAe@« e5« dZ@[@ww xY w)Ûé )Ú 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__© ó ú<H:\Change_password\venv_build\Lib\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Ø ii¨¯©Ð 2EÜ LEØ 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$ c ó. 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 PPM file format drivers.
|
|
It is called when opening or saving images.
|
r N)ÚBmpImagePlugin)ÚGifImagePlugin)ÚJpegImagePlugin)ÚPpmImagePlugin)ÚPngImagePlugin)Ú _initializedÚ r¥ Ú ImportErrorr¦ r§ r¨ r© )r¥ r¦ r§ r¨ r© s r% Úpreinitr G sË ô qÒØð Ý$á Ð ~ð Ý$á Ð ~ð Ý%á Ð ð Ý$á Ð ~ð Ý$á Ð ~ð Løô7 ò Ù ð ûô ò Ù ð ûô ò Ù ð ûô ò Ù ð ûô ò Ø àLð úsU
|
A
|
|
A ¤
|
A( °
|
A7 ¼
|
B Á
|
AÁAÁ A%Á$A%Á( A4Á3A4Á7 BÂBÂ BÂBc óJ t dk\ ryt j d« d } t D ]< } t j d|« t | d| t « t « g « > t st rda yy# t $ r!}t j d||« Y d}~td}~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 Fú.r z Importing %sz Image: failed to import %s: %sNT) rª r Ú
|
rpartitionr ÚloggerÚdebugÚ
|
__import__ÚglobalsÚlocalsr¬ rl ro )Ú parent_nameÚpluginÚes r% Úinitr¹ t s ô qÒØä×%Ñ% cÓ*¨1Ñ-KÜò Fð FÜ LL ¨Ô 0Ü + a¨ xÐ0´'³)¼V»XÀrÕ JðFõ tØ ØØ øô ò FÜ LLÐ9¸6À1× EÑ Eûð Fús 9A8Á8 B"ÂB Â B"c ó |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)Ú
|
isinstanceÚtuplerr ÚKeyErrorÚgetattrÚcoreÚAttributeErrorÚOSError)r{ Ú decoder_nameÚargsr Údecoderr¸ Úmsgs r% Ú _getdecoderrÈ ó° ð |ØÜ eÔ $Øwð,Ü<Ñ(ñ tÐ+d UlÒ+Ð+øô ò Ù ð úð
|
"ä$ < .°Ð 9Ó:øÜ ò "Ø nÐ5Ücl Ð!ûð"úñ 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
|
dZd dZd dZeZd dZd dZ d dZ
|
e
|
Z d dZ 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__Ð s Ø
|
Ø r$ c óF t | j | j « S rÓ )rÑ rÔ rÕ ©rÖ s r% Ú__neg__zImagePointTransform.__neg__Ô 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__à s Øuf}Ð r$ c ó || z S rÓ r# rÜ s r% Ú__rsub__z ImagePointTransform.__rsub__ã 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__æ ó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$ 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ô ó s< ñ Ô AÓ &Ó'AÜ",¨QÔ0CÔ"DAGGQXXÐ ÐPÈ1ÈaÈ&ÐPr$ c ó e Zd Z ddZy)ÚSupportsGetDatac ó y rÓ r# rÙ s r% ÚgetdatazSupportsGetData.getdataÿ s à*-r$ N)rë z tuple[Transform, Sequence[int]])r r! r" rø r# r$ r% rö rö þ s ð.à (ô.r$ rö c óÈ e Zd ZU dZdZded< dZded< dZd_dZe d`d« Z
|
e
|
j dad « Z
|
e dbd
|
« Z e dbd « Z e dcd « Ze ddd « Ze dbd« Zej ded« ZdfdZd Zd Zd_dZd_dZd_dZ dg dhdZdidZdddZdjdZdkdZdldZ dld Z e dmd « Z dnd Z do dpd Z dqd Z!drd!Z"dsdtd"Z#dudvd#Z$ ds dwd$Z%dxd%Z&d_d&Z'ddde(jR d'f dyd(Z*d'dd)de+jX f dzd*Z-d{d+Z.e.Z/dod|d,Z0 d}d-Z1 d~d.Z2dd/Z3dd0Z4dd1dd2Z5 d dd3Z6dodd4Z7d
d5Z8dd6Z9dd7Z:d_d8Z;dd9Z<dd:Z=ddd;Z>e dd<« Z?d_d=Z@ dd>ZAdd?ZB dg dd@ZC dg ddAZD dg ddBZE d ddCZF do ddDZGddEZH d ddFZI d ddGZJ ddHZK do ddIZL ddJZM d ddKZN do ddLZOePj¢ dMdddf ddNZR do d dOZSd¡dPZTd¢dQZUdod£dRZVd¤dSZWd¥dTZXdbdUZYePj´ dVf d¦dWZ[dePj¢ dXdf d§dYZ\ePj¢ df d¨dZZ]d©d[Z^dªd\Z_d«d]Z`d¬d^Zay)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__ 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 ä dhh¤ Ô .Ø((++Ð ØxxÐ#Ð#Ð#Øxxr$ 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) ó àyy|Ðr$ c ó | j d S ry r rÙ s r% r| z Image.height- r r$ c ó | j S rÓ )r rÙ s r% r z
|
Image.size1 ó àzzÐr$ c ó | j S rÓ )r rÙ s r% r{ z
|
Image.mode5 r r$ c óf | j xr | j j xs | j S rÓ )rÿ r Ú _readonlyrÙ s r% r zImage.readonly9 s$ àÒ.TXX× .Ñ .ÒA°4·>±>ÐAr$ c ó || _ y rÓ )r )rÖ r s r% r 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 r r Úcopyr« rd r )rÖ r Únewrd s r% Ú_newz
|
Image._newA sy ÜgØØGG ØGG Ø 77kÑ !Ø||Ø "ll× /Ñ /Ó 1 å*à 7l× 7Ñ 7Ó 9 Ø99>>Ó#Ø
|
r$ c ó | S rÓ r# rÙ s r% Ú __enter__zImage.__enter__Q s Ø r$ c ó ddl m} t | |j « r%t | dd« r| j « d | _ y y )Nr ©rb Ú _exclusive_fpF)r« rb r½ rÀ Ú _close_fpÚfp)rÖ rÅ rb s r% Ú__exit__zImage.__exit__T s7 Ý ä dI× /Ñ /Ô 0Üt_¨eÔ4ØÔ ØDGð 1r$ 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Úhasattrr% Úcloser Ú
|
ValueErrorrÿ rÙ s r% r+ z Image.close\ sO ô 4 Ô %Ü||wÒ&¬7´3Ð8KÔ+LØÔ Ø)-DHô
|
!¤Ð,GÓ!HÓIr$ c óp | j « | j j « | _ d| _ y r )Úloadr r r rÙ s r% Ú_copyz Image._copyp s# Ø Ø'',,.Ø r$ c ó^ | j r| j « y | j « y rÓ )r r/ r. rÙ s r% Ú_ensure_mutablezImage._ensure_mutableu s Ø ==Ø JJLà IIKr$ 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Úosr+ Úendswithr. r Úsave_ppmÚsave)rÖ Úfilerû ÚoptionsÚsuffixÚfÚfilenames r% Ú_dumpz Image._dump{ s ð Ù Ø\FáÜ"×*Ñ*¨6Ó2KAxÜ HHQKàHØ×$Ñ$ VÔ,Ø# fÑ,à á 5 Ø GG× Ñ XÔ &ð ð DIIh Ñ 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 r Ú
|
getpaletteÚtobytesrÜ s r% Ú__eq__z Image.__eq__ s Ø >> § ¡ Ñ 0ØÜ%¤Ô'Ð'Ð'à IIÑ #ò 2Ø UZZÑ'ò 2à UZZÑ'ò 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 )rB 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ÜtHQ<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¯ rG rH r rI r rv N)ÚtextrB 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)zHelper function for iPython display hook.
|
|
:param image_format: Image format.
|
:returns: image as bytes, saved into the given format.
|
N)ÚioÚBytesIOr9 Ú ExceptionÚgetvalue)rÖ Ú image_formatÚkwargsÚbs r% Ú _repr_imagezImage._repr_image° sK ô JJLð Ø DIIa Ñ 0¨Ò 0ð zz|Ðøô ò Ùð ús : º AÁAc ó( | j dd¬« S )zjiPython display hook support for PNG format.
|
|
:returns: PNG version of the image as bytes
|
ÚPNGr )Úcompress_level©rZ 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{ rD r
)rÖ r s r% Ú__array_interface__zImage.__array_interface__Ë s\ ð @IÈ!¸nØ 99Ò ð ,, u¨cÓ2CKà ,,.CKÜ'7¸Ó'=Ñ$G c)nØ
|
r$ c óV | j « | j j « S rÓ )r. r Ú__arrow_c_schema__rÙ s r% ri zImage.__arrow_c_schema__Ø s Ø Øww×)Ñ)Ó+Ð+r$ c ó | j « | j j « | j j « fS rÓ )r. r ri Ú__arrow_c_array__©rÖ Úrequested_schemas r% rk zImage.__arrow_c_array__Ü s2 ð Ø×*Ñ*Ó,¨d¯g©g×.GÑ.GÓ.IÐJÐJr$ c ó | j « }| j | j | j | j « |gS rÓ )rD r r{ r rC )rÖ Úim_datas r% Ú __getstate__zImage.__getstate__â s1 Ø,,.Ø 499 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× r r r rÁ r r Ú
|
putpaletteÚ frombytes)rÖ Ústater r{ r r rf s r% Ú __setstate__zImage.__setstate__æ sn Ü tÔ Ø*/°°¨)Ñ'dD' 4Ø Ø
|
Ø
|
Ü((4 Ó&Ø Ð)Ñ )©gØ OOGÔ $Ø 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 « 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 re r# r$ r r3 zencoder error z in tobytes)r~ r½ r¾ r{ r. r} r| rÏ Úsetimager r« rb ÚmaxÚMAXBLOCKr ÚencodeÚappendÚ RuntimeErrorÚjoin) rÖ rÍ rÅ Ú encoder_argsr¸ rb ÚbufsizeÚoutputÚbytes_consumedÚerrcoderf rÇ s r% rD z Image.tobytesñ s ð0 ! Ü |Ó Ò !¤j° ¸a± Ä%Ô&Hà'¨?Là 5Ò \°RÒ%7Ø 99Là à ::?dkk¨QÒ .Øô <° Ó >Ø
|
|
477Ôå äi×(Ñ(¨$¯)©)°A©,¸Ñ*:Ó;àØØ,-¯H©H°WÓ,=Ñ )NG TØ MM$Ô ÙØð ð
|
Q;Ø" 7 )¨;Ð7CÜ sÓ#Ð #àxxÓ Ð r$ c óZ | j « | j dk7 r d}t |« | j d« }dj d| d| j
|
d dj d « d| d
|
| j
|
d dj 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 };)r. r{ r, rD r~ r r{ )rÖ ÚnamerÇ rf s r% ÚtobitmapzImage.tobitmap* s³ ð Ø 99Ò Ø CÜ S/Ð !Ø||EÓ"Øxxà4& ¨¯ © °!© ~°RÐ8×?Ñ?ÀÓHØ4& ¨¯©°1© ¨°bÐ9×@Ñ@ÀÓIØ tf 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 « |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 re r# znot enough image datazcannot decode image data) r} r| r~ r½ r¾ r{ rÈ rx r Údecoder, )rÖ rf rÄ rÅ Ú decoder_argsÚdÚsrÇ s r% rt zImage.frombytesD sÉ ð ::?dkk¨QÒ .Ø à Ü |Ó Ò !¤j° ¸a± Ä%Ô&Hà'¨?Lð 5Ò \°RÒ%7Ø 99Lô <° Ó >Ø
|
|
477ÔØ HHTNà Q419Ø)CÜ S/Ð !Ø Q419Ø,CÜ S/Ð !ð r$ c ót | j z| j rm| j j rV| j j « \ }}| j j | j j ||« d| j _ d| j _ d| j v r
|dv rt | j d t « r*| j j | j d d« n(| j j | j d « d| j _ nS| 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ÿ r Údirtyrø r rs r{ Úrawmoder r½ ÚintÚputpalettealphaÚputpalettealphasrC Ú pixel_accessr )rÖ r{ Úarrs r% r. z
|
Image.loadi s4 ð 88Ñ D§L£L°T·\±\×5GÓ5Gà ×,Ñ,Ó.ID#Ø GG× Ñ t||× 0Ñ 0°$¸Ô <Ø!"DLLÔ Ø#'DLLÔ Ø §¡Ñ*¨t°|Ñ/CÜ dii¨Ñ 7¼Ô=ØGG×+Ñ+¨D¯I©I°nÑ,EÀqÕIàGG×,Ñ,¨T¯Y©Y°~Ñ-FÔGØ$* Õ!à'+§w¡w×'9Ñ'9ØLL×%Ñ% t§|¡|×'8Ñ'8ó( Ô$ð 88Ð Ø77×'Ñ'¨¯ © Ó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( rs| 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 éÿ )ry Úminr )r ÚvÚvalues r% Úconvert_transparencyz+Image.convert.<locals>.convert_transparencyä s\ ð aD 1 Q¡4K¨!¨A©$°°1±©+Ñ 5¸¸!¹¸qÀ¹t¹ Ñ CÀaÈÁdÈSÁjÑ PEÜ 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>í 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 r .z0Couldn't allocate palette entry for transparencyr )r r r )ÚImageCmsÚsRGBr )r ztuple[float, ...]r ztuple[int, int, int]rë r ).r. r r{ r r r, r Úconvert_matrixr r r~ r¾ ÚrangeÚquantizeÚsplitÚmergeÚconvert_transparentr½ ÚbytesÚwarningsÚwarnr rs ÚgetcolorÚstrÚputpixelÚconvertÚgetpixelr r r rV rX r« rd rC r rU r« Ú createProfileÚbuildTransformÚapplyrP rT r r¿ ) rÖ r{ r¦ Úditherr ÚcolorsÚhas_transparencyrÇ r Únew_imÚrÚgrY ró ÚrgbrO Ú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Ø Ù § ¡ Ò)±&Ø99;Ð á à<Ñ'Ø*Ü oÐ%Ø×'Ñ'¨¨fÓ5BØYYr]FÙ D§G¡G§M¡M°QÒ$6Ø %{{¨>Ñ : ð8Ø(ð8Ø-Að8àó8ð 3;Ù#7¸À Ó#MLÜY !^Ü#(õ )ä!&¤s¨<Ó'8Ó!9ô)ó $Lð /; NÑ+ØMà 99Ò Øs{Ø}} VÓ,Ð,Ø Ø !ZZ\
|
1aÜE A q¨! 9Ó-ØLL Ó(Ü T A q 6Ó*Ð*àØ â Ø Ð 4Ñ4¸À Ñ9OØ UÒ" tÐ/KÑ'Kð ØGG×/Ñ/°°d·i±iÀÑ6OÓPóð KK Ð/Ø ØÐ /Ò/°DÐ<MÒ4MØIInÑ-Ü a¤Ô'ä MMð3ôð #'Kô " $§)¡)¨VÓ 4GØyy CÒ'Ø #||Ð 7Ð7Ð 7Ø ×*Ñ*¨4¯<©<¸¿ ¹ ×9JÑ9JÔKÜ% a¬Ô/Ø"VCØ#*§?¡?Ð#>Ð >Ð#>ð AØ$+§O¡O×$<Ñ$<¸QÀÓ$E ð yØ #à ×(Ñ(¨°Ô3à <Ñ/Ø&-§o¡o°dÓ&;Gð '.§o¡o°eÓ&<GØ &× /Ñ /°Ó 7àcÒ! dÐ.BÑ&BØIInÑ-Ø " ä a¤Ô'ØGG×,Ñ,¨QÕ/Ü ¤3Ô'ØGG×+Ñ+¨A¨qÕ1àJCÜ$ S/Ð)à 3;7¤g×&6Ñ&6Ò6Ø×!Ñ! &Ó)BØYYr]FÝ &à 6\× 6Ñ 6Øvyy×+Ñ+¨EÓ2ó FNñ ð KK Ð/ØÐ ð VØ28·.±.×2IÑ2IÜ U¤3¨ 8_¨dÓ3Ø ó3FKK Ñ/ð M6Mà TYY Ð%Ñ %ØBØu}Ø77Ð"9Ñ9Ø FÓ+BØ WW
|
à !
|
ØÐ 4Ñ4Ý&à ×-Ñ-¨fÓ5Ø ×,Ñ,¨UÓ3Ø*,¯'©'°UÒ*:C ;ÀÀsÀ Ø $× 3Ñ 3Ø QK ¨!¡¨b¯g©g°tó ð ! rÓ*Ð*ð >Ü×*Ñ*Fð -Ø vÓ.Bð 2 Ø ;Ñ 7¬g×.>Ñ.>Ò#>Ý &à 6\× 6Ñ 6°u¸b¿m¹mÈEÓ>RÓ SFNÙ à NÐ+Ø Ð Ø{{cÒ! f§n¢nð Ø28·.±.×2IÑ2IÜ U¤3¨ 8_¨dÓ3°Vó3FKK Ñ/ð ð /3 NÑ+Ø øôm $.ò AÜ#& q£6Ð-SÒ#Sð )-¡Aä*4°S«/¸qÐ$@õ %&ûð Aûôd !ò Vð NÐ3Ü MMÐ"TÕUØMð Vûô@ ò
|
-ð -ä& t§y¡yÓ1ØtyyÒ(ØØWW__ XÓ.ØZZ fÓ-øÜò -Ø*Ü o¨1Ð,ûð -úò ð
|
-ûô4 "ò Ø NÐ3Ü1vÐ!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 r )r. rZ r[ r{ r] r^ r, r r¹ r r r r¯ r« rd ÚgetpalettemoderC r~ ) rÖ r¿ ÚmethodÚkmeansr r¾ rÇ r rÁ rd r{ Ú palette_datas r% r¯ zImage.quantize s ðF à >ä ×'Ñ'FØyyFÒ"Ü!×,Ñ,à 99Ò 6Ü × Ñ Ü × "Ñ "ð2
|
ñ $
|
ð Hð ô S/Ð !á à LLNØ||sÒ"Ø2Ü oÐ%Øyy Ñ,ØOÜ oÐ%Ø f¨g¯j©jÓ9BØYYr]FØ??Ð.Ð .Ð.Ø $__× 1Ñ 1Ó 3FNØMà A:Ø/CÜ S/Ð !à YYtww×'Ñ'¨°¸Ó?Ó @å"àuu×#Ñ#Ó%Øuu×'Ñ'¨¨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.
|
)r. r r r rÙ s r% r z
|
Image.copyë s& ð Øyy Ó(Ð(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')r r, r. r Ú_cropr )rÖ ÚboxrÇ s r% Úcropz
|
Image.cropø sx ð ;Ø99;Ð à q6CF?Ø:CÜ S/Ð !Ø Vc!f_Ø;CÜ S/Ð !à Øyy 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.
|
)r% r ÚroundÚabsÚ_decompression_bomb_checkrÙ )rÖ r rØ Úx0Úy0Úx1Úy1Úabsolute_valuess r% r× z Image._crop sX ô S¤#¤e¨S£/Ó2BBä r Bw<¬¨R°"©W« Ð6ä! /Ô2àwwB 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 r. Úcallabler* Ú TypeErrorr½ ÚMultibandFilterr r r ræ r® Úgetbandr± r{ )rÖ ræ rc rÇ Ú multibandÚcÚimss r% ræ z Image.filterA sÚ õ "à ä FÔ ÙXFÜvxÔ(ØRCÜC.Ð ä v {×'BÑ'BÓC Ø 77==AÒ ¡Ø99V]]¨4¯7©7Ó 3Ó4Ð 4ô CHÈÏÉÏ É ÓBVö
|
Ø=>DIIfmm D§G¡G§O¡O°AÓ$6Ó7Õ 8ð
|
ð
|
ô TYY Ó$Ð$ùò
|
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.
|
|
)r. r Úgetbbox)rÖ rð s r% rò z Image.getbboxf s ð ØwwzÓ*Ð*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)r. r{ r Ú histogramr® r~ Ú getcolors)rÖ Ú maxcolorsÚhr¥ Úouts r% rõ zImage.getcolorsy s ð Ø 99Ñ 'Ø×!Ñ!Ó#AÜ?DÀS»zÖ+R¸!ÈQÈqËT¨Q¨q©T°1ªIÐ+RCÐ+RÜ3x)Ò#ØØJØww× Ñ Ó+Ð+ùò ,Ss Á
|
BÁ Bc ót | 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.
|
)r. r rê )rÖ Úbands r% rø z Image.getdata s/ ð$ Ø Ð Ø77?? 4Ó(Ð (Øwwr$ c óì j « j j dkD r1t fdt 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)r. r r r¾ r® rý rÙ s `r% rý zImage.getextrema© sO ø ð Ø 77==1Ò ÜÓWÄ%ÈÏÉÏ É ÓBVÔWÓWÐ WØww×!Ñ!Ó#Ð#r$ c ó dddfd 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_nameÀ s Ü66* 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 )NrN )ÚattribÚitemsÚlistr r½ r| rN )
|
ÚelementÚkr r¡ ÚchildrenÚchildr Ú child_valuer Ú get_values
|
r% r z Image.getxmp.<locals>.get_valueà sÚ ø Ø@GÇÁ×@TÑ@TÓ@V×$W¹¸¸1¡X¨a£[°!¡^Ð$WEÑ$WÜG}HÙØ %ò 2EÙ# E§I¡IÓ.DÙ"+¨EÓ"2KØu}Ü )¨%°©+´tÔ <Ø+0°©;¨-E $KØ d ×*Ñ*¨;Õ7à&1d ð2ð Lñ Ø<<Ø$+§L¡LE&Mð Lð ||Ð#ùó! %Xs C
|
z5XMP data cannot be read without defusedxml dependencyÚxmps )r r· rë r· )r r` rë zstr | dict[str, Any] | None)r r´ rµ r Ú
|
fromstringÚrstripr )rÖ Úrootr r s @@r% Úgetxmpz Image.getxmp¸ st ù ó /ö ô( Ð Ü MMÐQÔ RØIØ Ñ !ØIÜ×%Ñ% d§i¡i°Ñ&6×&=Ñ&=¸hÓ&GÓHÙÓ"¡I¨d£OÐ4Ð4r$ c óR | j t « | _ n"| j j r | j S d| j _ | j j d« }|âd| j v rDt
|
j dj | j d j d« dd « « }nt | d« r| j j | j _ | j j | j _ | j j | j | j j" « || j j% |« t& j( j* | j vr| j j d « }d
|
}|s | j j d « x}rd }|rKt- j. ||« }|r3t1 |d « | j t& j( j* < | 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_v2zXML:com.adobe.xmpz tiff:Orientation(="|>)([0-9])r s tiff:Orientation(="|>)([0-9])r1 )r ÚExifÚ_loadedr Úgetr³ Úfromhexr~ r° r* r Ú_bigtiffÚbigtiffÚ_endianÚendianÚ load_from_fpr" Ú_offsetr. r
|
ÚBaseÚ Orientationr Úsearchr )rÖ Ú exif_infoÚxmp_tagsÚpatternÚmatchs r% Úgetexifz Image.getexifß s ð ::Ð Ü DJØ ZZ× Ò Ø::Ð Ø !
|
|
ÔàIIMM &Ó) Ø Ð Ø&¨$¯)©)Ñ3Ü !MMØGGDIIÐ&=Ñ >× DÑ DÀTÓ JÈ1È2Ð NÓOó ô xÔ(Ø%)§[¡[×%9Ñ%9
|
|
Ô"Ø$(§K¡K×$7Ñ$7
|
|
Ô!Ø
|
|
×'Ñ'¨¯©°·±×1DÑ1DÔEØ Ð Ø JJOOIÔ &ô ==× $Ñ $¨D¯J©JÑ 6Øyy}}Ð%8Ó9HØ#CGÙ¨T¯Y©Y¯]©]¸5Ó-AÐ!A Ð!AØ;ÙÜ '¨8Ó4ÙÜ<?ÀÀaÁ»MDJJx}}× 8Ñ 8Ñ9àzzÐr$ c ó | j | j j sy d| j _ | j « y rA )r r r' 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.
|
)r. r ÚptrrÙ s r% Úgetimz Image.getim s ð Øww{{Ð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)r. r rÑ r, r rC )rÖ r r{ s r% rC zImage.getpalette s` ð ð Ø77×)Ñ)Ó+Dð ?ØGÜDGG×&Ñ& 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{ r r r7 rÙ s r% Úhas_transparency_datazImage.has_transparency_data1 sZ ð IIÐ;Ñ ;Ø §¡Ñ*àØ 99Ò Ø<<Ð+Ð +Ð+Ø<<×$Ñ$×-Ñ-¨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 r r r3 r2 r )
|
r{ r r« rd rC r½ r³ Ú enumerater r )rÖ rd r r r¥ Úalphas r% Úapply_transparencyzImage.apply_transparencyG sÅ ð 99Ò ~°T·Y±YÑ >Ø å"à// &Ó)ØÐ"Ð"Ð"Øyy Ñ0 Ü l¤EÔ *Ü % lÓ 3ò +5Ø%*A Ò"ñ +ð -.GL 1Ñ$ qÑ(Ñ )Ø0|×0Ñ0°¼¸w» ÓH Ø Ôà IInÑ %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.
|
)r. r rº r¾ )rÖ Úxys r% rº zImage.getpixel_ s& ð Øww× Ñ ¤ 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.
|
)r. r Ú getprojectionr )rÖ rI Úys r% r; zImage.getprojectionn s6 ð Øww×$Ñ$Ó&1ÜAwQÐ Ð 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 )r. r rô r{ rý ©rÖ ÚmaskÚextremas r% rô zImage.histogramz s ð. Ù Ø IIKØ77×$Ñ$ V¨T¯W©WÓ5Ð 5Ø 99
|
Ñ "Ø77×$Ñ$Ø"Ð.óð Ø48·O±OÓ4Eóð ð ww× Ñ Ó"Ð"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þ r> )r. r Úentropyr{ rý r? s r% rC z Image.entropy s ð$ Ù Ø IIKØ77?? 6¨4¯7©7Ó3Ð 3Ø 99
|
Ñ "Ø77??Ø"Ð.óð Ø48·O±OÓ4Eóð ð wwÓ Ð 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 « }nt |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 r, r~ r r· r« rF r¶ r{ r. r¹ r r1 Úpaste)rÖ r rØ r@ rÇ r rF Úsources r% rG z Image.paste· sf ô\ c5Ô !ØÐ ØUÜ oÐ%àDØCà ;ØCä s8q=ä"eÔ$ØwwÜD¤%Ô(Øyyð EÜ oÐ%Ø CFT !WÑ$ c¨!¡f¨t°A©wÑ&6Ð7Ñ 7Cô b#Ô Ý $à ×(Ñ(¨¨T¯Y©YÓ7FÜ EÔ "Ø GGIØyyBGGÒ#Ø99 Ò%¨¯©Ð8NÑ)Nà D§I¡IÓ.BØUUFàFà × Ñ Ô á Ø IIKØ GGMM& # t§w¡wÕ /à GGMM& #Õ &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½ r r¾ r, r~ r r rÙ r} r| Úalpha_compositerG )
|
rÖ r ÚdestrH rÇ Úoverlay_crop_boxÚoverlayrØ Ú
|
backgroundÚresults
|
r% rJ zImage.alpha_composite sK ô &¤4¬ -Ô0Ø2CÜ S/Ð !Ü$¤¤u Ô.Ø7CÜ S/Ð !ä v;!Ò Ü $ V}Ñ Ü [AÒ Ü $ V}¨r¯w©wÑ 6Ñ à>CÜ S/Ð !ä4yA~Ø>CÜ S/Ð !Ü v;?Ø/CÜ S/Ð !ð v¨¯©Ñ /Ò /ØGàggÐ .Ó/Gô DkT !W w§}¡}Ñ 4°d¸1±gÀÇÁÑ6NÐ OÑOð &499Ñ$Ò $Ø Jà 3 Jä ¨WÓ5Ø
|
|
63Õ 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)r. r½ ÚImagePointHandlerÚpointrç r{ rô r r Úpoint_transformr® r r, rÛ )rÖ Úlutr{ rÔ rÕ r¥ ÚflatLutrÇ s r% rR z Image.pointK sö ðB ä cÔ,Ô -Ø99T?Ð "ä C=àyyÐ .Ñ.ô !0°Ó 4 vØyy §¡×!8Ñ!8¸ÀÓ!GÓHÐHä',¨S£zÖ2 !s1vÒ2°T·W±W·]±]ÑBGàGà 99Ò à?CÜ S/Ð !à 3;Ø)0Ö1 AuQxÐ1GÐ1Øyy 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ª r2 z alpha channel could not be addedNúillegal image moder r r2 )r r r r )r1 r{ r r Úsetmoder r, r¹ r r¿ r½ rw r. Úfillbandr r Úputband)rÖ r6 r{ r¸ r rÇ rú s r% ÚputalphazImage.putalpha s ð × Ñ Ô à 99Ð 0Ñ 0ð -Ü" 4§9¡9Ó-°Ñ3ð!ØGGOO DÔ)ð "WW\\
|
ð
|
99 Ñ $ØDàDä eUÔ #àzz Ñ+Ø*Ü oÐ%Ø JJLØzzSÒ Ø cÓ*ð Ø× Ñ uÔ-ð
|
à $Õ'øôG '¬
|
Ð3ò !à ¨Ó.BØwwÐ&:Ñ:Ø @Ü (¨o°1Ð4Ø DGGûð !ûô ò -Ø*Ü 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)r1 r Úputdata)rÖ rf rÔ rÕ s r% r] z Image.putdata¾ s$ ð( × Ñ Ô à e VÕ,r$ c ó
|
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 | _
|
|| _ d|v rd
|
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", or a mode
|
that can be transformed to "RGB" or "RGBA" (e.g. "R", "BGR;15", "RGBA;L").
|
r r rr rW N©r r2 r r r r ) r« rd r{ r, r½ r re r r r³ r r. )rÖ rf r rd rÇ r s r% rs zImage.putpaletteÖ sÕ õ. #à 99Ð 2Ñ 2Ø&CÜ S/Ð !Ü dL× 5Ñ 5Ô 6Ø||Ð'Ø*,×*Ñ*¨4¯<©<¸¿ ¹ ÓFà3,×3Ñ3¸D¿L¹LÔIØ ! ä d¤EÔ*Ü T{Ø&l×&Ñ& w°Ó5GØ D§I¡IÑ -T°3
|
Ø Ø&)¨W¡nF¸% ÔØ r$ c ó | j « | j dv rt |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.
|
r )r2 r3 r r3 r2 r N)
|
r1 r{ r½ r r¾ r~ r r¶ r r¸ )rÖ r9 r¡ r6 Ú palette_indexs r% r¸ zImage.putpixel s¾ ð0 × Ñ Ô ð IIÑ $Ü5¤4¬ -Ô0ÜE
|
fÑ$ð yyDÒ Ü$'¨£J°!¢Oa¸Ø bq Ø<<Ð+Ð +Ð+Ø LL× 1Ñ 1´%¸³,ÀÓ EMØ.2¯i©i¸4Ò.?] EÑ*À]EØww× Ñ 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 r )r r rW r2 r r r r3 c 3 ó& K | ] }|d z yw)r2 Nr# ©r¤ r¥ s r% r§ z&Image.remap_palette.<locals>.<genexpr>F s è ø Ò*F°a¨1°6Ñ*Fùs i r$ r r r_ z;Lr r )r« rd r{ r, r. r rÑ rC Ú bytearrayr® r~ r5 r r r rs rD r¹ r Ú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 õ #à 99JÑ &Ø&CÜ S/Ð !àØ Ø Ð !ØyyCÒ Ø Ø #ww× 5Ñ 5Ó 7 Ø 6Ò)Ø EØ!%§¡×!3Ñ!3°LÀ,Ó!Oä!*Ñ*F¼5À»:Ô*FÓ!FÜ Ó 3Ò &ØEØ!Là Øc ô (¨Ó 1ò +NA{Ø ^ØeÑ# k°EÑ&9¸EÑ&Að ñ Mð *+M+Ò &ð +ô0 $ MÓ2àyy{Ø
|
à0|×0Ñ0Ø /°EÑ"9ô
|
ð ×Ñ<¨ ¸Ñ)<¸d¿l¹l×>RÑ>RÓ>TÔUà||CÓ à |Ô4Ø0|×0Ñ0° À}ÔU à TYYÑ &ð 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 )zExpands the box so it includes adjacent pixels
|
that may be used by resampling with the given resampling filter.
|
rL r1 r r2 r )Ú_filters_supportry 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Øq6C F? d¨1¡gÑ-Øq6C F? d¨1¡gÑ-Ø" WÑ, Ø" WÑ, ô 3s1v Ñ)Ó*Ó +Ü 3s1v Ñ)Ó*Ó +Ü ! dii¨¨A©°Ñ(:Ó ;Ó <Ü ! dii¨¨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- | 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Ø )rE rJ rF rH rK rG rI r~ r, r r¾ r r{ r¹ Úresizer. r rz r rç Úreducerw r r ) rÖ r rt rØ Ú reducing_gaprÇ ræ Úfiltersr Úfactor_xÚfactor_yÚ
|
reduce_boxÚfactors r% r z Image.resize sZ ðL Ð Ü!×)Ñ)HØ Ü × Ñ Ü × Ñ Ü × Ñ Ü × Ñ Ü NNÜ × Ñ ð
|
ñ
|
ð 0°¨z¸Ð<Cô
|
×'Ñ'Ð)CÐDÜ ×'Ñ'Ð)CÐDÜ ×(Ñ(Ð*EÐFÜ ×'Ñ'Ð)CÐDÜ ^^Ð%;Ð<Ü ×'Ñ'Ð)CÐDð ö
|
àð !9+R q¡ {¨!Ò,ð
|
Gð
|
ð U499 W¨S¨b \Ó2Ð3°4¸À¹ °}ÐEÑ ECÜ S/Ð !à Ð #¨ °sÒ(:Ø7CÜ S/Ð !à ;Ø499Ñ$CäT{Ø 99Ò ¨°·±Ñ(:Ò!:Ø99;Ð à 99
|
Ñ "Ü!×)Ñ)Hà 99Ñ &¨8´z×7IÑ7IÒ+IØ T°6Ñ :¸4¿9¹9Ñ EÓFBØ4 ¨3Ó/BØ::diiÓ(Ð (à à Ð #¨´J×4FÑ4FÒ(FÜC F S¨¡VO¨t°A©wÑ6¸ ÑEÓFÒKÈ!HÜC F S¨¡VO¨t°A©wÑ6¸ ÑEÓFÒKÈ!HØ!|x¨!|Ø !× /Ñ /°´d¼:ÀxÓ6PÐRUÓ V
|
Ø" HÐ-ô § ¡ Ô,ð KK ¨JKÔ7ä d¨F¸
|
ÓCð ð Vj¨mÑ+¨xÑ7ØVj¨mÑ+¨xÑ7ØVj¨mÑ+¨xÑ7ØVj¨mÑ+¨xÑ7ð ð yy ¨¨h¸Ó<Ó=Ð=ùòk
|
s Ã#M 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½ r r¾ r r r{ r¹ r r. r r )rÖ r rØ r s r% r z Image.reduce sÅ ô" &¤4¬ -Ô0Ø fÐ%Fà ;Ø499Ñ$Cà VÒ v°· ± Ñ'9Ò 9Ø99;Ð à 99Ñ &Ø T°6Ñ :¸4¿9¹9Ñ EÓFBØ6 3Ó'BØ::diiÓ(Ð (à àyy ¨°Ó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# ) rI r< r¦ ró rY rì r r¸ r= s r% rÎ z Image.rotate.<locals>.transformz sA Ø!'Ñ Q1aAØq51q5= 1Ñ$ a¨!¡e¨a°!©e¡m°aÑ&7Ð7Ð 7r$ r r4 rN )Ú fillcolor)rI rê r< rê r¦ z list[float]rë útuple[float, float])r Ú transposer0 r9 r} r| r8 r: r rr ÚradiansrÛ ÚcosÚsinr| rs ry Úfloorr rÎ r> r? )rÖ Úanglert ÚexpandÚcenterÚ translater Úwr÷ Ú
|
post_transr¦ rÎ ÚxxÚyyrI r< Ú transformed_xÚ transformed_yÚnwÚnhs r% Úrotatez Image.rotate% s¦ ðD ñ )ØzØyy{Ð"Ø|Ø~~¤i×&:Ñ&:Ó;Ð;Ø Ñ!¡v°·±¸t¿{¹{Ò1JØ~~Ø+0°Bª;I×'Ñ'óð Ü<E×<PÑ<Póð ð, yy1à Ð Ø Jà"JØ >Ø!eQ U^Fä eÓ$Ð$ä $((5/ 2Ó &Ü $((5/ 2Ó &Ø Ü 488E?Ð" BÓ 'Ü $((5/ 2Ó &Ø ð
|
ó 8ñ )Ø AYJ A Ñ &¨°©¨
|
°ZÀ±]Ñ(BÀFó
|
Ñ q 6!9ð q VAYÑ Øq VAYÑ á àBØBØ ! Q ¨!¨Q¨°!°Q°Ð8ò )1Ù/8¸¸A¸vÓ/FÑ, }Ø -Ô(Ø -Õ(ð )ô 3r7Ó#¤d§j¡j´°R³Ó&9Ñ9BÜ3r7Ó#¤d§j¡j´°R³Ó&9Ñ9Bñ
|
$-¨r°A©v¨Y¸©_ÀÀQÁ¸iÈ#¹oÈvÓ#VÑ F1IvayØrqAà~~Ø FI×$Ñ$ 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 « }t « t j j |« d j « }t |t « r|j « n|}|s |t vr
|
t# « t | }ddlm}
|
t | |
|
j* « rZt j j- |« t j j- | j. « k( r| j1 « n| j3 « |j5 d d« } || _ t9 | d
|
i « } | j; | « d | _ |j? « t@ vr
|
t# « | s)| ?|jC d « r.|j? « tD v rtD |j? « } nt@ |j? « } d}|r`t j jG |« }|jC d d« rtI jJ |d« }n.tI jJ |d« }ntM tN t |« } | | ||« | | _, |r|jS « yy# t $ r Y ¨w xY w# t$ $ r}d| } t' | « |d}~ww xY w# tP $ r< |r|jS « |r& t jT |« # tV $ 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 r6 Úfspathr( ÚstdoutÚbufferr r* r r ÚpathÚsplitextÚlowerr½ r³ r rq r¹ r¿ r, r« rb Úabspathr> r1 r. ÚpopÚ_default_encoderinforÀ Ú_attach_default_encoderinfoÚ encoderconfigÚupperro r rp ÚexistsÚbuiltinsÚopenr r rU r+ ÚremoveÚPermissionErrorr° )rÖ r" rû Úparamsr> Úopen_fpÚ filename_extÚextr¸ rÇ rb r¯ r° Ú save_handlerÚcreateds r% r9 z
|
Image.save sÞ ð\ !#ØÜ 2;Üyy }HØGØ 3::Ò ð ÜZZ×&Ñ&ñ G B¨Ô /´G¸B¿G¹GÔ4Däyy §¡Ó)Hä äww×'Ñ'¨Ó1°!Ñ4×:Ñ:Ó< Ü'1°,ÄÔ'Fl×!Ñ!Ô#ÈLáØ)Ñ#Üð -Ü" 3 õ
|
ô dI× /Ñ /Ô 0´R·W±W·_±_Ø ó6
|
ä WW__T]]Ó +ò6,ð × Ñ Õ "à IIKà::j¨$Ó/Ø$*Ô!Ü d M°2Ó6 Ø ×(Ñ(¨Ô.Ø.0Ôà <<>¤Ñ %Ü FÙ Ø Ð Ø
|
|
?Ô+Ø ¤(Ñ*ä# F§L¡L£NÑ3Lä § ¡ £Ñ/LàÙ Ü ''..¨Ó2Ð2GØzz( EÔ*ô ]] 8¨UÓ3ä ]] 8¨UÓ3äbi Ó$Bð +Ù r 8Õ ,ð +DÔ Ù Ø HHJð øôQ "ò Úð ûô ò -Ø0°°Ð6Ü o¨1Ð,ûð -ûôZ ò ÙØ
|
ÙðÜIIhÔ'ð øô 'ò ØØ ðúà ð ûð +DÕ úse ¼K2 Ä L Ë
|
L$ Ë2 K?Ë>K?Ì L!Ì L Ì L!Ì$ M)ÍMÍM)Í M$Í!M)Í#M$Í$M)Í)M, Í, M5c ó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 ØEb× 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.show5
|
s õ( àtUÕ#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 )r. r r r r¾ r% r r° rÙ s r% r° z Image.splitM
|
sK ð Ø 77==AÒ ØIIK>Ð !Ü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) r. r½ r· rï rf r, r r rê )rÖ Úchannelr¸ rÇ s r% Ú
|
getchannelzImage.getchannel`
|
s| ð ä gsÔ #ð -Ø --/×/Ñ/°Ó8ð
|
yy ¨Ó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.tellv
|
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\ rj 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 )ry r rr r rs )ÚnumberrÞ s r% Ú round_aspectzDImage.thumbnail.<locals>.preserve_aspect_ratio.<locals>.round_aspect±
|
s+ Ü3tzz¨&Ó 1´4·9±9¸VÓ3DÈ#ÔNÐPQÓRÐRr$ c ó& t | z z
|
« S rÓ ©rÜ )ÚnÚaspectr< s r% ú<lambda>z@Image.thumbnail.<locals>.preserve_aspect_ratio.<locals>.<lambda>º
|
s ø ¼3¸vÈÈAɹ~Ó;N r$ rÝ c ó4 | dk( rdS t | z z
|
« S r râ )rã rä rI s r% rå z@Image.thumbnail.<locals>.preserve_aspect_ratio.<locals>.<lambda>½
|
s ø °1¸²6¨a ¼sÀ6ÈAÐPQÉEÁ>Ó?R r$ )rß rê rÞ úCallable[[int], float]rë r )r} r| )rà rä rI r< Ú provided_sizerÖ s @@@r% Úpreserve_aspect_ratioz.Image.thumbnail.<locals>.preserve_aspect_ratio°
|
s û ó Sð !DAqØDJJ 1¨¯ © Ò#3ØàZZ $§+¡+Ñ-FØ1uÙ V¡Ô1NÔOð
|
a4Kñ !ØJÔ$Rôð a4Kr$ Nr r )rØ r )rë útuple[int, int] | None) r¾ r% rr r rä r r r r r r{ r r ) rÖ r rt r ré Úpreserved_sizeÚ
|
final_sizerØ Úresr rè s ` @r% Ú thumbnailzImage.thumbnail
|
sÑ ù ôZ c¤$§*¡*¨dÓ 3Ó4 ö ñ" /Ó0Ø Ð !Ø Ø#
|
àØ Ð #Ø**Øs4 7 \Ñ1Ó2´C¸¸Q¹À,Ñ8NÓ4OÐPóCð Ø!fà 99
|
Ò "ØZ¨°sÈ ÓVBàeeDGØ#DJØ DJà 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 )rt Úfillrø Nzmissing method datar rþ )r{ rE rF r¹ rÎ r½ ÚImageTransformHandlerr* rø r, r r r r r> rC Ú_Image__transformerrB ) rÖ r rÒ rf rt rð r rÇ r rØ Úquads r% rÎ zImage.transformÙ
|
su ðv 99Ñ &¨8´z×7IÑ7IÒ+Ià D°&Ñ 9¸$¿)¹)Ñ DÓEß4 ¨¨x¸¸yÓIßÓ#ð ô fÔ 3Ô 4Ø×#Ñ# D¨$¸ÈÐ#ÓMÐ Mä 69Ô %à!>>Ó+LFDà <Ø'CÜ S/Ð !ä D )Ó ,Ø 99Ò § ¢ Ø ×*Ñ*Ó,BJØ))..Ó"Ø 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 | dz }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 r, rE rF rH rJ rG rI rK r~ r. r{ r rÎ )rÖ rØ ÚimagerÒ rf rt rð r¥ r÷ rÞ rß rà rá ÚxsÚysr« ÚswÚseÚneÚAsÚAtrÇ Úunusableræ r s r% Ú __transformerzImage.__transformer7 s. ð FSVOØ FSVOà Y×%Ñ%Ò %Ø8Dà y×'Ñ'Ò 'à !NBBØr'Q BØr'Q BÜ ×%Ñ%FØ2q " bÐ)Dà y×,Ñ,Ò ,Ø8Dà y~~Ò %ð bqBØaBØaBØaBØFBØqBØqBàØArÑ!ØArÑ!ØAA A¡Ñ&¨Ñ+¨rÑ1°BÑ6ØØArÑ!ØArÑ!ØAA A¡Ñ&¨Ñ+¨rÑ1°BÑ6ð Dð 2CÜ S/Ð !à Ü × Ñ Ü × Ñ Ü × Ñ ð
|
ñ
|
ð
|
JNN¬J×,>Ñ,>Ä
|
×@RÑ@RÐSÑSä NNÐ$:Ü ×&Ñ&Ð(BÜ ×&Ñ&Ð(Bð,ð
|
xÑ(¨R°¨zÐ9JÐ+KÑKà3°H°:¸RÐ@ô
|
×'Ñ'Ð)CÐDÜ ×(Ñ(Ð*EÐFÜ ×'Ñ'Ð)CÐDð öàð !9+R q¡ {¨!Ò,ðGð ð U499 W¨S¨b \Ó2Ð3°4¸À¹ °}ÐEÑ ECÜ S/Ð !à
|
|
à à ::Ñ #Ü!×)Ñ)Hà ×Ñ#uxx¨°°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.
|
)r. r r r )rÖ rÒ s r% r zImage.transpose s+ ð Øyy×*Ñ*¨6Ó2Ó3Ð3r$ c óv | j « | j | j j |« « S )zj
|
Randomly spread pixels in an image.
|
|
:param distance: Distance to spread pixels.
|
)r. r r Ú effect_spread)rÖ Údistances r% r zImage.effect_spread s+ ð Øyy×.Ñ.¨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% r zImage.toqimage¤ s1 å à×&Ò&Ø1CÜ cÓ"Ð "Ø w× Ñ Ó%Ð%r$ c ód ddl m} |j s d}t |« |j | « S )z$Returns a QPixmap copy of this imager r r )r« re r r¬ Ú toqpixmapr s r% r zImage.toqpixmap s1 å à×&Ò&Ø1CÜ cÓ"Ð "Ø w× Ñ Ó&Ð&r$ ©rë rì )rë úcore.ImagingCore)r r rë rì ©rë r )rë útuple[int, int]©rë r· )r r rë rì )r r rë rw )NN)r: rú rû rú r; r rë r· )rÝ Úobjectrë r) )rO ra rP r) rë rì )rW r· rX r rë ú bytes | None)rë r )rë z.dict[str, str | bytes | int | tuple[int, ...]])rë r rÓ )rm z object | Nonerë ztuple[object, object])rë ú list[Any])ru r rë rì ©re )rÍ r· rÅ r rë r³ )rö )r r· rë r³ )rf ú*bytes | bytearray | SupportsArrayInterfacerÄ r· rÅ r rë rì )rë zcore.PixelAccess | None) r{ rú r¦ ztuple[float, ...] | Noner¾ z Dither | Noner rV r¿ r rë rw ) r¿ r rÒ r+ rÓ r r ú Image | Noner¾ rP rë rw )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ë z1tuple[float, float] | tuple[tuple[int, int], ...]©rë údict[str, Any])rë r )rë zlist[ImageFile.ImageFile])rë rg )r )r rú rë zlist[int] | None©rë r) )r9 útuple[int, int] | list[int]rë z float | tuple[int, ...] | None)rë ztuple[list[int], list[int]])r@ r rA útuple[float, float] | Nonerë ú list[int])r@ r rA r rë rê )r z'Image | str | float | tuple[float, ...]rØ z:Image | tuple[int, int, int, int] | tuple[int, int] | Noner@ r rë rì )rþ rþ )r rw rK ú Sequence[int]rH r! rë rì )rT zSequence[float] | NumpyArray | Callable[[int], float] | Callable[[ImagePointTransform], ImagePointTransform | float] | ImagePointHandlerr{ rú rë rw )r6 z Image | intrë rì )rM r )rf zISequence[float] | Sequence[Sequence[int]] | core.ImagingCore | NumpyArrayrÔ rê rÕ rê rë rì )rf z1ImagePalette.ImagePalette | bytes | Sequence[int]r r· rë rì )r9 r r¡ z#float | tuple[int, ...] | list[int]rë rì )rg r rh zbytes | bytearray | Nonerë rw )r r rt rE rØ r rë útuple[int, int, int, int])NNN)
|
r z(tuple[int, int] | list[int] | NumpyArrayrt r+ rØ r r ú float | Nonerë rw )r zint | tuple[int, int]rØ r rë rw )r¡ rê rt rE r¢ z
|
int | boolr£ r r¤ rê r ú&float | tuple[float, ...] | str | Nonerë rw )r" úStrOrBytesPath | IO[bytes]rû rú rà r rë rì )r rw rë r )rÌ r rë rì )rÒ rú rë rì )rë ztuple[Image, ...])rÖ z int | strrë rw )r r rt rE r r# rë rì )r r rÒ z3Transform | ImageTransformHandler | SupportsGetDatarf zSequence[Any] | Nonert r rð r r r$ rë rw )rØ r" rö rw rÒ r> rf zSequence[float]rt r rð r) rë rì )rÒ r0 rë rw )r r rë rw )rë zImageQt.ImageQt)rë úImageQt.QPixmap)br r! r" rí rû Ú__annotations__rü Ú!_close_exclusive_fp_after_loadingr× Úpropertyr Úsetterr} r| r r{ r r r r# r+ r/ r1 r? rE rL rQ rZ r_ rb rg ri rk rp rv rD r rt r. r rV rW r¹ rP rT r¯ r Ú__copy__rÙ r× rä ræ rï rò rõ rø rý r r' r) r, r/ rC r3 r7 rº r; rô rC rG rJ rR r[ r] rs r¸ ro rz r r rE rF r r9 r» rÍ rÑ r° r× rÙ rJ rî rÎ rò r r r r r# r$ r% rw rw sI
ñ ð FJÓ Ø%)Ð
|
Ó)Ø(,Ð%ó'ð òó ðð YYòó ðð ò ó ð ð ò ó ð ð òó ðð òó ðð òBó ðBð __ò"ó ð"ó ò òóJó(ó
|
ð =AðØ ðØ/9ðØMPðà óó0
|
|
ó
|
ó
|
ó ó9ó(ð ò
|
ó ð
|
ó,ð
|
15ðKØ -ðKà óKó Mó ô7 ôr
|
ð: "ð#"à8ð#"ð ð#"ð ð #"ð
|
|
ó #"óJ"óH ð Ø+/Ø $Ø";;Øð ~àð~ð )ð~ð ð ~ð
|
ð ~ð ð ~ð
|
ó~ðD Ø !ØØ $Ø ×.Ñ.ð QàðQð ðQð ð Qð
|
ð Qð ð Qð
|
óQóf )ð Hô3ð4)Ø"ð)Ø)Jð)à ó)ð, Ø ð Ø&<ð à 9ó ó2%ó62ð -1õ +ð( #ð,Ø ð,à Kó,ô2ó. $ó %5óN$óLó :ó ô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 ð)à?ð)ð ð)ð
|
ó )ðV&+Ø!ð&+Ø*Mð&+à ó&+ðR OSðXØ!ðXØ3KðXà óXðt
|
à ð
|
ð ð
|
ð /ð
|
ð
|
|
#ó
|
ð2 $Ø8<Ø%)ð g>à6ðg>ð ðg>ð 6ð g>ð
|
#ð g>ð
|
ó g>ðX 15ð!6à%ð!6ð .ð!6ð
|
ó !6ðL *× 1Ñ 1Ø "Ø-1Ø,0Ø<@ðr
|
àðr
|
ð ðr
|
ð ð r
|
ð
|
+ð r
|
ð *ð r
|
ð :ðr
|
ð
|
ór
|
ðj DHðØ,ðØ6@ðØSVðà óóBó
|
ô,$ó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)rQ zb
|
Used as a mixin by point transforms
|
(for use with :py:meth:`~PIL.Image.Image.point`)
|
c ó y rÓ r# r s r% rR zImagePointHandler.pointÁ s à r$ N)r rw rë rw )r r! r" rí ÚabcÚabstractmethodrR r# r$ r% rQ rQ » s! ñð
|
×Ñò ó ñ r$ rQ 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ö r; s r% rÎ z ImageTransformHandler.transformÌ s ð r$ N)r r rö rw r; r rë rw )r r! r" rí r. r/ rÎ r# r$ r% rñ rñ Æ 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½ r r¾ r, r~ )r rÇ s r% Ú _check_sizer3 Ú sd ô dT¤5MÔ *Ø,ÜoÐ Ü
|
4yA~Ø3ÜoÐ Ø Aw{d1g kØ-ÜoÐ ð "r$ c ój t |« |-t « j t j | |« « S t |t « rddlm} |j || « }t « }| dk( rt |t t f« rt 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 rE r c 3 ó< K | ] }t |t « y wrÓ )r½ r rd s r% r§ znew.<locals>.<genexpr> s è ø Ò2 q
|
1c×"Ñ2ùs .r2 r3 r )r3 rw r rÁ r r½ r· r« rF r¶ r r¾ Úallr r r~ rd r rð )r{ r ÚcolorrF r Ú
|
color_intsrd s r% r r í sì ô( Ôà }äw||DHH T¨4Ó 0Ó1Ð1ä%Ô õ !à×#Ñ# E¨4Ó0ä Bà Ü ut¤UmÔ ,Ü Ñ2¨EÔ2Ô 2ä&*¬5´°c°©?¼EÀ%»LÓ&I
|
Ü z?aÒ ¤3 z£?°aÒ#7å &à2 ×2Ñ2Ó4BJØJJ×'Ñ'¨
|
Ó3EØ 77499T 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 re r# )r3 r r} r| r~ r½ r¾ rt )r{ r rf rÄ rÅ r r s r% rt rt s} ô< Ôä T4 BØ xx1} 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 re r# rþ r r r )r3 r~ r½ r¾ Ú _MAPMODESr r rÁ Ú
|
map_bufferr« rd r rC r r rt )r{ r rf rÄ rÅ r rd s r% Ú
|
frombufferr= L sÏ ôP Ôô 4yA~* T¨!¡W¬eÔ4ØAwàuÒ Ø 2:ØA:DØ 7iÑ ÜT6Ó"BØ ¨¨t°\À1ÀdÓKÓLBØs{Ý*à 6\× 6Ñ 6°u¸b¿e¹e×>NÑ>NÈuÓ>UÓ V
|
ØBKØIä T4 |°TÓ :Ð:r$ c ó" e Zd ZdZedd« Zy)ÚSupportsArrayInterfacezC
|
An object that has an ``__array_interface__`` dictionary.
|
c ó t « rÓ ©ÚNotImplementedErrorrÙ s r% rg z*SupportsArrayInterface.__array_interface__ s ä!Ó#Ð#r$ Nr )r r! r" rí r) rg r# r$ r% r? r? s ñð ò$ó ñ$r$ r? c ó" e Zd ZdZ d ddZy)ÚSupportsArrowArrayInterfacezm
|
An object that has an ``__arrow_c_array__`` method corresponding to the arrow c
|
data interface.
|
Nc ó t « rÓ rA rl s r% rk z-SupportsArrowArrayInterface.__arrow_c_array__ s ô "Ó#Ð#r$ rÓ )rm z 'PyCapsule'rë z tuple['PyCapsule', 'PyCapsule'])r r! r" rí rk r# r$ r% rD rD s! ñð /3ð$Ø +ð$à (ô$r$ rD 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 rD Útostringz1'strides' requires either tobytes() or tostring()re ) rg r~ r r¿ rè Ú_fromarray_typemapr r, r* rD rH r= )Úobjr{ r r ÚndimrG Útypekeyr¸ Ú color_modesrÇ Útypemoder Ú typekey_shaper Úndmaxr s r% Ú fromarrayrQ sÀ ðL ×
|
!Ñ
|
!CØ LEÜ u:DØggi Ó&Gð(Ø5 9Ñ$ c¨)¡nÐ4ð Ðð (Ü-?ÀÑ-HÑ *Hg{ð
|
ÐØ 8Ò ¨KÑ 7Ü Ð@À"Ô EØàØ Ð(Ñ(ØØ ØàØ e|Ø% d V¨3¨u¨g°QÐ7ÜoÐ à 1u Qx¨¨q©Ð 1DØÐÜ 3 Ô "Ø++-CÜ S*Ô %Ø,,.CàECÜ S/Ð !ä dD # u¨g°q¸!Ó <Ð<øôQ ò (Ø Ð ØGØ%'Kà0CÜC. aÐ 'ô ûð(ûô ò (Ø%,Ñ "M7Ø2°=°/ÀÀGÀ9ÐMCÜ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.
|
:param size: Image size. This must match the storage of the arrow object.
|
:returns: An Image object
|
|
Note that according to the Arrow spec, both the producer and the
|
consumer should consider the exported array to be immutable, as
|
unsynchronized updates will potentially cause inconsistent data.
|
|
See: :ref:`arrow-support` for more detailed information
|
|
.. versionadded:: 11.2.1
|
|
rk z!arrow_c_array interface not foundz,new_arrow returned None without an exception)r* r, rk rÁ Ú new_arrowrw r )rJ r{ r rÇ Úschema_capsuleÚ array_capsulerÿ s r% Ú fromarrowrV ÷ si ôN 3Ð+Ô ,Ø1ÜoÐ à&)×&;Ñ&;Ó&=Ñ#^]Ü
|
..t ^°]Ó
|
CCÙ
|
Üw||CÓ Ð à
|
8CÜ
|
S/Ðr$ c ód ddl m} |j s d}t |« |j | « S )z-Creates an image instance from a QImage imager r r )r« re r r¬ Ú
|
fromqimage©r re rÇ s r% rX rX + s1 åà × "Ò "Ø-Ü#Ó Ð Ø 7× Ñ bÓ !Ð!r$ c ód ddl m} |j s d}t |« |j | « S )z.Creates an image instance from a QPixmap imager r r )r« re r r¬ Ú fromqpixmaprY s r% r[ r[ 5 s1 åà × "Ò "Ø-Ü#Ó Ð Ø 7× Ñ rÓ "Ð"r$ )r© z|b1r z1;8)r© ú|u1r r )r© z|i1r zI;8)r© z<u2r )r© z>u2r )r© z<i2zI;16S)r© z>i2zI;16BS)r© z<u4zI;32)r© z>u4zI;32B)r© z<i4zI;32S)r© z>i4zI;32BS)r© z<f4r zF;32F)r© z>f4zF;32BF)r© z<f8zF;64F)r© z>f8zF;64BF))r r r1 r\ r r r ))r r r2 r\ r )r r r ))r r r3 r\ r )r r r r© Úi4Úf4c óü t y t d| d « t d| d « z }|dt z kD rd| ddt z d}t |« |t kD r&t j d| dt dt
|
« y y )Nr r r1 z Image size (z pixels) exceeds limit of z0 pixels, could be decompression bomb DOS attack.)r, ry r( r´ rµ r )r ÚpixelsrÇ s r% rÝ rÝ Z s¡ ÜÐ Øä DG_s 1 d¨1¡gÑ .Fà Ô$Ñ$Ò$à6(Ð"<¸QÔAQÑ=QÐ<Rð S>ð >ð ô % SÓ)Ð)à Ô Ò Ü Ø6(Ð"<Ô=MÐ<Nð O6ð 6ä $õ
|
ð !r$ c óÖ
|
|dk7 rdt |« }t |« t | t j « r d}t |« |t
|
}n#t |t t f« s d}t |« d
|
d}t | « r.t j | « }t j |d« } d
|
nt t t | « } | j# d « | j+ d
|
« }t- « g d
|
fd } || |||« }|C|t
|
u r;t
|
j/ « t1 « r || ||t fd |D « « « }|r
|
|_ |S
|
r| j5 « D ] }t7 j8 |« d |r|n| z }t; |« # t$ t j& f$ r) t j( | j+ « « } d
|
Y w xY w)a
|
Opens and identifies the given image file.
|
|
This is a lazy operation; this function identifies the file, but
|
the file remains open and the actual image data is not read from
|
the file until you try to process the data (or call the
|
:py:meth:`~PIL.Image.Image.load` method). See
|
:py:func:`~PIL.Image.new`. See :ref:`file-handling`.
|
|
:param fp: A filename (string), os.PathLike object or a file object.
|
The file object must implement ``file.read``,
|
``file.seek``, and ``file.tell`` methods,
|
and be opened in binary mode. The file object will also seek to zero
|
before reading.
|
:param mode: The mode. If given, this argument must be "r".
|
:param formats: A list or tuple of formats to attempt to load the file in.
|
This can be used to restrict the set of formats checked.
|
Pass ``None`` to try all supported formats. You can print the set of
|
available formats by running ``python3 -m PIL`` or using
|
the :py:func:`PIL.features.pilinfo` function.
|
:returns: An :py:class:`~PIL.Image.Image` object.
|
:exception FileNotFoundError: If the file cannot be found.
|
:exception PIL.UnidentifiedImageError: If the image cannot be opened and
|
identified.
|
:exception ValueError: If the ``mode`` is not "r", or if a ``StringIO``
|
instance is used for ``fp``.
|
:exception TypeError: If ``formats`` is not ``None``, a list or a tuple.
|
r z bad mode zKStringIO cannot be used to open an image. Binary data must be used instead.z formats must be a list or tupleFr« ÚrbTr é c ó |D ] }|j « }|t vr
|
t « t | \ }}| xs ||« }t |t « r j |« n5|r3| j d« || |« }t |j « |c S y # t t t t j f$ r0} t r j |dz t | « z « Y d } ~ çd } ~ wt $ r
|
r| j! « w xY w)Nr z opening failed. )r½ rl r¹ r½ r· r| rÍ rÝ r Ú SyntaxErrorÚ
|
IndexErrorrè ÚstructÚerrorr* Ú BaseExceptionr+ ) r" r> ÚprefixÚformatsr¥ ÚfactoryÚacceptrO r r¸ Ú exclusive_fpÚwarning_messagess r% Ú
|
_open_corezopen.<locals>._open_core¶ sî ø ð ò AØ AØ}Üð Ü"& q¡'Ø #Ò5¡v¨f£~Ü f¤cÔ*Ø$×+Ñ+¨FÕ3ÙØGGAJÙ XÓ.BÜ-¨b¯g©gÔ6Ø Iøð ð* øô ¤¬Y¼¿ ¹ ÐEò NÝ(Ø$×+Ñ+¨AÐ0CÑ,CÄcÈ!ÃfÑ,LÔMÿøÜ ò Ù ØHHJØð ús ªA-B  #D à &C+Ã+ D c 3 ó, K | ] }|vs| y wrÓ r# )r¤ rû Úchecked_formatss r% r§ zopen.<locals>.<genexpr>Ü s øè ø ÒT °fÀOÒ6SfÑTùs z cannot identify image file %r)
|
r" ú IO[bytes]r> z str | bytesrj r³ rk zlist[str] | tuple[str, ...]rë zImageFile.ImageFile | None) Úreprr, r½ rS ÚStringIOrk r r¾ rè r r6 r² r¿ rÀ r r r³ rÍ r ÚUnsupportedOperationrT Úreadr r r¹ r r+ r´ rµ r ) r" r{ rk rÇ r> rj rp r Úmessagerr rn ro s @@@r% rÀ rÀ o sè ú ðD s{Ø$t* Ð&ÜoÐ Ü B Ô $ð 0ð ô oÐ àÜÜ ¤$¬ Ô /Ø/ÜnÐ àLØ HÜr{Ü99R=Ü ]]8 TÓ *Ø ä "U)RÓ ð Ø
|
|
ð
|
WWR[Fä Ià"$ÐðØ ðà ðð ðð -ð ð
|
|
$ö ñ:
|
B &¨'Ó 2Bà zg¤mÜ '')Ü 6ÙØØØÜÓT¨7ÔTÓTó Bñ
|
Ø'ÔØ áØ
|
|
Ø#ò Ü gÕ ð à
|
)¹©XÀrÑ
|
JCÜ
|
Ó
|
%Ð%øôy B× 3Ñ 3Ð 4ò Ü ZZ Ó "Ø ð ús Ã
|
F& Æ&>G(Ç'G(c ó´ | j « |j « | j t j | j |j « « S )zñ
|
Alpha composite im2 over im1.
|
|
:param im1: The first image. Must have mode RGBA or LA.
|
:param im2: The second image. Must have the same mode and size as the first image.
|
:returns: An :py:class:`~PIL.Image.Image` object.
|
)r. r rÁ rJ r )Úim1Úim2s r% rJ rJ ï s: ð HHJØHHJØ 88D×(Ñ(¨¯©°·±Ó8Ó 9Ð9r$ c ó¶ | j « |j « | j t j | j |j |« « S )a
|
Creates a new image by interpolating between two input images, using
|
a constant alpha::
|
|
out = image1 * (1.0 - alpha) + image2 * alpha
|
|
:param im1: The first image.
|
:param im2: The second image. Must have the same mode and size as
|
the first image.
|
:param alpha: The interpolation alpha factor. If alpha is 0.0, a
|
copy of the first image is returned. If alpha is 1.0, a copy of
|
the second image is returned. There are no restrictions on the
|
alpha value. If necessary, the result is clipped to fit into
|
the allowed output range.
|
:returns: An :py:class:`~PIL.Image.Image` object.
|
)r. r rÁ Úblendr )rz r{ r6 s r% r} r} ý s: ð$ HHJØHHJØ 88DJJsvv s§v¡v¨uÓ5Ó 6Ð6r$ c óL |j « }|j | d|« |S )af
|
Create composite image by blending images using a transparency mask.
|
|
:param image1: The first image.
|
:param image2: The second image. Must have the same mode and
|
size as the first image.
|
:param mask: A mask image. This image can have mode
|
"1", "L", or "RGBA", and must have the same size as the
|
other two images.
|
N)r rG )Úimage1Úimage2r@ rö s r% Ú compositer s$ ð KKMEØ KKdÔ#Ø Lr$ c ó* | j |d « S )aá
|
Applies the function (which should take one argument) to each pixel
|
in the given image. If the image has more than one band, the same
|
function is applied to each band. Note that the function is
|
evaluated once for each possible pixel value, so you cannot use
|
random components or other generators.
|
|
:param image: The input image.
|
:param function: A function object, taking one integer argument.
|
:returns: An :py:class:`~PIL.Image.Image` object.
|
r )rR )rö rÅ s r% Úevalr % s ð ;;tAwÓ Ð r$ c óº t | « t |« k7 sd| v r d}t |« |dd D ]P }|j t | « k7 r d}t |« |j
|
|d j
|
k7 sEd}t |« |D ] }|j « |d j t j | g|D cg c] }|j c}¢ « S c c}w )am
|
Merge a set of single band images into a new multiband image.
|
|
:param mode: The mode to use for the output image. See:
|
:ref:`concept-modes`.
|
:param bands: A sequence containing one single-band image for
|
each band in the output image. All bands must have the
|
same size.
|
:returns: An :py:class:`~PIL.Image.Image` object.
|
Ú*zwrong number of bandsr Nz mode mismatchr z size mismatch) r£ r~ r, r{ r r r. r rÁ r± r )r{ r rÇ rú rY s r% r± r± 5 sÏ ô DÓS ZÒ'¨3°$©;Ø%ÜoÐ Øab ò "Ø 99 DÓ)Ò )Ø!CÜ S/Ð !Ø 99a Ó %Ø!CÜ S/Ð !ð "ð ò Ø ðà 8== DÐA¸%Ö+@°Q¨A¯D«DÒ+@ÒAÓ BÐBùÒ+@s Â;Cc ót | j « } | t vrt j | « ||ft | < y)a1
|
Register an image file plugin. This function should not be used
|
in application code.
|
|
:param id: An image format identifier.
|
:param factory: An image file factory method.
|
:param accept: An optional function that can be used to quickly
|
reject images having another format.
|
N)r½ rk r| rl )rK rl rm s r% Ú register_openr T s. ð"
|
BØ |Ü
|
" ØDHr$ c ó2 |t | j « < y)a²
|
Registers an image MIME type by populating ``Image.MIME``. This function
|
should not be used in application code.
|
|
``Image.MIME`` provides a mapping from image format identifiers to mime
|
formats, but :py:meth:`~PIL.ImageFile.ImageFile.get_format_mimetype` can
|
provide a different result for specific images.
|
|
:param id: An image format identifier.
|
:param mimetype: The image MIME type for this format.
|
N)rn r½ )rK Úmimetypes r% Ú register_mimer k s ð DÒr$ c ó2 |t | j « < y)zÏ
|
Registers an image save function. This function should not be
|
used in application code.
|
|
:param id: An image format identifier.
|
:param driver: A function to save images in this format.
|
N)ro r½ ©rK Údrivers r% Ú register_saver z s ð DÒr$ c ó2 |t | j « < y)zü
|
Registers an image function to save all the frames
|
of a multiframe format. This function should not be
|
used in application code.
|
|
:param id: An image format identifier.
|
:param driver: A function to save images in this format.
|
N)rp r½ r s r% Úregister_save_allr s ð "HRXXZÒr$ c óN | j « t |j « < y)zÇ
|
Registers an image extension. This function should not be
|
used in application code.
|
|
:param id: An image format identifier.
|
:param extension: An extension used for this format.
|
N)r½ rq r· )rK Ú extensions r% Úregister_extensionr s ð $&§8¡8£:IiooÓ Ò r$ c ó* |D ] }t | |« y)zÎ
|
Registers image extensions. This function should not be
|
used in application code.
|
|
:param id: An image format identifier.
|
:param extensions: A list of extensions used for this format.
|
N)r )rK Ú
|
extensionsr s r% Úregister_extensionsr s ð ò * Ü2yÕ)ñ*r$ c ó" t « t S )za
|
Returns a dictionary containing all file extensions belonging
|
to registered plugins
|
)r¹ rq r# r$ r% Úregistered_extensionsr ¬ s ô
|
FÜ Ðr$ c ó |t | < y)zÙ
|
Registers an image decoder. This function should not be
|
used in application code.
|
|
:param name: The name of the decoder
|
:param decoder: An ImageFile.PyDecoder object
|
|
.. versionadded:: 4.1.0
|
N)rr )r rÆ s r% Úregister_decoderr µ ó ð HTNr$ c ó |t | < y)zÙ
|
Registers an image encoder. This function should not be
|
used in application code.
|
|
:param name: The name of the encoder
|
:param encoder: An ImageFile.PyEncoder object
|
|
.. versionadded:: 4.1.0
|
N)rs )r rÎ s r% Úregister_encoderr  r r$ c óP ddl m} t ddd« |j | fi |¤ y )Nr rÏ z Image._showr+ zImageShow.show)r« rÐ r rÑ )rö r; rÐ s r% Ú_showr Ó s% Ýä mRÐ!1Ô2ØINN5Ñ$GÓ$r$ c ó^ t « j t j | ||« « S )a
|
Generate a Mandelbrot set covering the given extent.
|
|
:param size: The requested size in pixels, as a 2-tuple:
|
(width, height).
|
:param extent: The extent to cover, as a 4-tuple:
|
(x0, y0, x1, y1).
|
:param quality: Quality.
|
)rw r rÁ Úeffect_mandelbrot)r ÚextentÚqualitys r% r¡ r¡ Þ s$ ô 7<<×.Ñ.¨t°V¸WÓEÓ FÐFr$ c ó\ t « j t j | |« « S )z»
|
Generate Gaussian noise centered around 128.
|
|
:param size: The requested size in pixels, as a 2-tuple:
|
(width, height).
|
:param sigma: Standard deviation of noise.
|
)rw r rÁ Ú effect_noise)r Úsigmas r% r¥ r¥ í s" ô 7<<×)Ñ)¨$°Ó6Ó 7Ð7r$ c óZ t « j t j | « « S )zl
|
Generate 256x256 linear gradient from black to white, top to bottom.
|
|
:param mode: Input mode.
|
)rw r rÁ Úlinear_gradientr s r% r¨ r¨ ø ó ô 7<<×,Ñ,¨TÓ2Ó 3Ð3r$ c óZ t « j t j | « « S )zm
|
Generate 256x256 radial gradient from black to white, centre to edge.
|
|
:param mode: Input mode.
|
)rw r rÁ Úradial_gradientr s r% r« r« r© r$ c ó | | nt j }dt j fdt j fdt j
|
ffD ]d \ }}||vr || j « }d}dD ]( \ }}|j |« s|}|d t |« }* t |« |z } ||« f y # t $ r t j | d« Y w xY w# t $ r$} t j | d| « Y d } ~ ·d } ~ ww xY w)NÚPILLOW_ALIGNMENTÚPILLOW_BLOCK_SIZEÚPILLOW_BLOCKS_MAXr ))r i )r i z is not intz: ) r6 ÚenvironrÁ Ú set_alignmentÚset_block_sizeÚset_blocks_maxr· r7 r~ r r, r´ rµ )
|
ÚenvÚenv_dictÚvar_namer* ÚvarÚunitsÚpostfixÚmulÚvar_intr¸ s
|
r% Ú_apply_env_variablesr¼ s Øos¬2¯:©:Hð
|
T× /Ñ /Ð0Ø d× 1Ñ 1Ð2Ø d× 1Ñ 1Ð2ð ò .Ñ&ð
|
8Ñ #Ø àxÑ ×&Ñ&Ó(àØ =ò +LGSØ||GÕ$ØØ/S \MÐ*ð +ð
|
Ü#h Ñ&Gð
|
.Ù 7Oñ/.øô$ ò Ü MMXJ kÐ2Ô 3Ù ð ûô ò .Ü MMXJ b¨¨Ð,× -Ñ -ûð .ús* ÂB2Â'CÂ2!CÃCà DÃ"DÄDc óÊ e Zd ZU dZdZded< dZdZddZddZ ddZ
|
d d d Z d d
|
Z d d Z dd d Zd d Zd!d"dZd#dZddZd$dZd%dZd&dZd'dZd(dZd)dZd*dZy)+r a
|
This class provides read and write access to EXIF image data::
|
|
from PIL import Image
|
im = Image.open("exif.png")
|
exif = im.getexif() # Returns an instance of this class
|
|
Information can be read and written, iterated over or deleted::
|
|
print(exif[274]) # 1
|
exif[274] = 2
|
for k, v in exif.items():
|
print("Tag", k, "Value", v) # Tag 274 Value 2
|
del exif[274]
|
|
To access information beyond IFD0, :py:meth:`~PIL.Image.Exif.get_ifd`
|
returns a dictionary::
|
|
from PIL import ExifTags
|
im = Image.open("exif_gps.jpg")
|
exif = im.getexif()
|
gps_ifd = exif.get_ifd(ExifTags.IFD.GPSInfo)
|
print(gps_ifd)
|
|
Other IFDs include ``ExifTags.IFD.Exif``, ``ExifTags.IFD.MakerNote``,
|
``ExifTags.IFD.Interop`` and ``ExifTags.IFD.IFD1``.
|
|
:py:mod:`~PIL.ExifTags` also has enum classes to provide names for data::
|
|
print(exif[ExifTags.Base.Software]) # PIL
|
print(gps_ifd[ExifTags.GPS.GPSDateStamp]) # 1999:99:99 99:99:99
|
Nrú r Fc óJ i | _ i | _ i | _ d | _ d | _ y rÓ )Ú_dataÚ _hidden_dataÚ_ifdsÚ_infoÚ _loaded_exifrÙ s r% r× z Exif.__init__] s' Ø%'
|
Ø,.ÔØ02
|
ØCG
|
Ø*.Õr$ c ón t |« dk( rt |t « r|d S |S # t $ r Y |S w xY wrñ )r~ r½ r¾ rU )rÖ r¡ s r% Ú_fixupz Exif._fixupd sD ð Ü5zQ¤:¨e´UÔ#;Ø Qxð øô ò Ø Ø ð ús "' § 4³4c ót |j « D ci c] \ }}|| j |« c}}S c c}}w rÓ )r rÅ )rÖ Úsrc_dictr r s r% Ú _fixup_dictzExif._fixup_dictl s0 ð /7¯n©nÓ.>×?¡d a¨4;;q>Ñ!Ó?Ð?ùÓ?s 4c ó | j j |« ddlm} |j | j
|
|¬« }|j | j « | j t |« « S # t t f$ r Y y w xY w)Nr ©rf )Úgroup) r" rÍ r« rf ÚImageFileDirectory_v2Úheadr. rÈ Údictr¿ rè )rÖ rÕ rË rf r s r% Ú _get_ifd_dictzExif._get_ifd_dictq st ð 0ð GGLLÔ õ *à8?×8Ñ8¸¿¹È%ÔPDØ IIdggÔ Ø×#Ñ#¤D¨£JÓ/Ð /øô )Ð$ò Ùð ús A6 Á6BÂBc ó | j rdnd}| j dk( rd|z dz t d« z }nd|z t d« z }| j r-|| j dk( r t d« n
|
t d« z }|dz }|S ) Nó +ó *ru s IIó rõ s MM s )r r r r )rÖ rd rÍ s r% Ú _get_headzExif._get_head s{ Ø !\\'¨wØ ;;#Ò Ø7? WÑ,¬u°Q«xÑ7Dà wÑ&¬¨q«Ñ1DØ <<Ø § ¡ ¨sÒ 2E!H¼¸a»Ñ @DØ Ð'Ñ 'DØ r$ c óÚ || j k( ry || _ | j j « | j j « | j j « |r*|j d« r|dd }|r|j d« r|sd | _ y t j |« | _ | j j d« | _ ddl m } |j | j « | _ | j j | _ | j j# | j j$ « | j j' | j « y )Nó Exif r5 rõ r rÊ )rà r¿ ÚclearrÀ rÁ Ú
|
startswithr rS rT r" rw rÍ r« rf rÌ r r rÍ Únextr. )rÖ rf rf s r% r. z Exif.load s ð 4×$Ñ$Ò $Ø Ø ÔØ
|
|
×ÑÔØ ×Ñ× Ñ Ô!Ø
|
|
×ÑÔÙt Ô7Ø8Dñ t Õ7áØ DJØ ä ZZ¨Ó -ØGGLL O å%à:_×:Ñ:¸4¿9¹9ÓE
|
Øjj×(Ñ( Ø TZZ__Ô%Ø
|
|
Õ r$ c ó¬ d | _ | j j « | j j « | j j « ddlm} || _ || j « | _ n | j j d« | _ |j | j « | _ | j | j j | _ || j j }| j j! « | j j# |« | j j% | j « y )Nr rÊ rõ )rà r¿ r× rÀ rÁ r« rf r" rÔ rÍ rw rÌ r r r rÙ rÙ rÍ r. )rÖ r" rÕ rf s r% r zExif.load_from_fp© så Ø ÔØ
|
|
×ÑÔØ ×Ñ× Ñ Ô!Ø
|
|
×ÑÔõ &àØ Ð Ø Ó(DIà QDIØ:_×:Ñ:¸4¿9¹9ÓE
|
Ø ;;Ð Ø **×,Ñ,DKØ >ØZZ__FØ Ø VÔ Ø
|
|
Õ r$ c óü t | « }t j j | v rX| j | t j j t j j « }|r|j |« t j j | v r`| j | t j j t j j « |t j j < |S rÓ )rÎ r
|
ÚIFDr rÏ ÚupdateÚGPSInfo)rÖ Ú merged_dictÚifds r% Ú_get_merged_dictzExif._get_merged_dictÀ s´ Ü4j ô <<× Ñ Ñ $Ø×$Ñ$ T¬(¯,©,×*;Ñ*;Ñ%<¼h¿l¹l×>OÑ>OÓPCÙØ×"Ñ" 3Ô'ô <<× Ñ 4Ñ 'Ø04×0BÑ0BØX\\×)Ñ)Ñ*¬H¯L©L×,@Ñ,@ó1K ×,Ñ,Ñ -ð Ðr$ c ó6 ddl m} | j « } |j |¬« }| j j « D ] \ }}|| vs |||< | j « D ] \ }}|t j j t j j fv rÙt |t « sÉ| j |« }|t j j k( rt j j |v rt |t j j t « sT|j « }| j t j j « |t j j < |||< d|z |j |« z S )Nr rÊ )ÚifhrÖ )r« rf rÔ rÌ rÁ r r
|
rÜ r rÞ r½ rÎ Úget_ifdÚInteropr rD )rÖ rÕ rf rÍ rà r Úifd_dictr¡ s r% rD z Exif.tobytesÑ sB Ý%à~~Ó Ø3o×3Ñ3¸Ô=Ø !ZZ× -Ñ -Ó /ò $MCØ$Ø#Cð $ð **,ó JCØÜ ×!Ñ!Ü ×$Ñ$ðñ ô ! ¬Ô-Ø SÓ)à8<<×,Ñ,Ò,Ü ×,Ñ,°Ñ5Ü & u¬X¯\©\×-AÑ-AÑ'BÄDÔ Ià !JJLEØ26·,±,¼x¿|¹|×?SÑ?SÓ2TE(,,×.Ñ.Ñ/Ø CHð ð Ñ%¨¯ © °FÓ(;Ñ;Ð;r$ c óì || j vr0|t j j k( r`| j | j j
|
dk7 rì| j | j j
|
« }|Ä|| j |< n³|t j j t j j fv rT| j j || j |« « }|O| j ||« }|:|| j |< n)|t j j t j j fv ròt j j | j vr)| j t j j « | j t j j | }|t j j k( r8ddlm} |j! d« r't# |d« }||d }i }t% t' j( d|d d « d « D ]Ã } t' j( d|| d z dz | dz d z dz « \ }
|
} } } |j* | \ }}| |z }|d
|
kD r't' j( d | « \ }||d z
|
||z d z
|
} n| d | } t/ | « |k7 r(t1 j2 d | d t/ | « d|
|
« ¯| s² | |« | d« ||
|
< Å t5 | j7 |« « | j |< n | j d« dk( ri }t% t' j( d|d d « d « D ]© } t' j( d|| d z dz | dz d z dz « \ }
|
} } } |
|
dk( s7t' j( d| « \ }| j8 j; |« d| j8 j= d
|
« i}| j8 j= d
|
« t# | j8 j= d « « |d< | j8 j= d
|
« | j8 j= d
|
« |d< | j8 j= d « | j8 j= d
|
« }|j* t> j@ d } | |« |d« d |d< | j8 j= d
|
« | j8 j= d« |d< d|i}¬ || j |< n#| j ||« }||| j |< | j jC |i « }|t j j k( re| j rY|jE « D ci c]> \ }}|t j j t j j fvr||@ }}}|S # t, $ r Y ·w xY wc c}}w )Nr r )rÌ s FUJIFILMrõ z<Hr1 z<HHL4sé r3 z<Lz9Possibly corrupt EXIF MakerNote data. Expecting to read z bytes but only got z. Skipping tag Fi ÚNintendoz>Hz>HHL4si z>LÚModelIDÚ TimeStampÚInternalSerialNumberÚParallaxÚCategory)#rÁ r
|
rÜ ÚIFD1r rÙ rÏ r rÞ rÀ r rå Ú MakerNoterä rf rÌ rØ r r® rg ÚunpackÚ_load_dispatchr¿ r~ r´ rµ rÎ rÈ r" rÍ rw r ÚFLOATÚ
|
setdefaultr )rÖ r rà rÕ Útag_datarÌ Ú
|
ifd_offsetÚifd_dataÚ makernoter¥ Úifd_tagÚtypÚcountrf Ú unit_sizeÚhandlerr Ú
|
camerainfoÚparallaxr r s r% rä z Exif.get_ifdé sA Ø djjÒ Øhll×'Ñ'Ò'Ø::Ñ)¨d¯j©j¯o©oÀÓ.BØ ×,Ñ,¨T¯Z©Z¯_©_Ó=CØØ*-
|
|
3Ø ×*Ñ*¬H¯L©L×,@Ñ,@ÐAÑAØ ×*Ñ*×.Ñ.¨s°D·H±H¸S³MÓBØÑ%Ø ×,Ñ,¨V°SÓ9CØØ*-
|
|
3Ø ×-Ñ-¬x¯|©|×/EÑ/EÐFÒFÜ<<×$Ñ$¨D¯J©JÑ6ØLL¤§ ¡ ×!2Ñ!2Ô3Ø ::¤h§l¡l×&7Ñ&7Ñ8¸Ñ=Ø(,,×0Ñ0Ó0ÝFà ×*Ñ*¨;Õ7Ü%*¨8°QÓ%7
|
Ø#+¨J¨KÐ#8à$& Ü!&¤v§}¡}°T¸8ÀBÀQ¸<Ó'HÈÑ'KÓ!Lò AÜ8>¿ ¹ Ø (¨(°1°r±6¸A±:ÀÀQÁÈ"Á ÈqÑ@PÐ*Qó9 Ñ 5G S¨%°ð )ð %:×$HÑ$HÈÑ$Mñ!"Ø$-Ø$+ð $)¨9Ñ#4DØ # axÜ,2¯M©M¸$ÀÓ,E¡ Ø'/°¸± ¸fÀt¹mÈbÑ>PÐ'Q¡à'+¨E¨T { ä " 4y¨DÒ 0Ü (§ ¡ ð%9Ø9=¸Ð>RÜ'*¨4£y k° ÀÀ ð%Kô!"ð
|
!)á#'Ø (á18Ù 5Ó 7¸¸uó2 I gÒ .ð; ô@ +/¨t×/?Ñ/?À Ó/JÓ*K
|
|
3Ø &Ó)¨ZÓ7Ø$& Ü!&¤v§}¡}°T¸8ÀBÀQ¸<Ó'HÈÑ'KÓ!Ló AAÜ8>¿ ¹ Ø (¨(°1°r±6¸A±:ÀÀQÁÈ"Á ÈqÑ@PÐ*Qó9 Ñ 5G S¨%°ð '¨&Ó 0ä,2¯M©M¸$ÀÓ,E¡ Ø $§¡§ ¡ ¨VÔ 4ð %.¨t¯w©w¯|©|¸A«ðF"
|
ð !%§¡§ ¡ ¨Q¤ä:?ÀÇÁÇ Á ÈRÓ@PÓ:Q
|
¨;Ñ 7à $§¡§ ¡ ¨Q¤ØEIÇWÁWÇ\Á\ÐRSÃ_
|
Ð+AÑ Bà $§¡§ ¡ ¨RÔ 0Ø+/¯7©7¯<©<¸«? Ø*?×*NÑ*NÜ$,§N¡Nñ+"à"#ñ+% ñ :AÙ$9Ó$;¸XÀuó:"à"#ñ:%
|
¨:Ñ 6ð !%§¡§ ¡ ¨Q¤Ø9=¿¹¿ ¹ Àa»
|
¨:Ñ 6à-3°ZÐ,@¢ ðA AðB +4
|
|
3ð ×,Ñ,¨X°sÓ;CØØ*-
|
|
3Øjj×#Ñ# C¨Ó,Ø (,,×#Ñ#Ò #¨×(9Ò(9ð "iik÷áQØX\\× 1Ñ 1´8·<±<×3IÑ3IÐ JÑJð 1ðCñ ð
|
|
øôQ $,ò )Ú (ð )üóFs É&W ÖAW0× W-×,W-c óª t j j t j j fD ] }|| v s| | | j |< | |= y rÓ )r
|
rÜ r rÞ rÀ ©rÖ r s r% Ú hide_offsetszExif.hide_offsetsU sL Ü LL×%Ñ%¤x§|¡|×';Ñ';Ð<ò CØd{Ø)-¨c©×!Ñ! #Ñ&ØIñ r$ c óp | j | j D ] }| | t | j « S rÓ )r r· r¿ r s r% Ú__str__z Exif.__str__[ s6 Ø ::Ð !àzzò ØS ð ô 4::Ð r$ c ó t | j « }| j |j | j « t |« S rÓ )Úsetr¿ r rÝ r~ ©rÖ Úkeyss r% Ú__len__z Exif.__len__c s3 Ü4::Ø ::Ð !Ø KK
|
|
Ô #Ü4yÐr$ c óà | j T|| j vrF|| j v r8| j | j | « | j |< | j |= | j | S rÓ )r r¿ rÅ r s r% Ú __getitem__zExif.__getitem__i sY Ø ::Ð ! c°·±Ñ&;ÀÀtÇzÁzÑ@QØ "kk¨$¯*©*°S©/Ó :DJJsOØ
|
|
3Øzz#Ð r$ c ó^ || j v xs | j d uxr || j v S rÓ )r¿ r r s r% Ú __contains__zExif.__contains__o s- ØdjjÐ ÒR T§Z¡Z°tÐ%;Ò%QÀÀtÇzÁzÐ@QÐRr$ c óp | j || j v r | j |= || j |< y rÓ )r r¿ )rÖ r r¡ s r% Ú __setitem__zExif.__setitem__r s/ Ø ::Ð ! c¨T¯Z©ZÑ&7Ø
|
|
3Ø
|
|
3r$ c ó¦ | j || j v r| j |= y | j |= || j v r| j |= y y rÓ )r r¿ rÁ r s r% Ú __delitem__zExif.__delitem__w sI Ø ::Ð ! c¨T¯Z©ZÑ&7Ø
|
|
3à
|
|
3ØdjjÑ ØJJsOð !r$ c ó t | j « }| j |j | j « t |« S rÓ )r r¿ r rÝ Úiterr s r% Ú__iter__z Exif.__iter__ s3 Ü4::Ø ::Ð !Ø KK
|
|
Ô #ÜDzÐr$ r )r¡ r rë r )rÇ údict[int, Any]rë r rÓ )rÕ r rË r+ rë zdict[int, Any] | None)rë r³ )rf r³ rë rì )r" rs rÕ r+ rë rì )rë r )rõ )rÕ r rë r³ )r r rë r r r )r r rë r )r r rë r) )r r r¡ r rë rì )r r rë rì )rë z Iterator[int])r r! r" rí r r' r r r× rÅ rÈ rÏ rÔ r. r rá rD rä r r r r r r r r r# r$ r% r r 7 s
ñ ðB FJÓ ØGØGó/óó@ð 04ð0Øð0Ø",ð0à ó0ó ó!ô:!ó.ô"<ó0jóX ó óó ó Só ó
|
$ôr$ r )r rw rë ztuple[tuple[int, ...], str])r{ r· rë r· )r{ r· rë r )r{ r· rë r r r )r# )
|
r{ r· rÄ r· rÅ r r útuple[Any, ...]rë z)core.ImagingDecoder | ImageFile.PyDecoder)
|
r{ r· rÍ r· rÅ r r r rë z)core.ImagingEncoder | ImageFile.PyEncoder)rò z<Callable[[ImagePointTransform], ImagePointTransform | float]rë r )r r rë rì )r )r{ r· r r r7 r$ rë rw r ) r{ r· r r rf r rÄ r· rÅ r rë rw ) r{ r· r r rf z bytes | SupportsArrayInterfacerÄ r· rÅ r rë rw rÓ )rJ r? r{ rú rë rw )rJ rD r{ r· r r rë rw )r zImageQt.QImagerë úImageFile.ImageFile)r r& rë r )r r rë rì )r N)r" r% r{ z Literal['r']rk z"list[str] | tuple[str, ...] | Nonerë r )rz rw r{ rw rë rw )rz rw r{ rw r6 rê rë rw )r rw r rw r@ rw rë rw )rö rw rÅ rç rë rw )r{ r· r zSequence[Image]rë rw )rK r· rl zSCallable[[IO[bytes], str | bytes], ImageFile.ImageFile] | type[ImageFile.ImageFile]rm z$Callable[[bytes], bool | str] | Nonerë rì )rK r· r r· rë rì )rK r· r z/Callable[[Image, IO[bytes], str | bytes], None]rë rì )rK r· r r· rë rì )rK r· r rj rë rì )rë rm )r r· rÆ ztype[ImageFile.PyDecoder]rë rì )r r· rÎ ztype[ImageFile.PyEncoder]rë rì )rö rw r; r rë rì )r r r¢ r r£ r rë rw )r r r¦ rê rë rw )r{ r· rë rw )r´ zdict[str, str] | Nonerë rì )¬Ú
|
__future__r r. Úatexitr¿ rS Úloggingrr r6 r rg r( r4 r´ Úcollections.abcr Úenumr Útypingr r r r« r
|
r r r r r Ú_binaryr r r Ú
|
_deprecater Ú_utilr r r' Ú
|
defusedxmlr r¬ Ú TYPE_CHECKINGr r r Útypesr r r Ú getLoggerr r± ÚRuntimeWarningr rU r( r* r r, r- rÁ rÀ rÇ r r· rØ rµ r0 r> rE rG rH rI rJ rK rq rP rV rZ ÚmodulesÚmoduleÚitemÚsetattrr r¡ r* r_ ÚFILTEREDÚ HUFFMAN_ONLYÚRLEÚFIXEDÚmmapÚxml.etree.ElementTreer` ÚIPython.lib.prettyra rb rc rd re rf Ú_typingrg rh ri rk rl rn ro rp rq rr rs Ú byteorderÚ_ENDIANr
ÚMODESr; r r r¡ r£ rª r r¹ rÈ rÏ rÑ rô rö rw ÚABCrQ rñ r3 r rt r= r? rD rQ rV rX r[ rI rÝ rÀ rJ r} r r r± r r r r r r r r r r r¡ r¥ r¨ r« r¼ ÚregisterÚ clear_cacheÚ _ExifBaser r# r$ r% ú<module>r9 sG ðö6 #ã
|
Û Û Û Û Û Û Û Û Û
|
Û Û Ý *Ý ß %Ñ %÷
|
÷ ÷ )Ñ (Ý !ß )à Ó ðÝ&ð Ùß<Ñ<Ý ß#à × Ñ 8Ó $ô ~ô ô Yô ð $Ð tÓ #ñ #Ð#?Ó @Ð *Ó @ð
|
õ #àgdÐ$4°dÓ;Ò;ð Ù $ TÐ+;¸TÓ BÐ Cð D Ø *mð -ð ñ
|
#Ó Ð ð <ô<ô ô ô ôô ð NNCØ×ÑØ×ÑØ×ÑØ×Ñð Ð ôWô ôgô ô
|
wô ð
|
XÑ Ø :¨v°wÀÐ Iò /DØò /Ù 4§:¡:Õ.ñ/ð/ñ
|
4Ð#Ô$Ø×,Ñ,ÐØ}}HØ×$Ñ$LØ
|
((CØ JJEð ÙÛÝ-å0çPÕPß@Ñ@ØIÓ ð ð ð ó ð nÓ ØCEÐ@Ó EØGIÐ
|
DÓ IØ >Ó Ø13Ð
|
.Ó 3Ø13Ð
|
.Ó 3ð
|
(Ò*#°ó ò ð2 I ó
|
,ó ,ó )ó .ð ó*óZð@ GIð(Ø
|
ð(Ø ð(Ø(+ð(Ø4Cð(à.ó(ð4 GIð(Ø
|
ð(Ø ð(Ø(+ð(Ø4Cð(à.ó(÷:'Lñ 'LðTQØ
|
FðQàóQô.hô .÷ p&'ñ p&'ônM ô ô CGGô ó( ð, 56ð.1Ø
|
ð.1à
|
%ð.1ð 2ð.1ð ó .1ðj ð +Ø
|
ð+à
|
ð+ð 5ð+ð ð +ð
|
ð +ð ó +ðd ð ;;Ø
|
ð;;à
|
ð;;ð )ð;;ð ð ;;ð
|
ð ;;ð ó ;;ô|$Xô $ô $ (ô $ôT=ðn1Ø $ð1Ø,/ð1Ø7Fð1à
|
ó1óh"ó#ðð c5 "Ð%ðð c3 Ð&ð ð
|
c5 "Ð%ð ð c6 2Ð&ð ð c7 BÐ'ðð c7 BÐ'ðð c8 RÐ(ðð c6 2Ð&ðð c7 BÐ'ðð c7 BÐ'ðð c8 RÐ(ðð c7 BÐ'ð ð c8 RÐ(ð ð c7 BÐ'ð!ð" c8 RÐ(ð#ð$ t d¨D \Ð2ð%ð& Ò'>Ð?ð'ð( Ò)AÐBà y^Ð s C¨nØ y^Ð s C¨nñ/Ð ó6
|
ð. Ø26ðy&Ø"ðy&à
|
ðy&ð 0ðy&ð ó y&ó@ :ó 7ó.ó" ó CðJ 48ð Ø ð ð $ð ð 1ð ð
|
ó ó. ð
|
Ø ð
|
ØDð
|
à ó
|
ð "Ø ð "ØDð "à ó "ó .ó *óó
|
ó
|
ó"%ð GØ
|
ð GØ#Dð GØORð Gà
|
ó Gó 8ó4ó4ô .ñ> Ô Ø × Ò Ô !ñ Ø s CxÑ(Ià IôL9õ Løðqw ò ØKðûðT ò
|
á
|
1v×ÑÐ/Ô0ð Ø MØ ô
|
ð
|
ñ
|
Q× Ñ Ð3Ô 4Ø c!fnÔ-ð
|
ûð
|
ús+ Á<S Ã+S ÓS Ó S ÓT6ÓA T1Ô1T6
|
