archive.git - Gitblit

Ë  
³òúhÉfãó.ddlmZddlZddlZddlZddlmZddlmZm    Z    m
Z
mZddlm Z mZmZd$dZd%dZd&d    Z                d'                                            d(dZ                d)                                                            d*dZej*j,f                            d+d Zej*j,f                            d+dZej*j,ddf                                            d,dZd-d.dZej*j,f                            d/dZGdde    «Zej*j:f                            d0dZd1d2dZ        d3                            d4dZ ej*j,ddf                                            d5dZ!d6dZ"d6dZ#d6dZ$d6dZ%d7dZ&d8d9dZ'ed:d «Z(ed
d!                    d;d"«Z(d
d!d<d#Z(y)=é)ÚannotationsN)ÚSequence)ÚLiteralÚProtocolÚcastÚoverloadé)ÚExifTagsÚImageÚImagePalettecót|t«r/t|«dk(r|x\}}\}}nt|«dk(r|\}}}}n|x}x}x}}fS)Néé)Ú
isinstanceÚtupleÚlen)ÚborderÚleftÚtopÚrightÚbottoms     ú?H:\Change_password\venv_build\Lib\site-packages\PIL/ImageOps.pyÚ_borderr!sgÜ&%Ô Üv;!ÒØ(.Ð.ID# vÜ [AÒ Ø'-Ñ$D#ufà&,Ð,Ð,sÐ,UVØeVÐ#Ð#ócóVt|t«rddlm}|j    ||«}|S)Nr    )Ú
ImageColor)rÚstrÚrÚgetcolor)ÚcolorÚmoders   rÚ_colorr",s&Ü%ÔÝ à×#Ñ# E¨4Ó0ØLrcóö|jdk(r d}t|«|jdvr6|jdk(rt|«dk(r||z|z}|j|«Sd|j}t    |«)NÚPzmode P support coming soon)ÚLÚRGBr&éznot supported for mode )r!ÚNotImplementedErrorrÚpointÚOSError)ÚimageÚlutÚmsgs   rÚ_lutr.4svØzzSÒà*Ü! #Ó&Ð&Ø    |Ñ    #Ø::Ò¤3 s£8¨s¢?Ø)c/CØ{{3ÓÐà'¨¯
©
 |Ð4ÜclÐrFcó|r!|jd«j|«}n|j|«}g}tdt|«d«D]ª}|||dz}|"t    |t
«rd||<n|D]}    d||    <    |rÐt    |t«s||f}d}
td«D]
}    |
||    z}
t|
|dzdz«}td«D].}|||kDr|||z
}d||<n||xx|zcc<d}|dks.nt|
|dzdz«}tddd«D].} ||| kDr||| z
}d|| <n|| xx|zcc<d}|dks.ntd«D]    }||s    ntddd«D]    } || s    n kr%|jttd«««\d| |z
z}||z}td«D]3}    t|    |z|z«}    |    dkrd}    n|    dkDrd}    |j|    «5t||«S)    aÙ
    Maximize (normalize) image contrast. This function calculates a
    histogram of the input image (or mask region), removes ``cutoff`` percent of the
    lightest and darkest pixels from the histogram, and remaps the image
    so that the darkest pixel becomes black (0), and the lightest
    becomes white (255).
 
    :param image: The image to process.
    :param cutoff: The percent to cut off from the histogram on the low and
                   high ends. Either a tuple of (low, high), or a single
                   number for both.
    :param ignore: The background pixel value (use None for no background).
    :param mask: Histogram used in contrast operation is computed using pixels
                 within the mask. If no mask is given the entire image is used
                 for histogram computation.
    :param preserve_tone: Preserve image tone in Photoshop-like style autocontrast.
 
                          .. versionadded:: 8.2.0
 
    :return: An image.
    r%rr'édr    éÿéÿÿÿÿgào@)ÚconvertÚ    histogramÚrangerrÚintrÚextendÚlistÚappendr.)r+ÚcutoffÚignoreÚmaskÚ preserve_toner4r,ÚlayerÚhÚixÚnÚcutÚloÚhiÚscaleÚoffsets                rÚautocontrastrGFswñ8ØMM #Ó&×0Ñ0°Ó6    àOO DÓ)    à
CÜq#i.¨#Ó.ó:Øee ckÐ*ØÐä&¤#Ô&Ø&    à òBØAbEðáäf¤eÔ,Ø  &Ð)àAÜCjò Ø"Ið ôa& )m sÑ*Ó+CÜCjò Ø2;Ø  "¡+CØAbEàbESLEØCØ!8Ùð ôa& )m sÑ*Ó+CÜC  RÓ(ò Ø2;Ø  "¡+CØAbEàbESLEØCØ!8Ùð ô*ò    BØuÙð    ôR Ó$ò    BØuÙð    ð8àJJtE #JÓ'Ö(àR "WÑ%EØS5[FÜCjò Üe fÑ,Ó-Ø6ØBØ#XØBØ

2ò  ði:ôvsÓÐrcó¶|jdk(sJ|d|cxkr|cxkrdks!JJd|cxkr|cxkr|cxkrdksJJtttt    |d««}tttt    |d««}|!tttt    |d««nd}    g}
g}g}t|«D]>} |
j |d«|j |d«|j |d«@|    ¤t||z
«}|D]} |
j |d| |d|dz
zt|«zz«|j |d| |d|dz
zt|«zz«|j |d| |d|dz
zt|«zz«nDt||z
«}t||z
«}|D]} |
j |d| |    d|dz
zt|«zz«|j |d| |    d|dz
zt|«zz«|j |d| |    d|dz
zt|«zz«|D]} |
j |    d| |d|    dz
zt|«zz«|j |    d| |d|    dz
zt|«zz«|j |    d| |d|    dz
zt|«zz«td|z
«D]>} |
j |d«|j |d«|j |d«@|jd«}t||
|z|z«S)    a
    Colorize grayscale image.
    This function calculates a color wedge which maps all black pixels in
    the source image to the first color and all white pixels to the
    second color. If ``mid`` is specified, it uses three-color mapping.
    The ``black`` and ``white`` arguments should be RGB tuples or color names;
    optionally you can use three-color mapping by also specifying ``mid``.
    Mapping positions for any of the colors can be specified
    (e.g. ``blackpoint``), where these parameters are the integer
    value corresponding to where the corresponding color should be mapped.
    These parameters must have logical order, such that
    ``blackpoint <= midpoint <= whitepoint`` (if ``mid`` is specified).
 
    :param image: The image to colorize.
    :param black: The color to use for black input pixels.
    :param white: The color to use for white input pixels.
    :param mid: The color to use for midtone input pixels.
    :param blackpoint: an int value [0, 255] for the black mapping.
    :param whitepoint: an int value [0, 255] for the white mapping.
    :param midpoint: an int value [0, 255] for the midtone mapping.
    :return: An image.
    r%Nrr1r&r    rr')
r!rrr6r"r5r9rr3r.)r+ÚblackÚwhiteÚmidÚ
blackpointÚ
whitepointÚmidpointÚ    rgb_blackÚ    rgb_whiteÚrgb_midÚredÚgreenÚblueÚiÚ    range_mapÚ
range_map1Ú
range_map2s                 rÚcolorizerY¦s¨ðB::ÒÐÐØ
{ØJÔ3 *Ô3°Ò3Ð3Ñ3Ð3Ð3àJÔ? (Ô?¨jÔ?¸CÒ?Ð?Ñ?Ð?Ð?ôXc]¤F¨5°%Ó$8Ó9IÜXc]¤F¨5°%Ó$8Ó9IØ9<¸d8C=¤&¨¨eÓ"4Ô5ÈdGð CØEØ Dô:Ó ò"Ø

9Q<Ô Ø Yq\Ô"ØIaLÕ!ð"ðÜ* zÑ1Ó2    àò        AØJJØ!q I¨a¡L°9¸Q±<Ñ$?Ñ@ÄCÈ    ÃNÑRÑRô ð LLØ!q I¨a¡L°9¸Q±<Ñ$?Ñ@ÄCÈ    ÃNÑRÑRô ð KKØ!q I¨a¡L°9¸Q±<Ñ$?Ñ@ÄCÈ    ÃNÑRÑRõ ò        ô8 jÑ0Ó1
Ü:¨Ñ0Ó1
àò        AØJJØ!q G¨A¡J°¸1±Ñ$=Ñ>Ä#ÀjÃ/ÑQÑQô ð LLØ!q G¨A¡J°¸1±Ñ$=Ñ>Ä#ÀjÃ/ÑQÑQô ð KKØ!q G¨A¡J°¸1±Ñ$=Ñ>Ä#ÀjÃ/ÑQÑQõ ð        ðò    YAØJJwqz A¨°1©¸À¹
Ñ)BÑ$CÄsÈ:ÃÑ$VÑVÔWØLLØ
Q )¨A¡,°¸±Ñ";Ñ<ÄÀJÃÑOÑOô ð KK 
 Q¨)°A©,¸À¹Ñ*CÑ%DÌÈJËÑ%WÑWÕXð    Yô3Ñ#Ó $ò"Ø

9Q<Ô Ø Yq\Ô"ØIaLÕ!ð"ð MM%Ó EÜsU{ TÑ)Ó*Ð*rcób|j|jz}|d|dz}||k7rt||kDr8t|j|jz|dz«}||dk7r?|d|f}n7t|j|jz|dz«}||dk7r||df}|j||¬«S)aí
    Returns a resized version of the image, set to the maximum width and height
    within the requested size, while maintaining the original aspect ratio.
 
    :param image: The image to resize.
    :param size: The requested output size in pixels, given as a
                 (width, height) tuple.
    :param method: Resampling method to use. Default is
                   :py:attr:`~PIL.Image.Resampling.BICUBIC`.
                   See :ref:`concept-filters`.
    :return: An image.
    rr    ©Úresample©ÚwidthÚheightÚroundÚresize©r+ÚsizeÚmethodÚim_ratioÚ
dest_ratioÚ
new_heightÚ    new_widths       rÚcontainri ó¿ð {{U\\Ñ)HØa4 7Ñ"Jà:ÒØjÒ Üu||¨e¯k©kÑ9¸DÀ¹GÑCÓDJØT !WÒ$ØQ Ð,äekk¨E¯L©LÑ8¸4À¹7ÑBÓCIØD GÒ#Ø! 4¨¡7Ð+Ø<< v<Ó.Ð.rcób|j|jz}|d|dz}||k7rt||kr8t|j|jz|dz«}||dk7r?|d|f}n7t|j|jz|dz«}||dk7r||df}|j||¬«S)aÕ
    Returns a resized version of the image, so that the requested size is
    covered, while maintaining the original aspect ratio.
 
    :param image: The image to resize.
    :param size: The requested output size in pixels, given as a
                 (width, height) tuple.
    :param method: Resampling method to use. Default is
                   :py:attr:`~PIL.Image.Resampling.BICUBIC`.
                   See :ref:`concept-filters`.
    :return: An image.
    rr    r[r]rbs       rÚcoverrl,rjr)çà?rmc
ó2t|||«}|j|k(r|}|Stj|j||«}|j
r#|j «}||j|«|j|dk7rKt|d|jz
tdt|dd««z«}|j||df«|St|d|jz
tdt|dd««z«}    |j|d|    f«|S)at
    Returns a resized and padded version of the image, expanded to fill the
    requested aspect ratio and size.
 
    :param image: The image to resize and crop.
    :param size: The requested output size in pixels, given as a
                 (width, height) tuple.
    :param method: Resampling method to use. Default is
                   :py:attr:`~PIL.Image.Resampling.BICUBIC`.
                   See :ref:`concept-filters`.
    :param color: The background color of the padded image.
    :param centering: Control the position of the original image within the
                      padded version.
 
                          (0.5, 0.5) will keep the image centered
                          (0, 0) will keep the image aligned to the top left
                          (1, 1) will keep the image aligned to the bottom
                          right
    :return: An image.
    rr    )rircrÚnewr!ÚpaletteÚ
getpaletteÚ
putpaletter^r`ÚmaxÚminÚpaster_)
r+rcrdr Ú    centeringÚresizedÚoutrpÚxÚys
          rÚpadr{Ksô8eT 6Ó*GØ||tÒØðJôii

 D¨%Ó0Ø??Ø×(Ñ(Ó*GØÐ"ØwÔ'Ø==D GÒ#ÜtAw §¡Ñ.´#°a¼¸YÀq¹\È1Ó9MÓ2NÑNÓOAØIIg  1vÔ&ðJôtAw §¡Ñ/´3°q¼#¸iÈ¹lÈAÓ:NÓ3OÑOÓPAØIIg  1vÔ&ØJrcót|«\}}}}|j|||jd|z
|jd|z
f«S)a/
    Remove border from image.  The same amount of pixels are removed
    from all four sides.  This function works on all image modes.
 
    .. seealso:: :py:meth:`~PIL.Image.Image.crop`
 
    :param image: The image to crop.
    :param border: The number of pixels to remove.
    :return: An image.
    rr    )rÚcroprc)r+rrrrrs      rr}r}ysHô ' vÑD#ufØ::tS %§*¡*¨Q¡-°%Ñ"7¸¿¹ÀA¹ÈÑ9OÐPÓQÐQrcóÔ|dk(r|j«S|dkr d}t|«t||jz«t||jz«f}|j||«S)aá
    Returns a rescaled image by a specific factor given in parameter.
    A factor greater than 1 expands the image, between 0 and 1 contracts the
    image.
 
    :param image: The image to rescale.
    :param factor: The expansion factor, as a float.
    :param resample: Resampling method to use. Default is
                     :py:attr:`~PIL.Image.Resampling.BICUBIC`.
                     See :ref:`concept-filters`.
    :returns: An :py:class:`~PIL.Image.Image` object.
    r    rz!the factor must be greater than 0)ÚcopyÚ
ValueErrorr`r^r_ra)r+Úfactorr\r-rcs     rrErEsdð{Øzz|ÐØ    1Ø1ÜoÐäfu{{Ñ*Ó+¬U°6¸E¿L¹LÑ3HÓ-IÐJØ||D (Ó+Ð+rcó eZdZdZ                ddZy)ÚSupportsGetMeshaE
    An object that supports the ``getmesh`` method, taking an image as an
    argument, and returning a list of tuples. Each tuple contains two tuples,
    the source box as a tuple of 4 integers, and a tuple of 8 integers for the
    final quadrilateral, in order of top left, bottom left, bottom right, top
    right.
    cóy©N©)Úselfr+s  rÚgetmeshzSupportsGetMesh.getmeshªsðrN)r+úImage.ImageÚreturnzUlist[tuple[tuple[int, int, int, int], tuple[int, int, int, int, int, int, int, int]]])Ú__name__Ú
__module__Ú__qualname__Ú__doc__rrrrrr¡sñðØ ðð
ôrrcó|j|jtjj|j|«|«S)aL
    Deform the image.
 
    :param image: The image to deform.
    :param deformer: A deformer object.  Any object that implements a
                    ``getmesh`` method can be used.
    :param resample: An optional resampling filter. Same values possible as
       in the PIL.Image.transform function.
    :return: An image.
    )Ú    transformrcrÚ    TransformÚMESHr)r+Údeformerr\s   rÚdeformr±s7ð??Ø 

EOO×(Ñ(¨(×*:Ñ*:¸5Ó*AÀ8óðrcób|jdk(r|jd«}|j|«}g}tdt    |«d«D]Ó}|||dzDcgc]}|s|    }}t    |«dkr$|jt td«««Mtjtj|«|dz
dz}|s$|jt td««« |dz}td«D]!}    |j||z«|||    |zz}#Õt||«Scc}w)    a
    Equalize the image histogram. This function applies a non-linear
    mapping to the input image, in order to create a uniform
    distribution of grayscale values in the output image.
 
    :param image: The image to equalize.
    :param mask: An optional mask.  If given, only the pixels selected by
                 the mask are included in the analysis.
    :return: An image.
    r$r&rr'r    r2r1r) r!r3r4r5rr7r8Ú    functoolsÚreduceÚoperatorÚaddr9r.)
r+r<r?r,ÚbÚ_fÚhistoÚsteprArUs
          rÚequalizerÅsð zzSÒØ  eÓ$Ø ÓAØ
CÜ 1c!fcÓ "ò%Ø  A¨¡GnÖ3²Ð3Ð3Üu:?ØJJtE #JÓ'Õ(ä×$Ñ$¤X§\¡\°5Ó9¸EÀ"¹IÑEÈ#ÑMDÙØ

4¤ c£
Ó+Õ,àAIÜsò%AØJJq DyÔ)ØAa !eHAñ%ð%ôsÓÐùò4sÁD,ÁD,có^t|«\}}}}||jdz|z}||jdz|z}t||j«}    |jry|jj}
tj
|
|j |
««}t|    t«r0t|    «dk(st|    «dk(r|j|    «}    nd}tj|j||f|    «}|r|j|j
«|j|||f«|S)zÖ
    Add border to the image
 
    :param image: The image to expand.
    :param border: Border width, in pixels.
    :param fill: Pixel fill value (a color value).  Default is 0 (black).
    :return: An image.
    rr    érN)rrcr"r!rprrqrrrrrrorrru) r+rÚfillrrrrr^r_r r!rprxs              rÚexpandr¢äsô ' vÑD#ufØ5::a=Ñ  5Ñ(EØ 5::a=Ñ   6Ñ )FÜ4Ó$EØ}}Ø}}×!Ñ!Ü×+Ñ+¨D°%×2BÑ2BÀ4Ó2HÓIÜeUÔ#¬¨U«°qª¼CÀ»JÈ!ºOØ×$Ñ$ UÓ+EàÜ
))EJJ ¨ °Ó
7CÙØw¨Ô-ØIIedC[Ô!ØJrçcó|\}}d|cxkrdksnd}d|cxkrdksnd}d|cxkrdksnd}||jdz||jdzf}|jd|ddzz
|jd|ddzz
f}|d|dz}    |d|dz}
|    |
k(r|d}|d}n |    |
k\r|
|dz}|d}n |d}|d|
z}|d|d|z
|zz} |d|d|z
|zz}| || |z||zf}|j|||¬«S)a
    Returns a resized and cropped version of the image, cropped to the
    requested aspect ratio and size.
 
    This function was contributed by Kevin Cazabon.
 
    :param image: The image to resize and crop.
    :param size: The requested output size in pixels, given as a
                 (width, height) tuple.
    :param method: Resampling method to use. Default is
                   :py:attr:`~PIL.Image.Resampling.BICUBIC`.
                   See :ref:`concept-filters`.
    :param bleed: Remove a border around the outside of the image from all
                  four edges. The value is a decimal percentage (use 0.01 for
                  one percent). The default value is 0 (no border).
                  Cannot be greater than or equal to 0.5.
    :param centering: Control the cropping position.  Use (0.5, 0.5) for
                      center cropping (e.g. if cropping the width, take 50% off
                      of the left side, and therefore 50% off the right side).
                      (0.0, 0.0) will crop from the top left corner (i.e. if
                      cropping the width, take all of the crop off of the right
                      side, and if cropping the height, take all of it off the
                      bottom).  (1.0, 0.0) will crop from the bottom left
                      corner, etc. (i.e. if cropping the width, take all of the
                      crop off the left side, and if cropping the height take
                      none from the top, and therefore all off the bottom).
    :return: An image.
    r£gð?rmrr    r)Úbox)rcra)r+rcrdÚbleedrvÚcentering_xÚcentering_yÚbleed_pixelsÚ    live_sizeÚlive_size_ratioÚoutput_ratioÚ
crop_widthÚcrop_heightÚ    crop_leftÚcrop_topr}s                rÚfitr±sðP )ÑKà+Ô$ Ô$ØØ+Ô$ Ô$Øà%Ô#ÔØðEJJ qMÑ)¨5°5·:±:¸a±=Ñ+@ÐALð    

1  Q¨!Ñ+Ñ+Ø 

1  Q¨!Ñ+Ñ+ðIð  l Y¨q¡\Ñ1Oð7T !WÑ$Lð,Ò&àq\
Ø lØ    LÒ    (à! I¨a¡LÑ0
Ø lðq\
Ø l \Ñ1ðQ 9¨Q¡<°*Ñ#<ÀÑ"KÑKIØA )¨A¡,°Ñ"<ÀÑ!KÑKHàx ¨ZÑ!7¸ÀKÑ9OÐPDð<<f¨$<Ó/Ð/rcóT|jtjj«S)zq
    Flip the image vertically (top to bottom).
 
    :param image: The image to flip.
    :return: An image.
    )Ú    transposerÚ    TransposeÚFLIP_TOP_BOTTOM©r+s rÚflipr·^óð??5??×:Ñ:Ó;Ð;rcó$|jd«S)zi
    Convert the image to grayscale.
 
    :param image: The image to convert.
    :return: An image.
    r%)r3r¶s rÚ    grayscalerºhsð==ÓÐrcóttddd««}|jdk(r|j|«St    ||«S)zc
    Invert (negate) the image.
 
    :param image: The image to invert.
    :return: An image.
    r1r2Ú1)r8r5r!r)r.)r+r,s  rÚinvertr½rs=ôuS"bÓ!Ó
"CØ$zz¨SÒ05;;sÓÐF´d¸5À#Ó6FÐFrcóT|jtjj«S)zq
    Flip image horizontally (left to right).
 
    :param image: The image to mirror.
    :return: An image.
    )r³rr´ÚFLIP_LEFT_RIGHTr¶s rÚmirrorrÀ}r¸rcórdd|z
zdz
}td«Dcgc]}||z    }}t||«Scc}w)zÁ
    Reduce the number of bits for each color channel.
 
    :param image: The image to posterize.
    :param bits: The number of bits to keep for each channel (1-8).
    :return: An image.
    rér    r')r5r.)r+Úbitsr<rUr,s     rÚ    posterizerÄsFð1t8_qÑ  Ð!DÜ" 3ZÖ
(1t8Ð
(CÐ
(ÜsÓÐùò)s4cóg}td«D]-}||kr|j|«|jd|z
«/t||«S)z¿
    Invert all pixel values above a threshold.
 
    :param image: The image to solarize.
    :param threshold: All pixels above this grayscale level are inverted.
    :return: An image.
    r'r1)r5r9r.)r+Ú    thresholdr,rUs    rÚsolarizerÇsMð CÜ 3Zò Øy=ØJJqMàJJsQwÕð     ô
sÓÐrcóyrr©r+Úin_places  rÚexif_transposerË¥sØLOr)rÊcóyrrrÉs  rrËrË©sðrcó®
|j«|j«}|jtjj
d«}tjjtjjtjjtjjtjjtjjtjjdj|«}|´|r<|jj!|«|_|jj"|_n|j!|«}|r|n}|j«}tjj
|vr-|tjj
=d|j&vr|j)«|j&d<n9d|j&vr+|j)«j+«|j&d<dD]¨}||j&vsdD]
|j&|}    t-|    t.«rt1j2
d|    «}    nJt-|    t4«rt5
fd    |    D««}    n%t1j2
j7«d
|    «}    |    |j&|<ª|sSy|s|j9«Sy)a
    If an image has an EXIF Orientation tag, other than 1, transpose the image
    accordingly, and remove the orientation data.
 
    :param image: The image to transpose.
    :param in_place: Boolean. Keyword-only argument.
        If ``True``, the original image is modified in-place, and ``None`` is returned.
        If ``False`` (default), a new :py:class:`~PIL.Image.Image` object is returned
        with the transposition applied. If there is no transposition, a copy of the
        image will be returned.
    r    )rr rééérÂNÚexifzRaw profile type exif)zXML:com.adobe.xmpÚxmp)ztiff:Orientation="([0-9])"z,<tiff:Orientation>([0-9])</tiff:Orientation>rc3óhK|])}tjj«d|«+yw)rN)ÚreÚsubÚencode)Ú.0ÚvÚpatterns  rú    <genexpr>z!exif_transpose.<locals>.<genexpr>às*øèøò*ØEF¤§¡ w§~¡~Ó'7¸¸a× @ñ*ùs/2r)ÚloadÚgetexifÚgetr
ÚBaseÚOrientationrr´r¿Ú
ROTATE_180rµÚ    TRANSPOSEÚ
ROTATE_270Ú
TRANSVERSEÚ    ROTATE_90Úimr³rcÚ_sizeÚinfoÚtobytesÚhexrrrÔrÕrrÖr)r+rÊÚ
image_exifÚorientationrdÚtransposed_imageÚ
exif_imagerÑÚkeyÚvaluerÙs          @rrËrË¯s/øð
JJLØJØ..¤§¡×!:Ñ!:¸AÓ>Kä??×*Ñ*Ü??×%Ñ%Ü??×*Ñ*Ü??×$Ñ$Ü??×%Ñ%Ü??×%Ñ%Ü??×$Ñ$ñ÷
c+ÓððÑÙØxx×)Ñ)¨&Ó1EHØ((--EKà$¨vÓ6ÐÙ&UÐ,<
à×!Ñ!Ó#Ü==×$Ñ$¨Ò,ØX]]×.Ñ.Ð/ØÑ(Ø*.¯,©,«.
 Ò'Ø(¨J¯O©OÑ;Ø;?¿<¹<»>×;MÑ;MÓ;O
Ð 7Ñ8Ø3ò 5Ø*//Ò)ð$ò 5ð!+§¡°Ñ 4Ü% e¬SÔ1Ü$&§F¡F¨7°B¸Ó$>EÜ'¨¬uÔ5Ü$)ó*ØJOô*ó%Eô%'§F¡F¨7¯>©>Ó+;¸SÀ%Ó$HEØ/4
¨Ò,ñ 5ð 5ñ Ø#Ð#ðñØzz|ÐØr)rúint | tuple[int, ...]rztuple[int, int, int, int])r ústr | int | tuple[int, ...]r!rrrð)r+rr,z    list[int]rr)rNNF)r+rr:zfloat | tuple[float, float]r;zint | Sequence[int] | Noner<úImage.Image | Noner=Úboolrr)Nrr1é)r+rrIústr | tuple[int, ...]rJrõrKú"str | int | tuple[int, ...] | NonerLr6rMr6rNr6rr)r+rrcútuple[int, int]rdr6rr)r+rrcr÷rdr6r rörvútuple[float, float]rr)r)r+rrr6rr)r+rrÚfloatr\r6rr)r+rrrr\r6rrr)r+rr<ròrr)rr)r+rrrðr¡rñrr)r+rrcr÷rdr6r¦rùrvrørr)r+rrr)r+rrÃr6rr)é)r+rrÆr6rr)r+rrÊz Literal[True]rÚNone)r+rrÊzLiteral[False]rr)r+rrÊrórrò))Ú
__future__rrrrÔÚcollections.abcrÚtypingrrrrrr
rrrr"r.rGrYÚ
ResamplingÚBICUBICrirlr{r}rErÚBILINEARrrr¢r±r·rºr½rÀrÄrÇrËrrrú<module>rs1ðõ&#ãÛÛ    Ý$ß4Ó4ç+Ñ+ó$óóð(+,Ø)-Ø#Øð]Øð]à'ð]ð 'ð]ðð    ]ð
ð]ðó ]ðH/3ØØØðd+Øðd+à ðd+ð!ðd+ð
,ð    d+ð
ðd+ðð d+ððd+ðód+ðP>C×=MÑ=M×=UÑ=Uð/Øð/Ø-ð/Ø7:ð/àó/ð@>C×=MÑ=M×=UÑ=Uð/Øð/Ø-ð/Ø7:ð/àó/ðD×"Ñ"×*Ñ*Ø04Ø%/ð+Øð+à
ð+ð ð+ð.ð    +ð
#ð+ðó +ô\Rð 8=×7GÑ7G×7OÑ7Oð,Øð,Ø %ð,Ø14ð,àó,ô2 hô ð&×$Ñ$×-Ñ-ðØðàððððó    ô(ðB%&Ø()ðØðà!ðð&ððó    ðD×"Ñ"×*Ñ*ØØ%/ðX0ØðX0à
ðX0ð ðX0ðð    X0ð
#ðX0ðó X0óv<óóGó<ó
ôð"
ÚOó
ØOð
à6;ñØðØ%3ðàòó
ðð
<Aö;r